indicate where you are while not in editing mode and ability to move through current focus items, help image

flizzer_tracker.c

@@ -25,14 +25,13 @@ void draw_callback(Canvas* canvas, void* ctx) {
         return;
     }
 
-    canvas_set_custom_u8g2_font(canvas, u8g2_font_tom_thumb_4x6_tr);
-
-    /*char buffer[33];
-    snprintf(buffer, sizeof(buffer), "%ld", (tracker->sound_engine.counter & 8191));
-    canvas_draw_str(canvas, 0, 29, buffer);
+    if(tracker->showing_help)
+    {
+        canvas_draw_icon(canvas, 0, 0, &I_help);
+        return;
+    }
 
-    snprintf(buffer, sizeof(buffer), "%ld", (tracker->tracker_engine.counter & 8191));
-    canvas_draw_str(canvas, 18, 29, buffer);*/
+    canvas_set_custom_u8g2_font(canvas, u8g2_font_tom_thumb_4x6_tr);
 
     switch(tracker->mode) {
     case PATTERN_VIEW: {

flizzer_tracker.h

@@ -139,6 +139,7 @@ typedef enum {
     SUBMENU_PATTERN_LOAD_SONG,
     SUBMENU_PATTERN_SAVE_SONG,
     SUBMENU_PATTERN_SETTINGS,
+    SUBMENU_PATTERN_HELP,
     SUBMENU_PATTERN_EXIT,
 } PatternSubmenuParams;
 
@@ -186,6 +187,7 @@ typedef struct {
 
     bool is_loading;
     bool is_saving;
+    bool showing_help;
 
     bool quit;
 

flizzer_tracker_hal.h

@@ -32,6 +32,7 @@ void sound_engine_dma_init(uint32_t address, uint32_t size);
 void sound_engine_PWM_timer_init(bool external_audio_output);
 void sound_engine_set_audio_output(bool external_audio_output);
 void tracker_engine_init_hardware(uint8_t rate);
+void tracker_engine_timer_init(uint8_t rate);
 void tracker_engine_set_rate(uint8_t rate);
 void sound_engine_start();
 void sound_engine_stop();

init_deinit.c

@@ -102,6 +102,8 @@ FlizzerTrackerApp* init_tracker(
         tracker);
     submenu_add_item(
         tracker->pattern_submenu, "Settings", SUBMENU_PATTERN_SETTINGS, submenu_callback, tracker);
+        submenu_add_item(
+        tracker->pattern_submenu, "Help", SUBMENU_PATTERN_HELP, submenu_callback, tracker);
     submenu_add_item(
         tracker->pattern_submenu, "Exit", SUBMENU_PATTERN_EXIT, submenu_callback, tracker);
 

input/instrument.c

@@ -397,8 +397,7 @@ void instrument_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* even
         return;
     }
 
-    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort) {
         switch(tracker->selected_param) {
         default: {
             tracker->current_digit++;
@@ -450,8 +449,7 @@ void instrument_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* even
         }
     }
 
-    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort) {
         switch(tracker->selected_param) {
         default: {
             tracker->current_digit--;

input/pattern.c

@@ -249,13 +249,19 @@ void edit_pattern_step(FlizzerTrackerApp* tracker, TrackerSongPatternStep* step,
 }
 
 void pattern_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
-    if(event->input.key == InputKeyDown && event->input.type == InputTypeLong &&
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeLong &&
        !(tracker->editing)) {
         flipbit(
             tracker->tracker_engine.channel[tracker->current_channel].channel_flags, TEC_DISABLED);
         return;
     }
 
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeLong &&
+       !(tracker->editing)) {
+        tracker->tracker_engine.pattern_position = tracker->tracker_engine.song->pattern_length - 1; // return to pattern 1st row
+        return;
+    }
+
     if(event->input.key == InputKeyUp && event->input.type == InputTypeLong &&
        !(tracker->editing)) {
         tracker->tracker_engine.pattern_position = 0; // return to pattern 1st row
@@ -317,8 +323,7 @@ void pattern_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         }
     }
 
-    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort) {
         tracker->patternx++;
 
         if(tracker->patternx > MAX_PATTERNX - 1) {
@@ -332,8 +337,7 @@ void pattern_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         }
     }
 
-    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort) {
         tracker->patternx--;
 
         if(tracker->patternx > MAX_PATTERNX - 1) // unsigned int overflow

input/sequence.c

@@ -75,8 +75,7 @@ void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         tracker->editing = !tracker->editing;
     }
 
-    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort) {
         tracker->current_digit++;
 
         if(tracker->current_digit > 1) {
@@ -90,8 +89,7 @@ void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         }
     }
 
-    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort) {
         tracker->current_digit--;
 
         if(tracker->current_digit > 1) // unsigned int overflow
@@ -141,7 +139,7 @@ void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         }
     }
 
-    if(event->input.key == InputKeyUp && event->input.type == InputTypeLong &&
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeLong &&
        !(tracker->editing)) // set loop begin or loop end for the song
     {
         TrackerSong* song = &tracker->song;
@@ -162,7 +160,7 @@ void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         }
     }
 
-    if(event->input.key == InputKeyDown && event->input.type == InputTypeLong &&
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeLong &&
        !(tracker->editing)) // erase loop begin and loop end points
     {
         TrackerSong* song = &tracker->song;
@@ -170,6 +168,18 @@ void sequence_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         song->loop_start = song->loop_end = 0;
     }
 
+    if(event->input.key == InputKeyUp && event->input.type == InputTypeLong &&
+       !(tracker->editing)) // jump to the beginning
+    {
+        tracker->tracker_engine.sequence_position = 0;
+    }
+
+    if(event->input.key == InputKeyDown && event->input.type == InputTypeLong &&
+       !(tracker->editing)) // jump to the end
+    {
+        tracker->tracker_engine.sequence_position = tracker->song.num_sequence_steps - 1;
+    }
+
     if(event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
        tracker->editing) {
         delete_sequence_step(tracker);

input/songinfo.c

@@ -117,8 +117,7 @@ void songinfo_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         tracker->editing = !tracker->editing;
     }
 
-    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyRight && event->input.type == InputTypeShort) {
         switch(tracker->selected_param) {
         default: {
             tracker->current_digit++;
@@ -152,8 +151,7 @@ void songinfo_edit_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event)
         }
     }
 
-    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort &&
-       tracker->editing) {
+    if(event->input.key == InputKeyLeft && event->input.type == InputTypeShort) {
         switch(tracker->selected_param) {
         default: {
             tracker->current_digit--;

input_event.c

@@ -123,6 +123,12 @@ void submenu_callback(void* context, uint32_t index) {
             break;
         }
 
+        case SUBMENU_PATTERN_HELP: {
+            tracker->showing_help = true;
+            view_dispatcher_switch_to_view(tracker->view_dispatcher, VIEW_TRACKER);
+            break;
+        }
+
         case SUBMENU_PATTERN_SAVE_SONG: {
             text_input_set_header_text(tracker->text_input, "Song filename:");
             memset(&tracker->filename, 0, FILE_NAME_LEN);
@@ -266,6 +272,13 @@ void cycle_view(FlizzerTrackerApp* tracker) {
 }
 
 void process_input_event(FlizzerTrackerApp* tracker, FlizzerTrackerEvent* event) {
+    if(event->input.key == InputKeyBack && event->input.type == InputTypeShort && tracker->showing_help) {
+        tracker->showing_help = false;
+        return;
+    }
+
+    if(tracker->showing_help || tracker->is_loading || tracker->is_saving) return; //do not react until these are finished
+
     if(event->input.key == InputKeyBack && event->input.type == InputTypeShort &&
        event->period > 0 && event->period < 300 && !(tracker->editing)) {
         cycle_view(tracker);

tracker_engine/tracker_engine.c

@@ -468,7 +468,7 @@ void tracker_engine_advance_tick(TrackerEngine* tracker_engine) {
 
     uint16_t opcode = 0;
 
-    for(int chan = 0; chan < SONG_MAX_CHANNELS; ++chan) {
+    for(uint8_t chan = 0; chan < SONG_MAX_CHANNELS; chan++) {
         SoundEngineChannel* se_channel = &tracker_engine->sound_engine->channel[chan];
         TrackerEngineChannel* te_channel = &tracker_engine->channel[chan];
 
@@ -518,7 +518,6 @@ void tracker_engine_advance_tick(TrackerEngine* tracker_engine) {
                 else if(
                     pinst && note != MUS_NOTE_RELEASE && note != MUS_NOTE_CUT &&
                     note != MUS_NOTE_NONE) {
-                    // te_channel->slide_speed = 0;
 
                     uint8_t prev_adsr_volume = se_channel->adsr.volume;
 

util.c

@@ -7,13 +7,28 @@ void reset_buffer(SoundEngine* sound_engine) {
     }
 }
 
+void stop_song(FlizzerTrackerApp* tracker) {
+    tracker->tracker_engine.playing = false;
+    tracker->editing = tracker->was_editing;
+
+    for(int i = 0; i < SONG_MAX_CHANNELS; i++) {
+        tracker->sound_engine.channel[i].adsr.volume = 0;
+        tracker->tracker_engine.channel[i].channel_flags &= ~(TEC_PROGRAM_RUNNING);
+    }
+
+    stop();
+}
+
 void play_song(FlizzerTrackerApp* tracker, bool from_cursor) {
+    stop_song(tracker);
+    
     reset_buffer(&tracker->sound_engine);
 
     sound_engine_dma_init(
         (uint32_t)tracker->sound_engine.audio_buffer, tracker->sound_engine.audio_buffer_size);
 
     tracker->tracker_engine.playing = true;
+
     tracker->was_editing = tracker->editing;
     tracker->editing = false;
 
@@ -21,7 +36,7 @@ void play_song(FlizzerTrackerApp* tracker, bool from_cursor) {
         tracker->tracker_engine.pattern_position = 0;
     }
 
-    tracker_engine_set_rate(tracker->song.rate);
+    tracker_engine_timer_init(tracker->song.rate);
 
     tracker->tracker_engine.current_tick = 0;
     tracker_engine_set_song(&tracker->tracker_engine, &tracker->song);
@@ -29,17 +44,6 @@ void play_song(FlizzerTrackerApp* tracker, bool from_cursor) {
     play();
 }
 
-void stop_song(FlizzerTrackerApp* tracker) {
-    tracker->tracker_engine.playing = false;
-    tracker->editing = tracker->was_editing;
-
-    for(int i = 0; i < SONG_MAX_CHANNELS; i++) {
-        tracker->sound_engine.channel[i].adsr.volume = 0;
-    }
-
-    stop();
-}
-
 bool is_pattern_empty(TrackerSong* song, uint8_t pattern) {
     TrackerSongPattern song_pattern = song->pattern[pattern];
 

view/instrument_editor.c

@@ -28,6 +28,16 @@ void draw_inst_flag(
             canvas_draw_box(canvas, x + 5, y - 6, strlen(text) * 4 + 1, 7);
         }
     }
+
+    if(tracker->focus == focus && tracker->selected_param == param && !(tracker->editing)) {
+        if(text[strlen(text) - 1] == ':') {
+            canvas_draw_frame(canvas, x + 5, y - 6, strlen(text) * 4 - 1, 7);
+        }
+
+        else {
+            canvas_draw_frame(canvas, x + 5, y - 6, strlen(text) * 4 + 1, 7);
+        }
+    }
 }
 
 void draw_inst_text_one_digit(
@@ -48,6 +58,10 @@ void draw_inst_text_one_digit(
     if(tracker->focus == focus && tracker->selected_param == param && tracker->editing) {
         canvas_draw_box(canvas, x + strlen(text) * 4 - 3, y - 6, 5, 7);
     }
+
+    if(tracker->focus == focus && tracker->selected_param == param && !(tracker->editing)) {
+        canvas_draw_frame(canvas, x + strlen(text) * 4 - 3, y - 6, 5, 7);
+    }
 }
 
 void draw_inst_text_two_digits(
@@ -69,6 +83,11 @@ void draw_inst_text_two_digits(
         canvas_draw_box(
             canvas, x + strlen(text) * 4 + 4 * tracker->current_digit - 3, y - 6, 5, 7);
     }
+
+    if(tracker->focus == focus && tracker->selected_param == param && !(tracker->editing)) {
+        canvas_draw_frame(
+            canvas, x + strlen(text) * 4 + 4 * tracker->current_digit - 3, y - 6, 5, 7);
+    }
 }
 
 static const char* filter_types[] = {
@@ -164,6 +183,17 @@ void draw_instrument_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
             }
         }
 
+        if(!(tracker->editing) && tracker->focus == EDIT_INSTRUMENT &&
+           tracker->selected_param == INST_CURRENT_NOTE) {
+            if(tracker->current_digit) {
+                canvas_draw_frame(canvas, 19 + 2 * 4, 5 - shift, 5, 7);
+            }
+
+            else {
+                canvas_draw_frame(canvas, 19, 5 - shift, 5 + 4, 7);
+            }
+        }
+
         snprintf(buffer, sizeof(buffer), "FINE:%+02d", inst->finetune);
         canvas_draw_str(canvas, 37, 11 - shift, buffer);
 
@@ -177,6 +207,17 @@ void draw_instrument_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
                 canvas_draw_box(canvas, 60, 5 - shift, 5, 7);
             }
         }
+
+        if(!(tracker->editing) && tracker->focus == EDIT_INSTRUMENT &&
+           tracker->selected_param == INST_FINETUNE) {
+            if(tracker->current_digit) {
+                canvas_draw_frame(canvas, 60 + 4, 5 - shift, 5, 7);
+            }
+
+            else {
+                canvas_draw_frame(canvas, 60, 5 - shift, 5, 7);
+            }
+        }
     }
 
     draw_inst_text_two_digits(
@@ -314,6 +355,12 @@ void draw_instrument_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
             canvas, 19, 35 - shift, strlen(filter_types[inst->filter_type]) * 4 + 1, 7);
     }
 
+    if(!(tracker->editing) && tracker->focus == EDIT_INSTRUMENT &&
+       tracker->selected_param == INST_FILTERTYPE) {
+        canvas_draw_frame(
+            canvas, 19, 35 - shift, strlen(filter_types[inst->filter_type]) * 4 + 1, 7);
+    }
+
     draw_inst_flag(
         tracker,
         canvas,

view/opcode_description.c

@@ -2,6 +2,15 @@
 #include <stdint.h>
 
 static const OpcodeDescription opcode_desc[] = {
+    {TE_PROGRAM_LOOP_BEGIN, 0x7f00, "PROGRAM LOOP BEGIN", "L.BEG."},
+    {TE_PROGRAM_LOOP_END, 0x7f00, "PROGRAM LOOP END", "L.END"},
+
+    {TE_PROGRAM_NOP, 0x7fff, "NO OPERATION", ""},
+    {TE_PROGRAM_END, 0x7fff, "PROGRAM END", "PR.END"},
+    {TE_PROGRAM_JUMP, 0x7f00, "JUMP TO POSITION", "GOTO"},
+
+    //====================================================
+
     {TE_EFFECT_ARPEGGIO, 0x7f00, "RELATIVE ARPEGGIO NOTE", ""},
     {TE_EFFECT_PORTAMENTO_UP, 0x7f00, "PORTAMENTO UP", "PORTUP"},
     {TE_EFFECT_PORTAMENTO_DOWN, 0x7f00, "PORTAMENTO DOWN", "PORTDN"},
@@ -49,13 +58,6 @@ static const OpcodeDescription opcode_desc[] = {
     {TE_EFFECT_LEGATO, 0x7f00, "LEGATO", "LEGATO"},
     {TE_EFFECT_ARPEGGIO_ABS, 0x7f00, "ABSOLUTE ARPEGGIO NOTE", ""},
     {TE_EFFECT_TRIGGER_RELEASE, 0x7f00, "TRIGGER RELEASE", "TR.REL"},
-
-    {TE_PROGRAM_LOOP_BEGIN, 0x7f00, "PROGRAM LOOP BEGIN", "L.BEG."},
-    {TE_PROGRAM_LOOP_END, 0x7f00, "PROGRAM LOOP END", "L.END"},
-
-    {TE_PROGRAM_NOP, 0x7fff, "NO OPERATION", ""},
-    {TE_PROGRAM_END, 0x7fff, "PROGRAM END", "PR.END"},
-    {TE_PROGRAM_JUMP, 0x7f00, "JUMP TO POSITION", "GOTO"},
     {0, 0, NULL, NULL},
 };
 

view/pattern_editor.c

@@ -140,6 +140,14 @@ void draw_pattern_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
         canvas_draw_box(canvas, x, y, (tracker->patternx > 0 ? 5 : 9), 7);
     }
 
+    if(!(tracker->editing) && tracker->focus == EDIT_PATTERN) {
+        uint16_t x = tracker->current_channel * 32 + tracker->patternx * 4 +
+                     (tracker->patternx > 0 ? 4 : 0) - 1;
+        uint16_t y = PATTERN_EDITOR_Y + 6 * 2 + 1;
+
+        canvas_draw_frame(canvas, x, y, (tracker->patternx > 0 ? 5 : 9), 7);
+    }
+
     canvas_set_color(canvas, ColorBlack);
 
     for(int i = 1; i < SONG_MAX_CHANNELS; ++i) {
@@ -240,6 +248,13 @@ void draw_sequence_view(Canvas* canvas, FlizzerTrackerApp* tracker) {
 
         canvas_draw_box(canvas, x, y, 5, 7);
     }
+
+    if(!(tracker->editing) && tracker->focus == EDIT_SEQUENCE) {
+        uint8_t x = tracker->current_channel * (4 + 4 + 1) + (tracker->current_digit ? 4 : 0) + 2;
+        uint8_t y = 11;
+
+        canvas_draw_frame(canvas, x, y, 5, 7);
+    }
 }
 
 #define member_size(type, member) sizeof(((type*)0)->member)
@@ -305,6 +320,41 @@ void draw_generic_n_digit_field(
             canvas_draw_box(canvas, x - 1, y - 6, fmax(5, strlen(text) * 4 + 1), 7);
         }
     }
+
+    if(tracker->focus == focus && tracker->selected_param == param && !(tracker->editing)) {
+        bool select_string = true;
+
+        if(tracker->focus == EDIT_SONGINFO) {
+            if(param != SI_SONGNAME && param != SI_INSTRUMENTNAME) {
+                select_string = false;
+            }
+        }
+
+        if(tracker->focus == EDIT_INSTRUMENT) {
+            if(param != INST_INSTRUMENTNAME) {
+                select_string = false;
+            }
+        }
+
+        if(!(select_string)) {
+            if(tracker->focus == EDIT_INSTRUMENT && param == INST_CURRENTINSTRUMENT) {
+                canvas_draw_frame(canvas, x + strlen(text) * 4 - digits * 4 - 1, y - 6, 5, 7);
+            }
+
+            else {
+                canvas_draw_frame(
+                    canvas,
+                    x + strlen(text) * 4 - digits * 4 + tracker->current_digit * 4 - 1,
+                    y - 6,
+                    5,
+                    7);
+            }
+        }
+
+        else {
+            canvas_draw_frame(canvas, x - 1, y - 6, fmax(5, strlen(text) * 4 + 1), 7);
+        }
+    }
 }
 
 void draw_songinfo_view(Canvas* canvas, FlizzerTrackerApp* tracker) {