wirtz
/
MicroDexed
mirror of https://codeberg.org/dcoredump/MicroDexed.git
1
1
Fork 0
Code Issues Releases Wiki Activity

Fixes for LCDMenuLib2.

Browse Source 
Fixes for displaying changes values (via MIDI) on display.
pull/32/head
Holger Wirtz 4 years ago
parent cc1380701a
commit 743dc51f42
9 changed files with 485 additions and 438 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 12
      MicroDexed.ino
  2. 290
      UI.hpp
  3. 7
      third-party/LCDMenuLib2/keywords.txt
  4. 527
      third-party/LCDMenuLib2/src/LCDMenuLib2.cpp
  5. 61
      third-party/LCDMenuLib2/src/LCDMenuLib2.h
  6. 2
      third-party/LCDMenuLib2/src/LCDMenuLib2_macros.h
  7. 10
      third-party/LCDMenuLib2/src/LCDMenuLib2_menu.cpp
  8. 10
      third-party/LCDMenuLib2/src/LCDMenuLib2_menu.h
  9. 4
      third-party/LCDMenuLib2/src/LCDMenuLib2_typedef.h

12
MicroDexed.ino
Unescape View File

@ -701,6 +701,9 @@ void handleControlChange(byte inChannel, byte inCtrl, byte inValue)
MicroDexed[instance_id]->setMonoMode(false);
break;
}
LCDML.OTHER_updateFunc();
LCDML.loop_menu();
}
}
}
@ -742,6 +745,9 @@ void handleProgramChange(byte inChannel, byte inProgram)
#ifdef DISPLAY_LCD_SPI
change_disp_sd(true);
#endif
LCDML.OTHER_updateFunc();
LCDML.loop_menu();
}
}
}
@ -888,6 +894,9 @@ void handleSystemExclusive(byte * sysex, uint len)
break;
}
MicroDexed[instance_id]->controllers.refresh();
LCDML.OTHER_updateFunc();
LCDML.loop_menu();
}
#ifdef DEBUG
else
@ -952,6 +961,9 @@ void handleSystemExclusive(byte * sysex, uint len)
// load sysex-data into voice memory
MicroDexed[instance_id]->loadVoiceParameters(&sysex[6]);
LCDML.OTHER_updateFunc();
LCDML.loop_menu();
/*
// manipulate UI names and numbers
strncpy(voice_name[instance_id], (char *)&sysex[151], sizeof(voice_name[instance_id]) - 1);

290
UI.hpp
Unescape View File

@ -363,9 +363,6 @@ class EncoderDirection
bool down;
};
#define g_LCDML_CONTROL_button_long_press LONG_BUTTON_PRESS
#define g_LCDML_CONTROL_button_short_press BUT_DEBOUNCE_MS
//Encoder ENCODER[NUM_ENCODER] = {Encoder(ENC_R_PIN_B, ENC_R_PIN_A), Encoder(ENC_L_PIN_B, ENC_L_PIN_A)};
MD_REncoder ENCODER[NUM_ENCODER] = {MD_REncoder(ENC_R_PIN_B, ENC_R_PIN_A), MD_REncoder(ENC_L_PIN_B, ENC_L_PIN_A)};
EncoderDirection encoderDir[NUM_ENCODER];
@ -546,7 +543,7 @@ void lcdml_menu_control(void)
g_LCDML_CONTROL_button_press_time[ENC_R] = millis();
//Reset for left right action
}
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_R]) >= g_LCDML_CONTROL_button_long_press)
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_R]) >= LONG_BUTTON_PRESS)
{
#ifdef DEBUG
Serial.println("ENC-R long");
@ -554,16 +551,15 @@ void lcdml_menu_control(void)
//LCDML.BT_quit();
encoderDir[ENC_R].ButtonLong(true);
/*
if (LCDML.FUNC_getID() < 0xff)
LCDML.FUNC_setGBAToLastFunc();
else
LCDML.FUNC_setGBAToLastCursorPos();
*/
LCDML.FUNC_setGBA();
if (LCDML.FUNC_getID() < 0xff)
LCDML.FUNC_setGBAToLastFunc();
else
LCDML.FUNC_setGBAToLastCursorPos();
//LCDML.FUNC_setGBA();
LCDML.OTHER_jumpToFunc(UI_func_voice_select);
}
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_R]) >= g_LCDML_CONTROL_button_short_press)
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_R]) >= BUT_DEBOUNCE_MS)
{
#ifdef DEBUG
Serial.println(F("ENC-R short"));
@ -644,7 +640,7 @@ void lcdml_menu_control(void)
g_LCDML_CONTROL_button_press_time[ENC_L] = millis();
//Reset for left right action
}
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_L]) >= g_LCDML_CONTROL_button_long_press)
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_L]) >= LONG_BUTTON_PRESS)
{
#ifdef DEBUG
Serial.println(F("ENC-L long"));
@ -654,7 +650,7 @@ void lcdml_menu_control(void)
for (uint8_t i = 0; i < NUM_DEXED; i++)
MicroDexed[i]->panic();
}
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_L]) >= g_LCDML_CONTROL_button_short_press)
else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_L]) >= BUT_DEBOUNCE_MS)
{
//LCDML.BT_enter();
#ifdef DEBUG
@ -837,12 +833,11 @@ void UI_func_reverb_roomsize(uint8_t param)
configuration.fx.reverb_roomsize = constrain(configuration.fx.reverb_roomsize + ENCODER[ENC_R].speed(), REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.reverb_roomsize = constrain(configuration.fx.reverb_roomsize - ENCODER[ENC_R].speed(), REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX);
lcd_display_bar_int("Reverb Room", configuration.fx.reverb_roomsize, 1.0, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 3, false, false, false, false);
freeverb_r.roomsize(mapfloat(configuration.fx.reverb_roomsize, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 0.0, 1.0));
freeverb_l.roomsize(mapfloat(configuration.fx.reverb_roomsize, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 0.0, 1.0));
}
lcd_display_bar_int("Reverb Room", configuration.fx.reverb_roomsize, 1.0, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 3, false, false, false, false);
freeverb_r.roomsize(mapfloat(configuration.fx.reverb_roomsize, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 0.0, 1.0));
freeverb_l.roomsize(mapfloat(configuration.fx.reverb_roomsize, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 0.0, 1.0));
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -871,12 +866,12 @@ void UI_func_reverb_damping(uint8_t param)
configuration.fx.reverb_damping = constrain(configuration.fx.reverb_damping + ENCODER[ENC_R].speed(), REVERB_DAMPING_MIN, REVERB_DAMPING_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.reverb_damping = constrain(configuration.fx.reverb_damping - ENCODER[ENC_R].speed(), REVERB_DAMPING_MIN, REVERB_DAMPING_MAX);
}
lcd_display_bar_int("Reverb Damp.", configuration.fx.reverb_damping, 1.0, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 3, false, false, false, false);
lcd_display_bar_int("Reverb Damp.", configuration.fx.reverb_damping, 1.0, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 3, false, false, false, false);
freeverb_r.damping(mapfloat(configuration.fx.reverb_damping, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 0.0, 1.0));
freeverb_l.damping(mapfloat(configuration.fx.reverb_damping, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 0.0, 1.0));
}
freeverb_r.damping(mapfloat(configuration.fx.reverb_damping, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 0.0, 1.0));
freeverb_l.damping(mapfloat(configuration.fx.reverb_damping, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 0.0, 1.0));
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -910,12 +905,12 @@ void UI_func_reverb_send(uint8_t param)
configuration.dexed[instance_id].reverb_send = constrain(configuration.dexed[instance_id].reverb_send + ENCODER[ENC_R].speed(), REVERB_SEND_MIN, REVERB_SEND_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].reverb_send = constrain(configuration.dexed[instance_id].reverb_send - ENCODER[ENC_R].speed(), REVERB_SEND_MIN, REVERB_SEND_MAX);
}
lcd_display_bar_int("Reverb Send", configuration.dexed[instance_id].reverb_send, 1.0, REVERB_SEND_MIN, REVERB_SEND_MAX, 3, false, false, false, false);
lcd_display_bar_int("Reverb Send", configuration.dexed[instance_id].reverb_send, 1.0, REVERB_SEND_MIN, REVERB_SEND_MAX, 3, false, false, false, false);
reverb_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].reverb_send / 100.0);
reverb_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].reverb_send / 100.0);
}
reverb_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].reverb_send / 100.0);
reverb_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].reverb_send / 100.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -949,12 +944,12 @@ void UI_func_reverb_level(uint8_t param)
configuration.fx.reverb_level = constrain(configuration.fx.reverb_level + ENCODER[ENC_R].speed(), REVERB_LEVEL_MIN, REVERB_LEVEL_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.reverb_level = constrain(configuration.fx.reverb_level - ENCODER[ENC_R].speed(), REVERB_LEVEL_MIN, REVERB_LEVEL_MAX);
}
lcd_display_bar_int("Reverb Level", configuration.fx.reverb_level, 1.0, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 3, false, false, false, true);
lcd_display_bar_int("Reverb Level", configuration.fx.reverb_level, 1.0, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 3, false, false, false, true);
master_mixer_r.gain(REVERB, mapfloat(configuration.fx.reverb_level, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 0.0, 1.0));
master_mixer_l.gain(REVERB, mapfloat(configuration.fx.reverb_level, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 0.0, 1.0));
}
master_mixer_r.gain(REVERB, mapfloat(configuration.fx.reverb_level, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 0.0, 1.0));
master_mixer_l.gain(REVERB, mapfloat(configuration.fx.reverb_level, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 0.0, 1.0));
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -983,11 +978,10 @@ void UI_func_chorus_frequency(uint8_t param)
configuration.fx.chorus_frequency = constrain(configuration.fx.chorus_frequency + ENCODER[ENC_R].speed(), CHORUS_FREQUENCY_MIN, CHORUS_FREQUENCY_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.chorus_frequency = constrain(configuration.fx.chorus_frequency - ENCODER[ENC_R].speed(), CHORUS_FREQUENCY_MIN, CHORUS_FREQUENCY_MAX);
lcd_display_bar_float("Chorus Frq.", configuration.fx.chorus_frequency, 0.1, CHORUS_FREQUENCY_MIN, CHORUS_FREQUENCY_MAX, 2, 1, false, false, false, false);
chorus_modulator.frequency(configuration.fx.chorus_frequency / 10.0);
}
lcd_display_bar_float("Chorus Frq.", configuration.fx.chorus_frequency, 0.1, CHORUS_FREQUENCY_MIN, CHORUS_FREQUENCY_MAX, 2, 1, false, false, false, false);
chorus_modulator.frequency(configuration.fx.chorus_frequency / 10.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1058,11 +1052,11 @@ void UI_func_chorus_depth(uint8_t param)
configuration.fx.chorus_depth = constrain(configuration.fx.chorus_depth + ENCODER[ENC_R].speed(), CHORUS_DEPTH_MIN, CHORUS_DEPTH_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.chorus_depth = constrain(configuration.fx.chorus_depth - ENCODER[ENC_R].speed(), CHORUS_DEPTH_MIN, CHORUS_DEPTH_MAX);
}
lcd_display_bar_int("Chorus Dpt.", configuration.fx.chorus_depth, 1.0, CHORUS_DEPTH_MIN, CHORUS_DEPTH_MAX, 3, false, false, false, false);
lcd_display_bar_int("Chorus Dpt.", configuration.fx.chorus_depth, 1.0, CHORUS_DEPTH_MIN, CHORUS_DEPTH_MAX, 3, false, false, false, false);
chorus_modulator.amplitude(configuration.fx.chorus_depth / 100.0);
}
chorus_modulator.amplitude(configuration.fx.chorus_depth / 100.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1096,12 +1090,11 @@ void UI_func_chorus_send(uint8_t param)
configuration.dexed[instance_id].chorus_send = constrain(configuration.dexed[instance_id].chorus_send + ENCODER[ENC_R].speed(), CHORUS_SEND_MIN, CHORUS_SEND_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].chorus_send = constrain(configuration.dexed[instance_id].chorus_send - ENCODER[ENC_R].speed(), CHORUS_SEND_MIN, CHORUS_SEND_MAX);
lcd_display_bar_int("Chorus Send", configuration.dexed[instance_id].chorus_send, 1.0, CHORUS_SEND_MIN, CHORUS_SEND_MAX, 3, false, false, false, false);
chorus_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].chorus_send / 100.0);
chorus_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].chorus_send / 100.0);
}
lcd_display_bar_int("Chorus Send", configuration.dexed[instance_id].chorus_send, 1.0, CHORUS_SEND_MIN, CHORUS_SEND_MAX, 3, false, false, false, false);
chorus_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].chorus_send / 100.0);
chorus_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].chorus_send / 100.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1135,12 +1128,12 @@ void UI_func_chorus_level(uint8_t param)
configuration.fx.chorus_level = constrain(configuration.fx.chorus_level + ENCODER[ENC_R].speed(), CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.chorus_level = constrain(configuration.fx.chorus_level - ENCODER[ENC_R].speed(), CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX);
}
lcd_display_bar_int("Chorus Lvl.", configuration.fx.chorus_level, 1.0, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 3, false, false, false, false);
lcd_display_bar_int("Chorus Lvl.", configuration.fx.chorus_level, 1.0, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 3, false, false, false, false);
master_mixer_r.gain(CHORUS, mapfloat(configuration.fx.chorus_level, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 0.0, 1.0));
master_mixer_l.gain(CHORUS, mapfloat(configuration.fx.chorus_level, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 0.0, 1.0));
}
master_mixer_r.gain(CHORUS, mapfloat(configuration.fx.chorus_level, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 0.0, 1.0));
master_mixer_l.gain(CHORUS, mapfloat(configuration.fx.chorus_level, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 0.0, 1.0));
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1169,12 +1162,12 @@ void UI_func_delay_time(uint8_t param)
configuration.fx.delay_time = constrain(configuration.fx.delay_time + ENCODER[ENC_R].speed(), DELAY_TIME_MIN, DELAY_TIME_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.delay_time = constrain(configuration.fx.delay_time - ENCODER[ENC_R].speed(), DELAY_TIME_MIN, DELAY_TIME_MAX);
}
lcd_display_bar_int("Delay Time", configuration.fx.delay_time, 10.0, DELAY_TIME_MIN, DELAY_TIME_MAX, 3, false, false, false, true);
lcd_display_bar_int("Delay Time", configuration.fx.delay_time, 10.0, DELAY_TIME_MIN, DELAY_TIME_MAX, 3, false, false, false, true);
delay_r.delay(0, configuration.fx.delay_time * 10);
delay_l.delay(0, configuration.fx.delay_time * 10);
}
delay_r.delay(0, configuration.fx.delay_time * 10);
delay_l.delay(0, configuration.fx.delay_time * 10);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1203,13 +1196,13 @@ void UI_func_delay_feedback(uint8_t param)
configuration.fx.delay_feedback = constrain(configuration.fx.delay_feedback + ENCODER[ENC_R].speed(), DELAY_FEEDBACK_MIN, DELAY_FEEDBACK_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.delay_feedback = constrain(configuration.fx.delay_feedback - ENCODER[ENC_R].speed(), DELAY_FEEDBACK_MIN, DELAY_FEEDBACK_MAX);
}
lcd_display_bar_int("Delay Feedb.", configuration.fx.delay_feedback, 1.0, DELAY_FEEDBACK_MIN, DELAY_FEEDBACK_MAX, 3, false, false, false, false);
lcd_display_bar_int("Delay Feedb.", configuration.fx.delay_feedback, 1.0, DELAY_FEEDBACK_MIN, DELAY_FEEDBACK_MAX, 3, false, false, false, false);
delay_fb_mixer_r.gain(1, configuration.fx.delay_feedback / 100.0); // amount of feedback
delay_fb_mixer_l.gain(1, configuration.fx.delay_feedback / 100.0); // amount of feedback
//delay_fb_mixer.gain(0, 1.0 - configuration.fx.delay_feedback / 200.0); // original signal
}
delay_fb_mixer_r.gain(1, configuration.fx.delay_feedback / 100.0); // amount of feedback
delay_fb_mixer_l.gain(1, configuration.fx.delay_feedback / 100.0); // amount of feedback
//delay_fb_mixer.gain(0, 1.0 - configuration.fx.delay_feedback / 200.0); // original signal
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1243,12 +1236,12 @@ void UI_func_delay_send(uint8_t param)
configuration.dexed[instance_id].delay_send = constrain(configuration.dexed[instance_id].delay_send + ENCODER[ENC_R].speed(), DELAY_SEND_MIN, DELAY_SEND_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].delay_send = constrain(configuration.dexed[instance_id].delay_send - ENCODER[ENC_R].speed(), DELAY_SEND_MIN, DELAY_SEND_MAX);
}
lcd_display_bar_int("Delay Send", configuration.dexed[instance_id].delay_send, 1.0, DELAY_SEND_MIN, DELAY_SEND_MAX, 3, false, false, false, false);
lcd_display_bar_int("Delay Send", configuration.dexed[instance_id].delay_send, 1.0, DELAY_SEND_MIN, DELAY_SEND_MAX, 3, false, false, false, false);
delay_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].delay_send / 100.0);
delay_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].delay_send / 100.0);
}
delay_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].delay_send / 100.0);
delay_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].delay_send / 100.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1282,12 +1275,12 @@ void UI_func_delay_level(uint8_t param)
configuration.fx.delay_level = constrain(configuration.fx.delay_level + ENCODER[ENC_R].speed(), DELAY_LEVEL_MIN, DELAY_LEVEL_MAX);
else if (LCDML.BT_checkUp())
configuration.fx.delay_level = constrain(configuration.fx.delay_level - ENCODER[ENC_R].speed(), DELAY_LEVEL_MIN, DELAY_LEVEL_MAX);
}
lcd_display_bar_int("Delay Lvl.", configuration.fx.delay_level, 1.0, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 3, false, false, false, false);
lcd_display_bar_int("Delay Lvl.", configuration.fx.delay_level, 1.0, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 3, false, false, false, false);
master_mixer_r.gain(DELAY, mapfloat(configuration.fx.delay_level, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 0.0, 1.0));
master_mixer_l.gain(DELAY, mapfloat(configuration.fx.delay_level, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 0.0, 1.0));
}
master_mixer_r.gain(DELAY, mapfloat(configuration.fx.delay_level, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 0.0, 1.0));
master_mixer_l.gain(DELAY, mapfloat(configuration.fx.delay_level, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 0.0, 1.0));
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1321,11 +1314,11 @@ void UI_func_filter_cutoff(uint8_t param)
configuration.dexed[instance_id].filter_cutoff = constrain(configuration.dexed[instance_id].filter_cutoff + ENCODER[ENC_R].speed(), FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].filter_cutoff = constrain(configuration.dexed[instance_id].filter_cutoff - ENCODER[ENC_R].speed(), FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX);
}
lcd_display_bar_int("Filter Cut", configuration.dexed[instance_id].filter_cutoff, 1.0, FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX, 3, false, false, false, false);
lcd_display_bar_int("Filter Cut", configuration.dexed[instance_id].filter_cutoff, 1.0, FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX, 3, false, false, false, false);
MicroDexed[instance_id]->fx.Cutoff = mapfloat(configuration.dexed[instance_id].filter_cutoff, FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX, 1.0, 0.0);
}
MicroDexed[instance_id]->fx.Cutoff = mapfloat(configuration.dexed[instance_id].filter_cutoff, FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX, 1.0, 0.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1364,11 +1357,11 @@ void UI_func_filter_resonance(uint8_t param)
configuration.dexed[instance_id].filter_resonance = constrain(configuration.dexed[instance_id].filter_resonance + ENCODER[ENC_R].speed(), FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].filter_resonance = constrain(configuration.dexed[instance_id].filter_resonance - ENCODER[ENC_R].speed(), FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX);
}
lcd_display_bar_int("Filter Res", configuration.dexed[instance_id].filter_resonance, 1.0, FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX, 3, false, false, false, false);
lcd_display_bar_int("Filter Res", configuration.dexed[instance_id].filter_resonance, 1.0, FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX, 3, false, false, false, false);
MicroDexed[instance_id]->fx.Reso = mapfloat(configuration.dexed[instance_id].filter_resonance, FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX, 1.0, 0.0);
}
MicroDexed[instance_id]->fx.Reso = mapfloat(configuration.dexed[instance_id].filter_resonance, FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX, 1.0, 0.0);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1408,12 +1401,12 @@ void UI_func_transpose(uint8_t param)
configuration.dexed[instance_id].transpose = constrain(configuration.dexed[instance_id].transpose + ENCODER[ENC_R].speed(), TRANSPOSE_MIN, TRANSPOSE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].transpose = constrain(configuration.dexed[instance_id].transpose - ENCODER[ENC_R].speed(), TRANSPOSE_MIN, TRANSPOSE_MAX);
}
lcd_display_meter_int("Transpose", configuration.dexed[instance_id].transpose, 1.0, -24.0, TRANSPOSE_MIN, TRANSPOSE_MAX, 3, false, false, true, true);
lcd_display_meter_int("Transpose", configuration.dexed[instance_id].transpose, 1.0, -24.0, TRANSPOSE_MIN, TRANSPOSE_MAX, 3, false, false, true, true);
MicroDexed[instance_id]->data[DEXED_VOICE_OFFSET + DEXED_TRANSPOSE] = configuration.dexed[instance_id].transpose;
MicroDexed[instance_id]->notesOff();
}
MicroDexed[instance_id]->data[DEXED_VOICE_OFFSET + DEXED_TRANSPOSE] = configuration.dexed[instance_id].transpose;
MicroDexed[instance_id]->notesOff();
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1452,12 +1445,12 @@ void UI_func_tune(uint8_t param)
configuration.dexed[instance_id].tune = constrain(configuration.dexed[instance_id].tune + ENCODER[ENC_R].speed(), TUNE_MIN, TUNE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].tune = constrain(configuration.dexed[instance_id].tune - ENCODER[ENC_R].speed(), TUNE_MIN, TUNE_MAX);
}
lcd_display_meter_int("Fine Tune", configuration.dexed[instance_id].tune, 1.0, -100.0, TUNE_MIN, TUNE_MAX, 3, false, false, true, false);
lcd_display_meter_int("Fine Tune", configuration.dexed[instance_id].tune, 1.0, -100.0, TUNE_MIN, TUNE_MAX, 3, false, false, true, false);
MicroDexed[instance_id]->controllers.masterTune = (int((configuration.dexed[instance_id].tune - 100) / 100.0 * 0x4000) << 11) * (1.0 / 12);
MicroDexed[instance_id]->doRefreshVoice();
}
MicroDexed[instance_id]->controllers.masterTune = (int((configuration.dexed[instance_id].tune - 100) / 100.0 * 0x4000) << 11) * (1.0 / 12);
MicroDexed[instance_id]->doRefreshVoice();
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1557,11 +1550,11 @@ void UI_func_lowest_note(uint8_t param)
configuration.dexed[instance_id].lowest_note = constrain(configuration.dexed[instance_id].lowest_note + ENCODER[ENC_R].speed(), INSTANCE_LOWEST_NOTE_MIN, INSTANCE_LOWEST_NOTE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].lowest_note = constrain(configuration.dexed[instance_id].lowest_note - ENCODER[ENC_R].speed(), INSTANCE_LOWEST_NOTE_MIN, INSTANCE_LOWEST_NOTE_MAX);
getNoteName(note_name, configuration.dexed[instance_id].lowest_note);
lcd.setCursor(1, 1);
lcd.print(note_name);
}
getNoteName(note_name, configuration.dexed[instance_id].lowest_note);
lcd.setCursor(1, 1);
lcd.print(note_name);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1605,11 +1598,11 @@ void UI_func_highest_note(uint8_t param)
configuration.dexed[instance_id].highest_note = constrain(configuration.dexed[instance_id].highest_note + ENCODER[ENC_R].speed(), INSTANCE_HIGHEST_NOTE_MIN, INSTANCE_HIGHEST_NOTE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].highest_note = constrain(configuration.dexed[instance_id].highest_note - ENCODER[ENC_R].speed(), INSTANCE_HIGHEST_NOTE_MIN, INSTANCE_HIGHEST_NOTE_MAX);
getNoteName(note_name, configuration.dexed[instance_id].highest_note);
lcd.setCursor(1, 1);
lcd.print(note_name);
}
getNoteName(note_name, configuration.dexed[instance_id].highest_note);
lcd.setCursor(1, 1);
lcd.print(note_name);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1647,12 +1640,10 @@ void UI_func_sound_intensity(uint8_t param)
configuration.dexed[instance_id].sound_intensity = constrain(configuration.dexed[instance_id].sound_intensity + ENCODER[ENC_R].speed(), SOUND_INTENSITY_MIN, SOUND_INTENSITY_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].sound_intensity = constrain(configuration.dexed[instance_id].sound_intensity - ENCODER[ENC_R].speed(), SOUND_INTENSITY_MIN, SOUND_INTENSITY_MAX);
lcd_display_bar_float("Voice Level", float(configuration.dexed[instance_id].sound_intensity), 1.0, SOUND_INTENSITY_MIN, SOUND_INTENSITY_MAX, 3, 0, false, false, false, false);
dexed_level[instance_id]->gain(mapfloat(configuration.dexed[instance_id].sound_intensity, SOUND_INTENSITY_MIN, SOUND_INTENSITY_MAX, 0.0, SOUND_INTENSITY_AMP_MAX));
}
lcd_display_bar_float("Voice Level", float(configuration.dexed[instance_id].sound_intensity), 1.0, SOUND_INTENSITY_MIN, SOUND_INTENSITY_MAX, 3, 0, false, false, false, false);
dexed_level[instance_id]->gain(mapfloat(configuration.dexed[instance_id].sound_intensity, SOUND_INTENSITY_MIN, SOUND_INTENSITY_MAX, 0.0, SOUND_INTENSITY_AMP_MAX));
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1808,11 +1799,11 @@ void UI_func_polyphony(uint8_t param)
configuration.dexed[instance_id].polyphony = constrain(configuration.dexed[instance_id].polyphony + ENCODER[ENC_R].speed(), POLYPHONY_MIN, POLYPHONY_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].polyphony = constrain(configuration.dexed[instance_id].polyphony - ENCODER[ENC_R].speed(), POLYPHONY_MIN, POLYPHONY_MAX);
}
lcd_display_bar_int("Polyphony", configuration.dexed[instance_id].polyphony, 1.0, POLYPHONY_MIN, POLYPHONY_MAX, 3, false, false, false, false);
lcd_display_bar_int("Polyphony", configuration.dexed[instance_id].polyphony, 1.0, POLYPHONY_MIN, POLYPHONY_MAX, 3, false, false, false, false);
MicroDexed[instance_id]->setMaxNotes(configuration.dexed[instance_id].polyphony);
}
MicroDexed[instance_id]->setMaxNotes(configuration.dexed[instance_id].polyphony);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -1851,10 +1842,10 @@ void UI_func_engine(uint8_t param)
configuration.dexed[instance_id].engine = constrain(configuration.dexed[instance_id].engine + 1, ENGINE_MIN, ENGINE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].engine = constrain(configuration.dexed[instance_id].engine - 1, ENGINE_MIN, ENGINE_MAX);
MicroDexed[instance_id]->setEngineType(configuration.dexed[instance_id].engine);
}
MicroDexed[instance_id]->setEngineType(configuration.dexed[instance_id].engine);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].engine)
{
@ -1905,10 +1896,10 @@ void UI_func_mono_poly(uint8_t param)
configuration.dexed[instance_id].monopoly = constrain(configuration.dexed[instance_id].monopoly + 1, MONOPOLY_MIN, MONOPOLY_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].monopoly = constrain(configuration.dexed[instance_id].monopoly - 1, MONOPOLY_MIN, MONOPOLY_MAX);
MicroDexed[instance_id]->setMonoMode(!configuration.dexed[instance_id].monopoly);
}
MicroDexed[instance_id]->setMonoMode(!configuration.dexed[instance_id].monopoly);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].monopoly)
{
@ -1956,10 +1947,10 @@ void UI_func_note_refresh(uint8_t param)
configuration.dexed[instance_id].note_refresh = constrain(configuration.dexed[instance_id].note_refresh + 1, NOTE_REFRESH_MIN, NOTE_REFRESH_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].note_refresh = constrain(configuration.dexed[instance_id].note_refresh - 1, NOTE_REFRESH_MIN, NOTE_REFRESH_MAX);
MicroDexed[instance_id]->setRefreshMode(configuration.dexed[instance_id].note_refresh);
}
MicroDexed[instance_id]->setRefreshMode(configuration.dexed[instance_id].note_refresh);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].note_refresh)
{
@ -2007,11 +1998,11 @@ void UI_func_pb_range(uint8_t param)
configuration.dexed[instance_id].pb_range = constrain(configuration.dexed[instance_id].pb_range + ENCODER[ENC_R].speed(), PB_RANGE_MIN, PB_RANGE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].pb_range = constrain(configuration.dexed[instance_id].pb_range - ENCODER[ENC_R].speed(), PB_RANGE_MIN, PB_RANGE_MAX);
}
lcd_display_bar_int("PB Range", configuration.dexed[instance_id].pb_range, 1.0, PB_RANGE_MIN, PB_RANGE_MAX, 2, false, false, false, false);
lcd_display_bar_int("PB Range", configuration.dexed[instance_id].pb_range, 1.0, PB_RANGE_MIN, PB_RANGE_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setPBController(configuration.dexed[instance_id].pb_range, configuration.dexed[instance_id].pb_step);
}
MicroDexed[instance_id]->setPBController(configuration.dexed[instance_id].pb_range, configuration.dexed[instance_id].pb_step);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2050,11 +2041,11 @@ void UI_func_pb_step(uint8_t param)
configuration.dexed[instance_id].pb_step = constrain(configuration.dexed[instance_id].pb_step + ENCODER[ENC_R].speed(), PB_STEP_MIN, PB_STEP_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].pb_step = constrain(configuration.dexed[instance_id].pb_step - ENCODER[ENC_R].speed(), PB_STEP_MIN, PB_STEP_MAX);
}
lcd_display_bar_int("PB Step", configuration.dexed[instance_id].pb_step, 1.0, PB_STEP_MIN, PB_STEP_MAX, 2, false, false, false, false);
lcd_display_bar_int("PB Step", configuration.dexed[instance_id].pb_step, 1.0, PB_STEP_MIN, PB_STEP_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setPBController(configuration.dexed[instance_id].pb_range, configuration.dexed[instance_id].pb_step);
}
MicroDexed[instance_id]->setPBController(configuration.dexed[instance_id].pb_range, configuration.dexed[instance_id].pb_step);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2093,11 +2084,11 @@ void UI_func_mw_range(uint8_t param)
configuration.dexed[instance_id].mw_range = constrain(configuration.dexed[instance_id].mw_range + ENCODER[ENC_R].speed(), MW_RANGE_MIN, MW_RANGE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].mw_range = constrain(configuration.dexed[instance_id].mw_range - ENCODER[ENC_R].speed(), MW_RANGE_MIN, MW_RANGE_MAX);
}
lcd_display_bar_int("MW Range", configuration.dexed[instance_id].mw_range, 1.0, MW_RANGE_MIN, MW_RANGE_MAX, 2, false, false, false, false);
lcd_display_bar_int("MW Range", configuration.dexed[instance_id].mw_range, 1.0, MW_RANGE_MIN, MW_RANGE_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign, configuration.dexed[instance_id].mw_mode);
}
MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign, configuration.dexed[instance_id].mw_mode);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2136,10 +2127,10 @@ void UI_func_mw_assign(uint8_t param)
configuration.dexed[instance_id].mw_assign = constrain(configuration.dexed[instance_id].mw_assign + 1, MW_ASSIGN_MIN, MW_ASSIGN_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].mw_assign = constrain(configuration.dexed[instance_id].mw_assign - 1, MW_ASSIGN_MIN, MW_ASSIGN_MAX);
MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign, configuration.dexed[instance_id].mw_mode);
}
MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign, configuration.dexed[instance_id].mw_mode);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].mw_assign)
{
@ -2205,11 +2196,11 @@ void UI_func_mw_mode(uint8_t param)
configuration.dexed[instance_id].mw_mode = constrain(configuration.dexed[instance_id].mw_mode + 1, MW_MODE_MIN, MW_MODE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].mw_mode = constrain(configuration.dexed[instance_id].mw_mode - 1, MW_MODE_MIN, MW_MODE_MAX);
MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign, configuration.dexed[instance_id].mw_mode);
MicroDexed[instance_id]->controllers.refresh();
}
MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign, configuration.dexed[instance_id].mw_mode);
MicroDexed[instance_id]->controllers.refresh();
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].mw_mode)
{
@ -2260,11 +2251,11 @@ void UI_func_fc_range(uint8_t param)
configuration.dexed[instance_id].fc_range = constrain(configuration.dexed[instance_id].fc_range + ENCODER[ENC_R].speed(), FC_RANGE_MIN, FC_RANGE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].fc_range = constrain(configuration.dexed[instance_id].fc_range - ENCODER[ENC_R].speed(), FC_RANGE_MIN, FC_RANGE_MAX);
}
lcd_display_bar_int("FC Range", configuration.dexed[instance_id].fc_range, 1.0, FC_RANGE_MIN, FC_RANGE_MAX, 2, false, false, false, false);
lcd_display_bar_int("FC Range", configuration.dexed[instance_id].fc_range, 1.0, FC_RANGE_MIN, FC_RANGE_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign, configuration.dexed[instance_id].fc_mode);
}
MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign, configuration.dexed[instance_id].fc_mode);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2303,10 +2294,10 @@ void UI_func_fc_assign(uint8_t param)
configuration.dexed[instance_id].fc_assign = constrain(configuration.dexed[instance_id].fc_assign + 1, FC_ASSIGN_MIN, FC_ASSIGN_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].fc_assign = constrain(configuration.dexed[instance_id].fc_assign - 1, FC_ASSIGN_MIN, FC_ASSIGN_MAX);
MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign, configuration.dexed[instance_id].fc_mode);
}
MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign, configuration.dexed[instance_id].fc_mode);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].fc_assign)
{
@ -2372,11 +2363,11 @@ void UI_func_fc_mode(uint8_t param)
configuration.dexed[instance_id].fc_mode = constrain(configuration.dexed[instance_id].fc_mode + 1, FC_MODE_MIN, FC_MODE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].fc_mode = constrain(configuration.dexed[instance_id].fc_mode - 1, FC_MODE_MIN, FC_MODE_MAX);
MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign, configuration.dexed[instance_id].fc_mode);
MicroDexed[instance_id]->controllers.refresh();
}
MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign, configuration.dexed[instance_id].fc_mode);
MicroDexed[instance_id]->controllers.refresh();
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].fc_mode)
{
@ -2427,11 +2418,11 @@ void UI_func_bc_range(uint8_t param)
configuration.dexed[instance_id].bc_range = constrain(configuration.dexed[instance_id].bc_range + ENCODER[ENC_R].speed(), BC_RANGE_MIN, BC_RANGE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].bc_range = constrain(configuration.dexed[instance_id].bc_range - ENCODER[ENC_R].speed(), BC_RANGE_MIN, BC_RANGE_MAX);
}
lcd_display_bar_int("BC Range", configuration.dexed[instance_id].bc_range, 1.0, BC_RANGE_MIN, BC_RANGE_MAX, 2, false, false, false, false);
lcd_display_bar_int("BC Range", configuration.dexed[instance_id].bc_range, 1.0, BC_RANGE_MIN, BC_RANGE_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign, configuration.dexed[instance_id].bc_mode);
}
MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign, configuration.dexed[instance_id].bc_mode);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2470,10 +2461,10 @@ void UI_func_bc_assign(uint8_t param)
configuration.dexed[instance_id].bc_assign = constrain(configuration.dexed[instance_id].bc_assign + 1, BC_ASSIGN_MIN, BC_ASSIGN_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].bc_assign = constrain(configuration.dexed[instance_id].bc_assign - 1, BC_ASSIGN_MIN, BC_ASSIGN_MAX);
MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign, configuration.dexed[instance_id].bc_mode);
}
MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign, configuration.dexed[instance_id].bc_mode);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].bc_assign)
{
@ -2539,11 +2530,11 @@ void UI_func_bc_mode(uint8_t param)
configuration.dexed[instance_id].bc_mode = constrain(configuration.dexed[instance_id].bc_mode + 1, BC_MODE_MIN, BC_MODE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].bc_mode = constrain(configuration.dexed[instance_id].bc_mode - 1, BC_MODE_MIN, BC_MODE_MAX);
MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign, configuration.dexed[instance_id].bc_mode);
MicroDexed[instance_id]->controllers.refresh();
}
MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign, configuration.dexed[instance_id].bc_mode);
MicroDexed[instance_id]->controllers.refresh();
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].bc_mode)
{
@ -2594,11 +2585,11 @@ void UI_func_at_range(uint8_t param)
configuration.dexed[instance_id].at_range = constrain(configuration.dexed[instance_id].at_range + ENCODER[ENC_R].speed(), AT_RANGE_MIN, AT_RANGE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].at_range = constrain(configuration.dexed[instance_id].at_range - ENCODER[ENC_R].speed(), AT_RANGE_MIN, AT_RANGE_MAX);
}
lcd_display_bar_int("AT Range", configuration.dexed[instance_id].at_range, 1.0, AT_RANGE_MIN, AT_RANGE_MAX, 2, false, false, false, false);
lcd_display_bar_int("AT Range", configuration.dexed[instance_id].at_range, 1.0, AT_RANGE_MIN, AT_RANGE_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign, configuration.dexed[instance_id].at_mode);
}
MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign, configuration.dexed[instance_id].at_mode);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2637,10 +2628,10 @@ void UI_func_at_assign(uint8_t param)
configuration.dexed[instance_id].at_assign = constrain(configuration.dexed[instance_id].at_assign + 1, AT_ASSIGN_MIN, AT_ASSIGN_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].at_assign = constrain(configuration.dexed[instance_id].at_assign - 1, AT_ASSIGN_MIN, AT_ASSIGN_MAX);
MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign, configuration.dexed[instance_id].at_mode);
}
MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign, configuration.dexed[instance_id].at_mode);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].at_assign)
{
@ -2706,11 +2697,11 @@ void UI_func_at_mode(uint8_t param)
configuration.dexed[instance_id].at_mode = constrain(configuration.dexed[instance_id].at_mode + 1, AT_MODE_MIN, AT_MODE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].at_mode = constrain(configuration.dexed[instance_id].at_mode - 1, AT_MODE_MIN, AT_MODE_MAX);
MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign, configuration.dexed[instance_id].at_mode);
MicroDexed[instance_id]->controllers.refresh();
}
MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign, configuration.dexed[instance_id].at_mode);
MicroDexed[instance_id]->controllers.refresh();
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].at_mode)
{
@ -2761,10 +2752,10 @@ void UI_func_portamento_mode(uint8_t param)
configuration.dexed[instance_id].portamento_mode = constrain(configuration.dexed[instance_id].portamento_mode + 1, PORTAMENTO_MODE_MIN, PORTAMENTO_MODE_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].portamento_mode = constrain(configuration.dexed[instance_id].portamento_mode - 1, PORTAMENTO_MODE_MIN, PORTAMENTO_MODE_MAX);
MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
}
MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].portamento_mode)
{
@ -2818,10 +2809,10 @@ void UI_func_portamento_glissando(uint8_t param)
configuration.dexed[instance_id].portamento_glissando = constrain(configuration.dexed[instance_id].portamento_glissando + 1, PORTAMENTO_GLISSANDO_MIN, PORTAMENTO_GLISSANDO_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].portamento_glissando = constrain(configuration.dexed[instance_id].portamento_glissando - 1, PORTAMENTO_GLISSANDO_MIN, PORTAMENTO_GLISSANDO_MAX);
MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
}
MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
lcd.setCursor(0, 1);
switch (configuration.dexed[instance_id].portamento_glissando)
{
@ -2869,11 +2860,12 @@ void UI_func_portamento_time(uint8_t param)
configuration.dexed[instance_id].portamento_time = constrain(configuration.dexed[instance_id].portamento_time + ENCODER[ENC_R].speed(), PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].portamento_time = constrain(configuration.dexed[instance_id].portamento_time - ENCODER[ENC_R].speed(), PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX);
}
lcd_display_bar_int("Portam. Time", configuration.dexed[instance_id].portamento_time, 1.0, PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX, 2, false, false, false, false);
lcd_display_bar_int("Portam. Time", configuration.dexed[instance_id].portamento_time, 1.0, PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX, 2, false, false, false, false);
MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
}
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -2995,9 +2987,10 @@ void UI_handle_OP(uint8_t param, uint8_t op, uint8_t instance_id)
{
lcd.print(F("[DISABLED]"));
}
MicroDexed[instance_id]->setOPs(configuration.dexed[instance_id].op_enabled);
MicroDexed[instance_id]->doRefreshVoice();
}
MicroDexed[instance_id]->setOPs(configuration.dexed[instance_id].op_enabled);
MicroDexed[instance_id]->doRefreshVoice();
}
if (LCDML.FUNC_close()) // ****** STABLE END *********
@ -3059,6 +3052,7 @@ void UI_func_midi_soft_thru(uint8_t param)
else if (LCDML.BT_checkUp())
configuration.sys.soft_midi_thru = constrain(configuration.sys.soft_midi_thru - 1, SOFT_MIDI_THRU_MIN, SOFT_MIDI_THRU_MAX);
}
lcd.setCursor(0, 1);
switch (configuration.sys.soft_midi_thru)
{
@ -3101,9 +3095,9 @@ void UI_func_velocity_level(uint8_t param)
configuration.dexed[instance_id].velocity_level = constrain(configuration.dexed[instance_id].velocity_level + ENCODER[ENC_R].speed(), VELOCITY_LEVEL_MIN, VELOCITY_LEVEL_MAX);
else if (LCDML.BT_checkUp())
configuration.dexed[instance_id].velocity_level = constrain(configuration.dexed[instance_id].velocity_level - ENCODER[ENC_R].speed(), VELOCITY_LEVEL_MIN, VELOCITY_LEVEL_MAX);
lcd_display_bar_int("Velocity Lvl", configuration.dexed[instance_id].velocity_level, 1.0, VELOCITY_LEVEL_MIN, VELOCITY_LEVEL_MAX, 3, false, false, false, false);
}
lcd_display_bar_int("Velocity Lvl", configuration.dexed[instance_id].velocity_level, 1.0, VELOCITY_LEVEL_MIN, VELOCITY_LEVEL_MAX, 3, false, false, false, false);
}
if (LCDML.FUNC_close()) // ****** STABLE END *********

7
third-party/LCDMenuLib2/keywords.txt vendored
Unescape View File

@ -4,7 +4,7 @@
#
# MIT License
#
# Copyright (c) [2018] [Nils Feldkämper]
# Copyright (c) [2020] [Nils Feldkämper]
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
@ -59,6 +59,9 @@ _LCDML_DISP_cfg_scrollbar LITERAL1
_LCDML_VERSION LITERAL1
_LCDML_NO_FUNC LITERAL1
_LCDML_FIRST_ELEMENT_ID LITERAL1
_LCDML_CONTROL_serial_enter LITERAL1
_LCDML_CONTROL_serial_up LITERAL1
_LCDML_CONTROL_serial_down LITERAL1
@ -271,12 +274,14 @@ FUNC_disableScreensaver KEYWORD2
FUNC_setGBAToLastFunc KEYWORD2
FUNC_setGBAToLastCursorPos KEYWORD2
FUNC_setGBA KEYWORD2
FUNC_setCEMask KEYWORD2
OTHER_jumpToFunc KEYWORD2
OTHER_jumpToID KEYWORD2
OTHER_setCursorToFunc KEYWORD2
OTHER_setCursorToID KEYWORD2
OTHER_getIDFromFunction KEYWORD2
OTHER_updateFunc KEYWORD2
TIMER_ms KEYWORD2
TIMER_msReset KEYWORD2

527
third-party/LCDMenuLib2/src/LCDMenuLib2.cpp vendored
Unescape View File

@ -145,7 +145,7 @@ void LCDMenuLib2::loop_control(void)
// check if a "jumpTo - setCursoTo" function is active
// this check is necessary because there can be a bad timing between a timebased function call or a event and
// another OTHER_...() function.
if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == false)
if(bitRead(REG_special, _LCDML_REG_special_OTHER_function_active) == false)
{
// screensaver handling
// check if the screensaver is enabled and a callback function is defined
@ -256,7 +256,7 @@ void LCDMenuLib2::loop_menu(void)
// local declaration
uint8_t cnt = 0;
uint8_t found = _LCDML_NO_FUNC;
uint8_t found = _LCDML_FIRST_ELEMENT_ID;
LCDMenuLib2_menu *tmp;
// ============================================
@ -372,17 +372,15 @@ void LCDMenuLib2::loop_menu(void)
// ============================================
// jump to handling
// ============================================
if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled))
if(bitRead(REG_special, _LCDML_REG_special_OTHER_function_active))
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - is active"));
MENU_enScroll();
bitClear(REG_special, _LCDML_REG_special_jumpTo_enabled);
bitClear(REG_control, _LCDML_REG_control_dynMenuDisplayed);
bitSet(REG_control, _LCDML_REG_control_disable_hidden);
bitClear(REG_special, _LCDML_REG_special_OTHER_function_active);
bitClear(REG_control, _LCDML_REG_control_dynMenuDisplayed);
// got to root
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
@ -471,7 +469,7 @@ void LCDMenuLib2::loop_menu(void)
}
// check if the last item is reached
if(curMenu->getParent()->getID() == _LCDML_NO_FUNC && curMenu->getSibling(1) == NULL)
if(curMenu->getParent()->getID() == _LCDML_FIRST_ELEMENT_ID && curMenu->getSibling(1) == NULL)
{
break;
}
@ -483,6 +481,9 @@ void LCDMenuLib2::loop_menu(void)
// check childs for childs
if(curMenu->getChild(0) != NULL)
{
// Debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("gointo an element"));
// -- GO INTO --
layer++;
@ -499,10 +500,10 @@ void LCDMenuLib2::loop_menu(void)
else
{
// check parent element
if(curMenu->getParent()->getID() == _LCDML_NO_FUNC)
if(curMenu->getParent()->getID() == _LCDML_FIRST_ELEMENT_ID)
{
// Debug information
DBG_print(LCDML_DBG_function_name_OTHER, F("nothing found: point (A) / ID: "));
DBG_print(LCDML_DBG_function_name_OTHER, F("nothing found: endpoint (A) / ID: "));
DBG_println(LCDML_DBG_function_name_OTHER, curMenu->getID());
}
else
@ -516,7 +517,7 @@ void LCDMenuLib2::loop_menu(void)
layer--;
// Debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("go to parent element"));
DBG_println(LCDML_DBG_function_name_OTHER, F("goback to parent element"));
// check if the parent element have siblings
if(curMenu->getSibling(1) != NULL)
@ -527,7 +528,7 @@ void LCDMenuLib2::loop_menu(void)
}
else
{
if(curMenu->getParent()->getID() == _LCDML_NO_FUNC)
if(curMenu->getParent()->getID() == _LCDML_FIRST_ELEMENT_ID)
{
break;
}
@ -547,20 +548,17 @@ void LCDMenuLib2::loop_menu(void)
}
// check element handling
if(found != _LCDML_NO_FUNC)
if(found != _LCDML_FIRST_ELEMENT_ID)
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - element found"));
tmp = curMenu->getChild(0);
// get the current obj position in this layer
do
{
if(tmp->getID() == found)
{
cursor_pos_abs = cnt;
cursor_obj_pos = cnt;
{
break;
}
else
@ -572,7 +570,11 @@ void LCDMenuLib2::loop_menu(void)
cnt++;
}
while((tmp = tmp->getSibling(1)) != NULL);
// tmp have here the pointer to the right position
// tmp have here the pointer to the right position
//tmp = --pointer_position--
cursor_pos_abs = cnt;
cursor_obj_pos = cnt;
if(bitRead(REG_special, _LCDML_REG_special_setCursorTo) == false)
{
@ -598,7 +600,6 @@ void LCDMenuLib2::loop_menu(void)
// Debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_helpFunction - callbackfunction is hidden, the cursor cannot be set to this possition: go back to root menu"));
bitClear(REG_control, _LCDML_REG_control_disable_hidden);
MENU_goRoot();
}
else
@ -610,8 +611,6 @@ void LCDMenuLib2::loop_menu(void)
// update the menu
DISP_update();
bitClear(REG_control, _LCDML_REG_control_disable_hidden);
// set current cursor possition with hidden elements
tmp = curMenu->getChild(0);
cnt = 0;
@ -619,8 +618,7 @@ void LCDMenuLib2::loop_menu(void)
do
{
if(tmp->checkCondition())
{
//if(obj_pos == cursor_obj_pos)
{
if(tmp->getID() == found)
{
cursor_pos_abs = cnt;
@ -655,8 +653,6 @@ void LCDMenuLib2::loop_menu(void)
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpTo.. / LCDML.OTHER_setCursorTo... - nothing found"));
}
bitClear(REG_control, _LCDML_REG_control_disable_hidden);
}
else
{
@ -674,8 +670,16 @@ void LCDMenuLib2::loop_menu(void)
{
// => do not close the running function
// check if a loop time was set or a button was pressed or the function is called the first time
if(TIMER_ms(menuFunction_loopTimer, actMenu_default_time) == true || bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_setup) == false || BT_checkAny() > 0 || CE_checkAny() > 0)
if( TIMER_ms(menuFunction_loopTimer, actMenu_default_time) == true ||
bitRead(REG_MenuFunction, _LCDML_REG_MenuFunction_setup) == false ||
BT_checkAny() > 0 ||
CE_checkAny() > 0 ||
bitRead(REG_update, _LCDML_REG_update_menu_function_content)
)
{
// reset update flag
bitClear(REG_update, _LCDML_REG_update_menu_function_content);
// call the current menu function
FUNC_call();
}
@ -880,6 +884,9 @@ void LCDMenuLib2::MENU_goRoot(void)
void LCDMenuLib2::MENU_resetActiveMenu(void)
/* ******************************************************************** */
{
// debug information
DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_resetActiveMenu"));
// reset callback function
actMenu_cb_function = NULL;
@ -892,7 +899,8 @@ void LCDMenuLib2::MENU_resetActiveMenu(void)
// reset variables
actMenu_id = _LCDML_NO_FUNC;
actMenu_param = 0;
actMenu_default_time = 100000000;
actMenu_default_time = 0xFFFFFFFF; // 32 Bit
actMenu_ce_mask = 0xFFFFFFFFFFFFFFFF; // 64 Bit
bitClear(REG_control, _LCDML_REG_control_menu_func_active);
}
@ -903,15 +911,87 @@ void LCDMenuLib2::MENU_goBack(void)
// debug information
DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_goBack"));
if(curMenu->getParent() != NULL)
{
//set current menu object
MENU_goMenu(*curMenu->getParent(), true);
//declare variables
LCDMenuLib2_menu *tmp;
uint8_t old_id = 0;
uint8_t j = 0;
uint8_t obj_pos = 0;
bool found_visible = false;
old_id = curMenu->getID();
tmp = curMenu->getParent();
// set the curMenu pointer to a other menu element
curMenu = curMenu->getParent();
// update the layer counter
if(layer > 0)
{
layer--;
}
else
{
// do nothing
}
// init the cursor_position variables to 0
cursor_obj_pos = 0;
cursor_pos_abs = 0;
// get childs from the current menu element
if((tmp = curMenu->getChild(0)) != NULL)
{
// search the current possition of the cursor
do
{
// check conditions
if (tmp->checkCondition())
{
// when the current element id is the same as the old_id the current cursor position is found
if(tmp->getID() == old_id)
{
cursor_pos_abs = j;
cursor_obj_pos = obj_pos;
if(cursor_pos_abs - (window_rows-1) > 0)
{
window_start = cursor_pos_abs-(window_rows-1);
}
else
{
window_start = 0;
}
MENU_doScroll(10);
found_visible = true;
break;
}
else
{
// do nothing
}
// count all visible elements
j++;
}
else
{
// do nothing
}
obj_pos++;
// select the next sibling when it exists
} while ((tmp = tmp->getSibling(1)) != NULL);
if(found_visible == false)
{
MENU_goRoot();
}
}
else
{
// Something is wrong, go to a stable state (root menu)
MENU_goRoot();
}
}
/* ******************************************************************** */
@ -946,9 +1026,20 @@ void LCDMenuLib2::MENU_goInto(void)
{
//check if element has visible children
if(MENU_countChilds(curMenu->getChild(cursor_obj_pos)) > 0)
{
// Menu found, goInto
MENU_goMenu(*curMenu->getChild(cursor_obj_pos), false);
{
// set the curMenu pointer to a other menu element
curMenu = curMenu->getChild(cursor_obj_pos);
// new layer
window_start = 0;
cursor_obj_pos = 0;
cursor_pos_abs = 0;
MENU_initFirstElement();
// update the layer counter
layer++;
BT_resetAll(); // reset all buttons
DISP_update();
}
@ -970,121 +1061,6 @@ void LCDMenuLib2::MENU_goInto(void)
}
}
/* ******************************************************************** */
void LCDMenuLib2::MENU_goMenu(LCDMenuLib2_menu &p_m, uint8_t p_back)
/* ******************************************************************** */
{
// debug information
DBG_println(LCDML_DBG_function_name_MENU, F("LCDML.MENU_goMenu"));
//declare variables
LCDMenuLib2_menu *tmp;
uint8_t old_id = curMenu->getID();
uint8_t j = 0;
uint8_t obj_pos = 0;
boolean found_visible = false;
// check if the menu is opening or closing
if(p_back == false)
{
// set the curMenu pointer to a other menu element
curMenu = &p_m;
// only update the contet when the layer is smaller then 254
if(layer < (_LCDML_NO_FUNC-1))
{
// new layer
window_start = 0;
cursor_obj_pos = 0;
cursor_pos_abs = 0;
MENU_initFirstElement();
// update the layer counter
layer++;
}
else
{
// do nothing
}
}
else
{
// update the layer counter
if(layer > 0)
{
layer--;
}
else
{
// do nothing
}
// set the curMenu pointer to a other menu element
curMenu = &p_m;
// init the cursor_position variables to 0
cursor_obj_pos = 0;
cursor_pos_abs = 0;
// get childs from the current menu element
if((tmp = curMenu->getChild(0)) != NULL)
{
// search the current possition of the cursor
do
{
// check conditions
if (tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_disable_hidden))
{
// when the current element id is the same as the old_id the current cursor position is found
if(tmp->getID() == old_id)
{
cursor_pos_abs = j;
cursor_obj_pos = obj_pos;
if(cursor_pos_abs - (window_rows-1) > 0)
{
window_start = cursor_pos_abs-(window_rows-1);
}
else
{
window_start = 0;
}
MENU_doScroll(10);
found_visible = true;
break;
}
else
{
// do nothing
}
// count all visible elements
j++;
}
else
{
// do nothing
}
obj_pos++;
// select the next sibling when it exists
} while ((tmp = tmp->getSibling(1)) != NULL);
if(found_visible == false)
{
MENU_goRoot();
}
}
else
{
// Something is wrong, go to a stable state (root menu)
MENU_goRoot();
}
}
}
/* ******************************************************************** */
LCDMenuLib2_menu * LCDMenuLib2::MENU_getCurrentObj(void)
@ -1106,14 +1082,18 @@ LCDMenuLib2_menu * LCDMenuLib2::MENU_getRootObj(void)
LCDMenuLib2_menu *tmp;
if(curMenu->getID() != _LCDML_NO_FUNC)
if(curMenu->getID() != _LCDML_FIRST_ELEMENT_ID)
{
tmp = curMenu;
while((tmp = tmp->getParent()) != NULL)
while(true)
{
if(tmp->getID() == _LCDML_NO_FUNC)
{
if(tmp->getID() != _LCDML_FIRST_ELEMENT_ID)
{
tmp = tmp->getParent();
}
else
{
return tmp;
}
}
@ -1218,7 +1198,7 @@ void LCDMenuLib2::MENU_doScroll(uint8_t state)
uint8_t cnt_visible = 0;
uint8_t obj_pos = 0;
uint8_t last_valid_obj_pos = 0;
boolean rollover = false;
bool rollover = false;
//content:
// 0 = scroll up
@ -1526,7 +1506,7 @@ uint8_t LCDMenuLib2::MENU_countChilds(LCDMenuLib2_menu *menu, uint8_t all)
{
do
{
if (tmp->checkCondition() || bitRead(REG_control, _LCDML_REG_control_disable_hidden) || all == true)
if (tmp->checkCondition() || all == true)
{
j++;
}
@ -1573,13 +1553,13 @@ uint8_t LCDMenuLib2::MENU_getParentID(uint8_t p_layer)
{
for(uint8_t i=0; i<p_layer; i++)
{
if(tmp->getParent() != NULL)
if(tmp->getParent()->getID() != _LCDML_FIRST_ELEMENT_ID)
{
tmp = tmp->getParent();
}
else
{
return _LCDML_NO_FUNC;
return _LCDML_FIRST_ELEMENT_ID;
break;
}
}
@ -1588,7 +1568,7 @@ uint8_t LCDMenuLib2::MENU_getParentID(uint8_t p_layer)
}
else
{
return _LCDML_NO_FUNC;
return _LCDML_FIRST_ELEMENT_ID;
}
}
@ -1647,7 +1627,7 @@ void LCDMenuLib2::MENU_disScroll(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::MENU_getScrollDisableStatus(void)
bool LCDMenuLib2::MENU_getScrollDisableStatus(void)
/* ******************************************************************** */
{
// debug information
@ -1689,7 +1669,7 @@ uint8_t LCDMenuLib2::MENU_getElementIDFromCursorPos(void)
}
else
{
return _LCDML_NO_FUNC;
return _LCDML_FIRST_ELEMENT_ID;
}
}
@ -1723,7 +1703,7 @@ void LCDMenuLib2::DISP_clear(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::DISP_checkMenuUpdate(void)
bool LCDMenuLib2::DISP_checkMenuUpdate(void)
/* ******************************************************************** */
{
// debug information
@ -1742,7 +1722,7 @@ boolean LCDMenuLib2::DISP_checkMenuUpdate(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::DISP_checkMenuCursorUpdate(void)
bool LCDMenuLib2::DISP_checkMenuCursorUpdate(void)
/* ******************************************************************** */
{
// debug information
@ -1850,7 +1830,7 @@ void LCDMenuLib2::FUNC_call(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::FUNC_setup(void)
bool LCDMenuLib2::FUNC_setup(void)
/* ******************************************************************** */
{
// debug information
@ -1879,7 +1859,7 @@ boolean LCDMenuLib2::FUNC_setup(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::FUNC_loop(void)
bool LCDMenuLib2::FUNC_loop(void)
/* ******************************************************************** */
{
// debug information
@ -1905,7 +1885,7 @@ boolean LCDMenuLib2::FUNC_loop(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::FUNC_close(void)
bool LCDMenuLib2::FUNC_close(void)
/* ******************************************************************** */
{
// debug information
@ -2020,6 +2000,23 @@ void LCDMenuLib2::FUNC_setGBA(void)
}
}
/* ******************************************************************** */
void LCDMenuLib2::FUNC_setCEMask(unsigned long p_mask)
/* ******************************************************************** */
{
// debug information
DBG_println(LCDML_DBG_function_name_FUNC, F("LCDML.FUNC_setCEMask"));
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
{
actMenu_ce_mask = p_mask;
}
else
{
actMenu_ce_mask = 0xFFFFFFFFFFFFFFFF;
}
}
/* ******************************************************************** */
/* ******************************************************************** */
@ -2029,7 +2026,7 @@ void LCDMenuLib2::FUNC_setGBA(void)
/* ******************************************************************** */
boolean LCDMenuLib2::BT_setup(void)
bool LCDMenuLib2::BT_setup(void)
/* ******************************************************************** */
{
// debug information
@ -2109,7 +2106,7 @@ void LCDMenuLib2::BT_quit(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkAny(void)
bool LCDMenuLib2::BT_checkAny(void)
/* ******************************************************************** */
{
// debug information
@ -2126,7 +2123,7 @@ boolean LCDMenuLib2::BT_checkAny(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkEnter(void)
bool LCDMenuLib2::BT_checkEnter(void)
/* ******************************************************************** */
{
// debug information
@ -2143,7 +2140,7 @@ boolean LCDMenuLib2::BT_checkEnter(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkUp(void)
bool LCDMenuLib2::BT_checkUp(void)
/* ******************************************************************** */
{
// debug information
@ -2160,7 +2157,7 @@ boolean LCDMenuLib2::BT_checkUp(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkDown(void)
bool LCDMenuLib2::BT_checkDown(void)
/* ******************************************************************** */
{
// debug information
@ -2177,7 +2174,7 @@ boolean LCDMenuLib2::BT_checkDown(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkLeft(void)
bool LCDMenuLib2::BT_checkLeft(void)
/* ******************************************************************** */
{
// debug information
@ -2194,7 +2191,7 @@ boolean LCDMenuLib2::BT_checkLeft(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkRight(void)
bool LCDMenuLib2::BT_checkRight(void)
/* ******************************************************************** */
{
// debug information
@ -2211,7 +2208,7 @@ boolean LCDMenuLib2::BT_checkRight(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::BT_checkQuit(void)
bool LCDMenuLib2::BT_checkQuit(void)
/* ******************************************************************** */
{
// debug information
@ -2306,7 +2303,7 @@ void LCDMenuLib2::BT_resetQuit(void)
/* ******************************************************************** */
/* ******************************************************************** */
boolean LCDMenuLib2::CE_setup(void)
bool LCDMenuLib2::CE_setup(void)
/* ******************************************************************** */
{
// debug information
@ -2362,13 +2359,13 @@ void LCDMenuLib2::CE_reset(uint8_t p_event)
}
/* ******************************************************************** */
boolean LCDMenuLib2::CE_checkAny(void)
bool LCDMenuLib2::CE_checkAny(void)
/* ******************************************************************** */
{
// debug information
DBG_println(LCDML_DBG_function_name_CE, F("LCDML.CE_checkAny"));
if(REG_custom_event > 0)
if((REG_custom_event & actMenu_ce_mask) > 0)
{
return true;
}
@ -2379,7 +2376,7 @@ boolean LCDMenuLib2::CE_checkAny(void)
}
/* ******************************************************************** */
boolean LCDMenuLib2::CE_check(uint8_t p_event)
bool LCDMenuLib2::CE_check(uint8_t p_event)
/* ******************************************************************** */
{
// debug information
@ -2440,7 +2437,7 @@ void LCDMenuLib2::TIMER_msReset(unsigned long &p_var)
}
/* ******************************************************************** */
boolean LCDMenuLib2::TIMER_ms(unsigned long &p_var, unsigned long p_t)
bool LCDMenuLib2::TIMER_ms(unsigned long &p_var, unsigned long p_t)
/* ******************************************************************** */
{
// debug information
@ -2468,7 +2465,7 @@ void LCDMenuLib2::TIMER_usReset(unsigned long &p_var)
}
/* ******************************************************************** */
boolean LCDMenuLib2::TIMER_us(unsigned long &p_var, unsigned long p_t)
bool LCDMenuLib2::TIMER_us(unsigned long &p_var, unsigned long p_t)
/* ******************************************************************** */
{
// debug information
@ -2499,43 +2496,52 @@ void LCDMenuLib2::OTHER_jumpToFunc(LCDML_FuncPtr_pu8 p_search, uint8_t p_para)
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc"));
if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true)
if(bitRead(REG_special, _LCDML_REG_special_OTHER_function_active) == true)
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - is still activ"));
}
else
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - start"));
// check if this menu function is active - do nothing
if(p_search == actMenu_cb_function)
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - function is still running"));
}
else
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - start"));
// enable jump to Func
bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled);
bitClear(REG_special, _LCDML_REG_special_setCursorTo);
jT_id = 0;
bitSet(REG_special, _LCDML_REG_special_OTHER_function_active);
bitClear(REG_special, _LCDML_REG_special_setCursorTo);
// Save last active Menu ID
actMenu_lastFuncID = actMenu_id;
// Save last active Menu ID
actMenu_lastFuncID = actMenu_id;
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
{
// handle parameters
jT_paramOld = jT_param;
bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
}
else
{
// handle parameters
jT_paramOld = 0;
bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
{
// handle parameters
jT_paramOld = jT_param;
bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
}
else
{
// handle parameters
jT_paramOld = 0;
bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
// Save last cursor position
actMenu_lastCursorPositionID = actMenu_cursorPositionID;
actMenu_cursorPositionID = curMenu->getChild(MENU_getCursorPosAbs())->getID();
}
// Save last cursor position
actMenu_lastCursorPositionID = actMenu_cursorPositionID;
actMenu_cursorPositionID = curMenu->getChild(MENU_getCursorPosAbs())->getID();
}
jT_param = p_para;
jT_function = p_search;
// enable jump to Func
jT_id = 0;
jT_param = p_para;
jT_function = p_search;
}
}
}
@ -2548,45 +2554,54 @@ void LCDMenuLib2::OTHER_jumpToID(uint8_t p_id, uint8_t p_para)
if(p_id != _LCDML_NO_FUNC)
{
if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true)
if(bitRead(REG_special, _LCDML_REG_special_OTHER_function_active) == true)
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToID - is still activ"));
}
else
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToID - start"));
// enable jump to ID
bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled);
bitClear(REG_special, _LCDML_REG_special_setCursorTo);
jT_id = p_id;
// Save last active Menu ID
actMenu_lastFuncID = actMenu_id;
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
// check if this menu function is active - do nothing
if(p_id == actMenu_id)
{
// handle parameters
jT_paramOld = jT_param;
bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToFunc - function is still running"));
}
else
{
// handle parameters
jT_paramOld = 0;
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_jumpToID - start"));
bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
bitSet(REG_special, _LCDML_REG_special_OTHER_function_active);
bitClear(REG_special, _LCDML_REG_special_setCursorTo);
// Save last cursor position
actMenu_lastCursorPositionID = actMenu_cursorPositionID;
actMenu_cursorPositionID = curMenu->getChild(MENU_getCursorPosAbs())->getID();
// Save last active Menu ID
actMenu_lastFuncID = actMenu_id;
}
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
{
// handle parameters
jT_paramOld = jT_param;
bitClear(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
}
else
{
// handle parameters
jT_paramOld = 0;
jT_param = p_para;
jT_function = NULL;
bitSet(REG_MenuFunction, _LCDML_REG_MenuFunction_called_from_menu);
// Save last cursor position
actMenu_lastCursorPositionID = actMenu_cursorPositionID;
actMenu_cursorPositionID = curMenu->getChild(MENU_getCursorPosAbs())->getID();
}
// enable jump to ID
jT_id = p_id;
jT_param = p_para;
jT_function = NULL;
}
}
}
else
@ -2602,7 +2617,7 @@ void LCDMenuLib2::OTHER_setCursorToFunc(LCDML_FuncPtr_pu8 p_search)
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToFunc"));
if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true)
if(bitRead(REG_special, _LCDML_REG_special_OTHER_function_active) == true)
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToFunc - is still activ"));
@ -2613,7 +2628,7 @@ void LCDMenuLib2::OTHER_setCursorToFunc(LCDML_FuncPtr_pu8 p_search)
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToFunc - start"));
// enable jump to Func
bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled);
bitSet(REG_special, _LCDML_REG_special_OTHER_function_active);
bitSet(REG_special, _LCDML_REG_special_setCursorTo);
jT_id = 0;
@ -2652,7 +2667,7 @@ void LCDMenuLib2::OTHER_setCursorToID(uint8_t p_id)
if(p_id != _LCDML_NO_FUNC)
{
if(bitRead(REG_special, _LCDML_REG_special_jumpTo_enabled) == true)
if(bitRead(REG_special, _LCDML_REG_special_OTHER_function_active) == true)
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToID - is still activ"));
@ -2663,7 +2678,7 @@ void LCDMenuLib2::OTHER_setCursorToID(uint8_t p_id)
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_setCursorToID - start"));
// enable jump to Func
bitSet(REG_special, _LCDML_REG_special_jumpTo_enabled);
bitSet(REG_special, _LCDML_REG_special_OTHER_function_active);
bitSet(REG_special, _LCDML_REG_special_setCursorTo);
jT_id = p_id;
@ -2707,9 +2722,8 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_getIDFromFunction"));
// define local variables
uint8_t step = 0;
LCDMenuLib2_menu *tmp;
// set object
tmp = MENU_getRootObj();
@ -2750,7 +2764,7 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
*/
// check if the last item is reached
if(tmp->getParent()->getID() == _LCDML_NO_FUNC && tmp->getSibling(1) == NULL)
if(tmp->getParent()->getID() == _LCDML_FIRST_ELEMENT_ID && tmp->getSibling(1) == NULL)
{
break;
}
@ -2762,8 +2776,10 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
// check childs for childs
if(tmp->getChild(0) != NULL)
{
// Debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("gointo an element"));
// -- GO INTO --
layer++;
// set next child for check
tmp = tmp->getChild(0);
@ -2778,10 +2794,10 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
else
{
// check parent element
if(tmp->getParent()->getID() == _LCDML_NO_FUNC)
if(tmp->getParent()->getID() == _LCDML_FIRST_ELEMENT_ID)
{
// Debug information
DBG_print(LCDML_DBG_function_name_OTHER, F("nothing found: point (A) / ID: "));
DBG_print(LCDML_DBG_function_name_OTHER, F("end point: (A) / ID: "));
DBG_println(LCDML_DBG_function_name_OTHER, tmp->getID());
}
else
@ -2791,11 +2807,10 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
// set next parent for check
tmp = tmp->getParent();
// -- GO Back --
layer--;
// -- GO Back --
// Debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("go to parent element"));
DBG_println(LCDML_DBG_function_name_OTHER, F("goback to parent element"));
// check if the parent element have siblings
if(tmp->getSibling(1) != NULL)
@ -2806,14 +2821,14 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
}
else
{
if(tmp->getParent()->getID() == _LCDML_NO_FUNC)
if(tmp->getParent()->getID() == _LCDML_FIRST_ELEMENT_ID)
{
break;
}
else
{
// continue
}
// continue
}
}
} while (true);
}
@ -2827,6 +2842,24 @@ uint8_t LCDMenuLib2::OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_function_name)
}
/* ******************************************************************** */
void LCDMenuLib2::OTHER_updateFunc(void)
/* ******************************************************************** */
{
// debug information
DBG_println(LCDML_DBG_function_name_OTHER, F("LCDML.OTHER_updateFunc"));
if(bitRead(REG_control, _LCDML_REG_control_menu_func_active) == true)
{
bitSet(REG_update, _LCDML_REG_update_menu_function_content);
}
else
{
// do nothing
}
}
/* ******************************************************************** */
/* ******************************************************************** */
/* SCREEN methods */

61
third-party/LCDMenuLib2/src/LCDMenuLib2.h vendored
Unescape View File

@ -4,7 +4,7 @@
*
* MIT License
*
* Copyright (c) [2019] [Nils Feldkämper]
* Copyright (c) [2020] [Nils Feldkämper]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -83,7 +83,7 @@
#endif
// Version
#define _LCDML_VERSION "LCDML2 v2.2.2 - 23.04.2020"
#define _LCDML_VERSION "LCDML2 v2.2.2 - 27.04.2020"
// this makro is for unused variables which exists for compatibility tings ...
#define LCDML_UNUSED(expr) do { (void)(expr); } while (0)
@ -110,6 +110,7 @@
// No function constant
#define _LCDML_NO_FUNC 255
#define _LCDML_FIRST_ELEMENT_ID 255
// Bit pos control flags
#define _LCDML_REG_control_dynMenuDisplayed 7
@ -119,11 +120,11 @@
#define _LCDML_REG_control_update_direct 3
#define _LCDML_REG_control_free_2 2
#define _LCDML_REG_control_rollover 1
#define _LCDML_REG_control_disable_hidden 0
#define _LCDML_REG_control_free_0 0
// screensaver, jump to function, go Root, ...
#define _LCDML_REG_special_setCursorTo 7
#define _LCDML_REG_special_jumpTo_enabled 6
#define _LCDML_REG_special_OTHER_function_active 6
#define _LCDML_REG_special_free_5 5
#define _LCDML_REG_special_free_4 4
#define _LCDML_REG_special_free_3 3
@ -155,7 +156,7 @@
#define _LCDML_REG_update_content 7
#define _LCDML_REG_update_cursor 6
#define _LCDML_REG_update_menu 5
#define _LCDML_REG_update_free_4 4
#define _LCDML_REG_update_menu_function_content 4
#define _LCDML_REG_update_free_3 3
#define _LCDML_REG_update_free_2 2
#define _LCDML_REG_update_free_1 1
@ -212,7 +213,8 @@
uint8_t actMenu_lastFuncID; // History of the last three active menu functions
uint8_t actMenu_cursorPositionID; // current cursor position id
uint8_t actMenu_lastCursorPositionID; // Save the last Cursor position before a new function was called
unsigned long actMenu_default_time;
unsigned long actMenu_default_time; // default loop time
uint64_t actMenu_ce_mask; // ce mask
// jump To variables
uint8_t jT_id; // contains the jumpTo id
@ -252,13 +254,12 @@
void MENU_goInto(void); // activate the menu under the cursor
void MENU_goBack(void); // move to the parent menu
void MENU_doScroll(uint8_t state); // scroll the menu
void MENU_goMenu(LCDMenuLib2_menu &p_m, uint8_t p_back); // go to a menu element
uint8_t MENU_countChilds(LCDMenuLib2_menu *menu, uint8_t all=false); // how many children exists on next layer
void MENU_initFirstElement(void); // set counter to the first object child
void MENU_resetActiveMenu(void); // clear all neccessary variables
// callback function
void FUNC_call(void);
void FUNC_call(void);
public:
@ -282,7 +283,7 @@
void MENU_disScroll(void); // disable the scroll function to catch the cursor to an dyn content element when a encoder is used
void MENU_setDynContent(void); // set this value when dyn content is shown on the current windows of the display
uint8_t MENU_checkDynContent(void); // check if dyn content is displayed
boolean MENU_getScrollDisableStatus(void); // check if the scroll function is disabled
bool MENU_getScrollDisableStatus(void); // check if the scroll function is disabled
uint8_t MENU_getLayer(void); // get the current layer of the menu
uint8_t MENU_getCursorPos(void); // get the current cursor position (row 0, row 1, row 2, ...)
uint8_t MENU_getCursorPosAbs(void); // get the current cursor postion absolute (..., row 10, row 11, ..) based on the menu structure
@ -298,7 +299,7 @@
LCDMenuLib2_menu * MENU_getRootObj(void); // get the root menu object
// BT = button methods
boolean BT_setup(void); // check if the button initialisation was done
bool BT_setup(void); // check if the button initialisation was done
void BT_enter(void); // set button enter
void BT_up(void); // set button up
void BT_down(void); // set button down
@ -314,23 +315,23 @@
void BT_resetRight(void); // reset right button state
void BT_resetQuit(void); // reset quit button state
//
boolean BT_checkAny(void); // check if any button was pressed
boolean BT_checkEnter(void); // check enter button
boolean BT_checkUp(void); // check up button
boolean BT_checkDown(void); // check down button
boolean BT_checkLeft(void); // check left button
boolean BT_checkRight(void); // check right button
boolean BT_checkQuit(void); // check quit button
bool BT_checkAny(void); // check if any button was pressed
bool BT_checkEnter(void); // check enter button
bool BT_checkUp(void); // check up button
bool BT_checkDown(void); // check down button
bool BT_checkLeft(void); // check left button
bool BT_checkRight(void); // check right button
bool BT_checkQuit(void); // check quit button
// CE = custom event
boolean CE_setup(void); // check if the button initialisation was done
bool CE_setup(void); // check if the button initialisation was done
void CE_set(uint8_t p_event); // set button enter
//
void CE_resetAll(void); // reset all button states
void CE_reset(uint8_t p_event); // reset enter button state
//
boolean CE_checkAny(void); // check if any button was pressed
boolean CE_check(uint8_t p_event); // check enter button
bool CE_checkAny(void); // check if any button was pressed
bool CE_check(uint8_t p_event); // check enter button
//
void CE_setOnChangeCbFunction(uint8_t p_event, LCDML_FuncPtr_pu8 p_function); // add callback function
void CE_clearOnChangeCbFunction(uint8_t p_event); // remove callback function
@ -339,14 +340,14 @@
void DISP_update(void); // display the content and update the menu structure
void DISP_menuUpdate(void); // display the content but do not update the menu structure
void DISP_clear(void); // calls the callback function to clear the display
boolean DISP_checkMenuUpdate(void); // check if there is new content to display
boolean DISP_checkMenuCursorUpdate(void); // check if the cursor was moved
bool DISP_checkMenuUpdate(void); // check if there is new content to display
bool DISP_checkMenuCursorUpdate(void); // check if the cursor was moved
uint8_t DISP_getMenuContentId(uint8_t n); // get the id`s from a contentelement for a special line
// menu function methods
boolean FUNC_setup(void); // check if a menu function is called the first time to init some things
boolean FUNC_loop(void); // check if a menu function is running in a loop
boolean FUNC_close(void); // check if a menu function is closed to reach a stable state
bool FUNC_setup(void); // check if a menu function is called the first time to init some things
bool FUNC_loop(void); // check if a menu function is running in a loop
bool FUNC_close(void); // check if a menu function is closed to reach a stable state
void FUNC_goBackToMenu(uint8_t p_goBackCnt=0); // close the current menu function (the FUNC_close check is true when this is set)
uint8_t FUNC_getID(void); // get the ID of the current menu function
void FUNC_setLoopInterval(unsigned long p_t); // set a loop intervall for the current menu function the default loop intervall is 100000000 ms
@ -354,11 +355,12 @@
void FUNC_setGBAToLastCursorPos(void); // set a special "go back handling"
void FUNC_setGBAToLastFunc(void); // set a special "go back handling"
void FUNC_setGBA(void); // set a special "go back handling" which decide between the two function above
void FUNC_setCEMask(unsigned long p_mask); // set a mask to enable only special events for a menu function
// timer methods
boolean TIMER_ms(unsigned long &p_var, unsigned long p_t); // a small timer based on the millis() function
bool TIMER_ms(unsigned long &p_var, unsigned long p_t); // a small timer based on the millis() function
void TIMER_msReset(unsigned long &p_var); // reset the millis timer
boolean TIMER_us(unsigned long &p_var, unsigned long p_t); // a small timer based on the micros() function
bool TIMER_us(unsigned long &p_var, unsigned long p_t); // a small timer based on the micros() function
void TIMER_usReset(unsigned long &p_var); // reset the micros timer
// other methods
@ -366,7 +368,8 @@
void OTHER_jumpToID(uint8_t p_search, uint8_t p_para = 0); // jumpTo a defined function based on the function id
void OTHER_setCursorToID(uint8_t p_search); // set the cursor to a defined function based on the id
void OTHER_setCursorToFunc(LCDML_FuncPtr_pu8 p_search); // set the cursor to a defined function based on the function name
uint8_t OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_search); // get the menu element id from a menu element function name
uint8_t OTHER_getIDFromFunction(LCDML_FuncPtr_pu8 p_search); // get the menu element id from a menu element function name
void OTHER_updateFunc(void); // update a menu function directly when it runs
// screensaver methods
void SCREEN_enable(LCDML_FuncPtr_pu8 p_function, unsigned long p_t); // enable the screensaver feature

2
third-party/LCDMenuLib2/src/LCDMenuLib2_macros.h vendored
Unescape View File

@ -4,7 +4,7 @@
*
* MIT License
*
* Copyright (c) [2019] [Nils Feldkämper]
* Copyright (c) [2020] [Nils Feldkämper]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal

10
third-party/LCDMenuLib2/src/LCDMenuLib2_menu.cpp vendored
Unescape View File

@ -4,7 +4,7 @@
*
* MIT License
*
* Copyright (c) [2019] [Nils Feldkämper]
* Copyright (c) [2020] [Nils Feldkämper]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -144,7 +144,7 @@ uint8_t LCDMenuLib2_menu::getID()
}
/* ******************************************************************** */
boolean LCDMenuLib2_menu::checkCondition()
bool LCDMenuLib2_menu::checkCondition()
/* ******************************************************************** */
{
if(cb_condition != NULL)
@ -182,7 +182,7 @@ void LCDMenuLib2_menu::callback(uint8_t p)
}
/* ******************************************************************** */
boolean LCDMenuLib2_menu::checkCallback()
bool LCDMenuLib2_menu::checkCallback()
/* ******************************************************************** */
{
if(cb_function == NULL)
@ -196,7 +196,7 @@ boolean LCDMenuLib2_menu::checkCallback()
}
/* ******************************************************************** */
boolean LCDMenuLib2_menu::checkType_menu()
bool LCDMenuLib2_menu::checkType_menu()
/* ******************************************************************** */
{
if(bitRead(configuration, _LCDML_menu_default))
@ -210,7 +210,7 @@ boolean LCDMenuLib2_menu::checkType_menu()
}
/* ******************************************************************** */
boolean LCDMenuLib2_menu::checkType_dynParam()
bool LCDMenuLib2_menu::checkType_dynParam()
/* ******************************************************************** */
{
if(bitRead(configuration, _LCDML_menu_dynParam))

10
third-party/LCDMenuLib2/src/LCDMenuLib2_menu.h vendored
Unescape View File

@ -4,7 +4,7 @@
*
* MIT License
*
* Copyright (c) [2019] [Nils Feldkämper]
* Copyright (c) [2020] [Nils Feldkämper]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -81,12 +81,12 @@
LCDMenuLib2_menu * getParent(); // Returns this menu's parent menu. If no parent, returns itself
uint8_t getID(); // return the id of a menu element
boolean checkCondition(); // check menu display condition
bool checkCondition(); // check menu display condition
uint8_t getParam(); // return a parameter which is set on the initialization
boolean checkType_menu();
boolean checkType_dynParam();
bool checkType_menu();
bool checkType_dynParam();
void callback(uint8_t p); // call menu callback
boolean checkCallback(); // check if callback can called
bool checkCallback(); // check if callback can called
};
#endif

4
third-party/LCDMenuLib2/src/LCDMenuLib2_typedef.h vendored
Unescape View File

@ -4,7 +4,7 @@
*
* MIT License
*
* Copyright (c) [2019] [Nils Feldkämper]
* Copyright (c) [2020] [Nils Feldkämper]
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@ -40,6 +40,6 @@
typedef void (* LCDML_FuncPtr) ();
typedef void (* LCDML_FuncPtr_pu8) (uint8_t); // with parameter u8
typedef boolean (* LCDML_FuncPtr_rb) (); // with return value boolean
typedef bool (* LCDML_FuncPtr_rb) (); // with return value bool
#endif

Write Preview
Loading…
Cancel
Save