MicroMDAEPiano/UI.hpp

/*
   MicroMDAEPiano

   MicroMDAEPiano is a port of the MDA-EPiano sound engine
   (https://sourceforge.net/projects/mda-vst/) for the Teensy-3.5/3.6 with audio shield.

   (c)2019 H. Wirtz <wirtz@parasitstudio.de>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

*/

/* Don't forget to change parameters in ../libraries/LiquidMenu/src/LiquidMenu_config.h

  /// Configures the number of available variables per line.
  const uint8_t MAX_VARIABLES = 5; ///< @note Default: 5

  /// Configures the number of available functions per line.
  const uint8_t MAX_FUNCTIONS = 43; ///< @note Default: 8

  /// Configures the number of available lines per screen.
  const uint8_t MAX_LINES = 22; ///< @note Default: 12

  /// Configures the number of available screens per menu.
  const uint8_t MAX_SCREENS = 2; ///< @note Default: 14

  /// Configures the number of available menus per menus system.
  const uint8_t MAX_MENUS = 46; ///< @note Default: 8

*/

#ifndef UI_HPP_INCLUDED
#define UI_HPP_INCLUDED
#include <LiquidCrystal_I2C.h>
#include <LiquidMenu.h>
#define BOUNCE_WITH_PROMPT_DETECTION
#include <Bounce.h>
#include "Encoder4.h"
#include "config.h"

LiquidCrystal_I2C lcd(LCD_I2C_ADDRESS, LCD_CHARS, LCD_LINES);
Encoder4 enc[NUM_ENCODER] = {Encoder4(ENC_L_PIN_A, ENC_L_PIN_B), Encoder4(ENC_R_PIN_A, ENC_R_PIN_B)};
int32_t encoder_value[NUM_ENCODER];
Bounce but[NUM_ENCODER] = {Bounce(BUT_L_PIN, BUT_DEBOUNCE_MS), Bounce(BUT_R_PIN, BUT_DEBOUNCE_MS)};
elapsedMillis back_to_main;

#define NUM_MENUS 46

#define MAIN 0
/*************************************/
#define LOAD_SOUND 1
#define EDIT_SOUND 2
#define EFFECTS 3
#define SAVE_SOUND 4
#define SYSTEM 5
#define INFO 6
/*************************************/
#define DECAY 7
#define RELEASE 8
#define HARDNESS 9
#define TREBLE 10
#define STEREO_LEVEL 11
#define TRANSPOSE 12
#define TUNE 13
#define DETUNE 14
#define VELOCITY_SENSE 15
/*************************************/
#define PAN_TREM_FREQUENCY 16
#define PAN_TREM_LEVEL 17
#define OVERDRIVE 18
#define COMP_GAIN 19
#define COMP_RESPONSE 20
#define COMP_LIMIT 21
#define COMP_THRESHOLD 22
#define COMP_ATTACK 23
#define COMP_DECAY 24
#define REV_ROOMSIZE 25
#define REV_DAMPING 26
#define REV_LEVEL 27
#define CHORUS_FREQ 28
#define CHORUS_DELAY 29
#define CHORUS_INTENSITY 30
#define CHORUS_FEEDBACK 31
#define CHORUS_WAVEFORM 32
#define CHORUS_LEVEL 33
#define BASS_LR_LEVEL 34
#define BASS_MONO_LEVEL 35
#define EQ_BASS 36
#define EQ_TREBLE 37
/*************************************/
#define LOUDNESS 38
#define MIDI_CHANNEL 39
#define MIDI_SOFT_THRU 40
#define MAX_POLY 41
#define MONO 42
/*************************************/
#define STORE_QUESTION 43
/*************************************/
#define MASTER_VOLUME 44
/*************************************/

int8_t menu_position[NUM_MENUS];
bool yes_no = false;

#define LEFT_ENCODER 0
#define RIGHT_ENCODER 1

extern void set_master_volume(uint8_t value);
extern void config_from_eeprom(void);
extern void eeprom_config_write(uint8_t value);

extern AudioControlSGTL5000 sgtl5000_1;
extern AudioEffectFreeverb freeverb_r;
extern AudioEffectFreeverb freeverb_l;
extern AudioSynthWaveform modulator;
extern AudioEffectModulatedDelay modchorus_r;
extern AudioEffectModulatedDelay modchorus_l;
extern AudioMixer4 modchorus_fbk_mixer_r;
extern AudioMixer4 modchorus_fbk_mixer_l;
extern AudioMixer4 mixer_r;
extern AudioMixer4 mixer_l;
extern AudioAmplifier volume_r;
extern AudioAmplifier volume_l;
extern AudioAmplifier inverter;
extern mdaEPiano* ep;
extern config_t configuration;
extern uint8_t sound;
extern uint8_t master_volume;
extern int8_t pan;

/******************************************
   TEXT GETTER FUCTIONS
 ******************************************/
char comp_gain_value_text1[] = "  0 dB";
char comp_gain_value_text2[] = "+ 6 dB";
char comp_gain_value_text3[] = "+12 dB";
char* get_comp_gain_value_text(void)
{
  switch (configuration.comp_gain)
  {
    case 0:
      return (comp_gain_value_text1);
      break;
    case 1:
      return (comp_gain_value_text2);
      break;
    case 2:
      return (comp_gain_value_text3);
      break;
  }
  return ('\0');
}

char comp_response_value_text1[] = "  0 ms";
char comp_response_value_text2[] = " 25 ms";
char comp_response_value_text3[] = " 50 ms";
char comp_response_value_text4[] = "100 ms";
char* get_comp_response_value_text(void)
{
  switch (configuration.comp_response)
  {
    case 0:
      return (comp_response_value_text1);
      break;
    case 1:
      return (comp_response_value_text2);
      break;
    case 2:
      return (comp_response_value_text3);
      break;
    case 3:
      return (comp_response_value_text4);
      break;
  }
  return ('\0');
}

char comp_limit_value_text1[] = "soft Knee";
char comp_limit_value_text2[] = "hard Knee";
char* get_comp_limit_value_text(void)
{
  if (configuration.comp_limit == false)
    return (comp_limit_value_text1);
  else
    return (comp_limit_value_text2);
}

char comp_threshold_value_text1[] = "        ";
char* get_comp_threshold_value_text(void)
{
  if (configuration.comp_threshold == 0)
    sprintf(comp_threshold_value_text1, " %0d dBFS", configuration.comp_threshold);
  else
    sprintf(comp_threshold_value_text1, "-%0d dBFS", configuration.comp_threshold);

  return (comp_threshold_value_text1);
}

char comp_attack_value_text1[] = "       ";
char* get_comp_attack_value_text(void)
{
  sprintf(comp_attack_value_text1, "%0.1f dB/s", (float)configuration.comp_attack / 10);

  return (comp_attack_value_text1);
}

char comp_decay_value_text1[] = "       ";
char* get_comp_decay_value_text(void)
{
  sprintf(comp_decay_value_text1, "%0.1f dB/s", float(configuration.comp_decay) / 10);

  return (comp_decay_value_text1);
}

char tune_value_text1[] = "        ";
char* get_tune_value_text(void)
{
  sprintf(tune_value_text1, "%3d cent", configuration.tune);

  return (tune_value_text1);
}

char chorus_frequency_value_text1[] = "       ";
char* get_chorus_frequency_value_text(void)
{
  sprintf(chorus_frequency_value_text1, "%2.1f Hz", float(configuration.chorus_frequency) / 10);

  return (chorus_frequency_value_text1);
}

char chorus_delay_value_text1[] = "       ";
char* get_chorus_delay_value_text(void)
{
  sprintf(chorus_delay_value_text1, "%02.1f ms", float(configuration.chorus_delay) / 10);

  return (chorus_delay_value_text1);
}

char chorus_waveform_value_text1[] = "       ";
char* get_chorus_waveform_value_text(void)
{
  switch (configuration.chorus_waveform)
  {
    case 1:
      sprintf(chorus_waveform_value_text1, "TRIANGLE");
      break;
    case 2:
      sprintf(chorus_waveform_value_text1, "SINE");
      break;
    default:
      sprintf(chorus_waveform_value_text1, "TRIANGLE");
  }
  return (chorus_waveform_value_text1);
}

char midi_channel_value_text1[] = "   ";
char* get_midi_channel_value_text(void)
{
  if (configuration.midi_channel == 0)
    sprintf(midi_channel_value_text1, "OMNI");
  else
    sprintf(midi_channel_value_text1, "%02d", configuration.midi_channel);

  return (midi_channel_value_text1);
}

char midi_soft_thru_value_text1[] = "   ";
char* get_midi_soft_thru_value_text(void)
{
  if (configuration.midi_soft_thru == false)
    sprintf(midi_soft_thru_value_text1, "Off");
  else
    sprintf(midi_soft_thru_value_text1, "On ");

  return (midi_soft_thru_value_text1);
}

char mono_value_text1[] = "      ";
char* get_mono_value_text(void)
{
  if (configuration.mono == 0)
    sprintf(mono_value_text1, "Stereo");
  else
    sprintf(mono_value_text1, "Mono  ");

  return (mono_value_text1);
}

char yes_no_value_text1[] = "   ";
char* get_yes_no_value_text(void)
{
  if (yes_no == false)
    sprintf(yes_no_value_text1, "No ");
  else
    sprintf(yes_no_value_text1, "Yes");

  return (yes_no_value_text1);
}

/******************************************
   MAIN MENU
 ******************************************/
#define NUM_MAIN_MENUS 6
const char main_text1[] PROGMEM = "Load Sound";
const char main_text2[] PROGMEM = "Edit Sound";
const char main_text3[] PROGMEM = "Effects";
const char main_text4[] PROGMEM = "Save Sound";
const char main_text5[] PROGMEM = "System";
const char main_text6[] PROGMEM = "Info";
LiquidLine main_line1(1, 0, main_text1);
LiquidLine main_line2(1, 1, main_text2);
LiquidLine main_line3(1, 1, main_text3);
LiquidLine main_line4(1, 1, main_text4);
LiquidLine main_line5(1, 1, main_text5);
LiquidLine main_line6(1, 1, main_text6);
LiquidScreen main_screen;
LiquidMenu main_menu(lcd);

/******************************************
   LOAD SOUND MENU
 ******************************************/
#define NUM_LOAD_SOUNDS_MENUS 1
const char load_sound_text1[] PROGMEM = "Load Sound";
LiquidLine load_sound_line1(1, 0, load_sound_text1);
LiquidLine load_sound_line2(1, 1, sound);
LiquidScreen load_sound_screen;
LiquidMenu load_sound_menu(lcd);

/******************************************
   EDIT SOUND MENU
 ******************************************/
#define NUM_EDIT_SOUND_MENUS 9
const char edit_sound_text1[] PROGMEM = "Decay";
const char edit_sound_text2[] PROGMEM = "Release";
const char edit_sound_text3[] PROGMEM = "Hardness";
const char edit_sound_text4[] PROGMEM = "Treble";
const char edit_sound_text5[] PROGMEM = "Stereo Level";
const char edit_sound_text6[] PROGMEM = "Transpose";
const char edit_sound_text7[] PROGMEM = "Tune";
const char edit_sound_text8[] PROGMEM = "Detune";
const char edit_sound_text9[] PROGMEM = "Velocity Sense";
LiquidLine edit_sound_line1(1, 0, edit_sound_text1);
LiquidLine edit_sound_line2(1, 1, edit_sound_text2);
LiquidLine edit_sound_line3(1, 1, edit_sound_text3);
LiquidLine edit_sound_line4(1, 1, edit_sound_text4);
LiquidLine edit_sound_line5(1, 1, edit_sound_text5);
LiquidLine edit_sound_line6(1, 1, edit_sound_text6);
LiquidLine edit_sound_line7(1, 1, edit_sound_text7);
LiquidLine edit_sound_line8(1, 1, edit_sound_text8);
LiquidLine edit_sound_line9(1, 1, edit_sound_text9);
LiquidScreen edit_sound_screen;
LiquidMenu edit_sound_menu(lcd);

/******************************************
   DECAY MENU
 ******************************************/
#define NUM_DECAY_MENUS 1
const char decay_text1[] PROGMEM = "Decay";
LiquidLine decay_line1(1, 0, decay_text1);
LiquidLine decay_line2(1, 1, configuration.decay);
LiquidScreen decay_screen;
LiquidMenu decay_menu(lcd);

/******************************************
   RELEASE MENU
 ******************************************/
#define NUM_RELEASE_MENUS 1
const char release_text1[] PROGMEM = "Release";
LiquidLine release_line1(1, 0, release_text1);
LiquidLine release_line2(1, 1, configuration.release);
LiquidScreen release_screen;
LiquidMenu release_menu(lcd);

/******************************************
   HARDNESS MENU
 ******************************************/
#define NUM_HARDNESS_MENUS 1
const char hardness_text1[] PROGMEM = "Hardness";
LiquidLine hardness_line1(1, 0, hardness_text1);
LiquidLine hardness_line2(1, 1, configuration.hardness);
LiquidScreen hardness_screen;
LiquidMenu hardness_menu(lcd);

/******************************************
   TREBLE MENU
 ******************************************/
#define NUM_TREBLE_MENUS 1
const char treble_text1[] PROGMEM = "Treble";
LiquidLine treble_line1(1, 0, treble_text1);
LiquidLine treble_line2(1, 1, configuration.treble);
LiquidScreen treble_screen;
LiquidMenu treble_menu(lcd);

/******************************************
   STEREO MENU
 ******************************************/
#define NUM_TREBLE_MENUS 1
const char stereo_text1[] PROGMEM = "Stereo";
LiquidLine stereo_line1(1, 0, stereo_text1);
LiquidLine stereo_line2(1, 1, configuration.stereo);
LiquidScreen stereo_screen;
LiquidMenu stereo_menu(lcd);

/******************************************
   TRANSPOSE MENU
 ******************************************/
#define NUM_TRANSPOSE_MENUS 1
const char transpose_text1[] PROGMEM = "Transpose";
LiquidLine transpose_line1(1, 0, transpose_text1);
LiquidLine transpose_line2(1, 1, configuration.transpose);
LiquidScreen transpose_screen;
LiquidMenu transpose_menu(lcd);

/******************************************
   TUNE MENU
 ******************************************/
#define NUM_TUNE_MENUS 1
const char tune_text1[] PROGMEM = "Tune";
LiquidLine tune_line1(1, 0, tune_text1);
//LiquidLine tune_line2(1, 1, configuration.tune);
LiquidLine tune_line2(1, 1, get_tune_value_text);
LiquidScreen tune_screen;
LiquidMenu tune_menu(lcd);

/******************************************
   DETUNE MENU
 ******************************************/
#define NUM_DETUNE_MENUS 1
const char detune_text1[] PROGMEM = "Detune";
LiquidLine detune_line1(1, 0, detune_text1);
LiquidLine detune_line2(1, 1, configuration.detune);
LiquidScreen detune_screen;
LiquidMenu detune_menu(lcd);

/******************************************
   VELOCITY MENU
 ******************************************/
#define NUM_VELOCITY_MENUS 1
const char velocity_sense_text1[] PROGMEM = "Velocity Sense";
LiquidLine velocity_sense_line1(1, 0, velocity_sense_text1);
LiquidLine velocity_sense_line2(1, 1, configuration.velocity_sense);
LiquidScreen velocity_sense_screen;
LiquidMenu velocity_sense_menu(lcd);

/******************************************
   EFFECTS MENU
 ******************************************/
#define NUM_EFFECTS_MENUS 22
const char effects_text1[] PROGMEM = "Pan/Trem Freq.";
const char effects_text2[] PROGMEM = "Pan/Trem Level";
const char effects_text3[] PROGMEM = "Overdrive";
const char effects_text4[] PROGMEM = "Comp. Gain";
const char effects_text5[] PROGMEM = "Comp. Response";
const char effects_text6[] PROGMEM = "Comp. Limit";
const char effects_text7[] PROGMEM = "Comp. Threshold";
const char effects_text8[] PROGMEM = "Comp. Attack";
const char effects_text9[] PROGMEM = "Comp. Decay";
const char effects_text10[] PROGMEM = "Reverb Roomsize";
const char effects_text11[] PROGMEM = "Reverb Damping";
const char effects_text12[] PROGMEM = "Reverb Level";
const char effects_text13[] PROGMEM = "Chorus Freq.";
const char effects_text14[] PROGMEM = "Chorus Delay";
const char effects_text15[] PROGMEM = "Chorus Intens.";
const char effects_text16[] PROGMEM = "Chorus Feedback";
const char effects_text17[] PROGMEM = "Chorus Waveform";
const char effects_text18[] PROGMEM = "Chorus Level";
const char effects_text19[] PROGMEM = "Bass LR Level";
const char effects_text20[] PROGMEM = "Bass M Level";
const char effects_text21[] PROGMEM = "EQ Bass";
const char effects_text22[] PROGMEM = "EQ Treble";
LiquidLine effects_line1(1, 0, effects_text1);
LiquidLine effects_line2(1, 1, effects_text2);
LiquidLine effects_line3(1, 1, effects_text3);
LiquidLine effects_line4(1, 1, effects_text4);
LiquidLine effects_line5(1, 1, effects_text5);
LiquidLine effects_line6(1, 1, effects_text6);
LiquidLine effects_line7(1, 1, effects_text7);
LiquidLine effects_line8(1, 1, effects_text8);
LiquidLine effects_line9(1, 1, effects_text9);
LiquidLine effects_line10(1, 1, effects_text10);
LiquidLine effects_line11(1, 1, effects_text11);
LiquidLine effects_line12(1, 1, effects_text12);
LiquidLine effects_line13(1, 1, effects_text13);
LiquidLine effects_line14(1, 1, effects_text14);
LiquidLine effects_line15(1, 1, effects_text15);
LiquidLine effects_line16(1, 1, effects_text16);
LiquidLine effects_line17(1, 1, effects_text17);
LiquidLine effects_line18(1, 1, effects_text18);
LiquidLine effects_line19(1, 1, effects_text19);
LiquidLine effects_line20(1, 1, effects_text20);
LiquidLine effects_line21(1, 1, effects_text21);
LiquidLine effects_line22(1, 1, effects_text22);
LiquidScreen effects_screen;
LiquidMenu effects_menu(lcd);

/******************************************
   PAN_TREM_FRQUENCY MENU
 ******************************************/
#define NUM_PAN_TREM_FRQUENCY_MENUS 1
const char pan_trem_frequency_text1[] PROGMEM = "PAN/Trem Freq.";
LiquidLine pan_trem_frequency_line1(1, 0, pan_trem_frequency_text1);
LiquidLine pan_trem_frequency_line2(1, 1, configuration.pan_trem_frequency);
LiquidScreen pan_trem_frequency_screen;
LiquidMenu pan_trem_frequency_menu(lcd);

/******************************************
   PAN_TREM_LEVEL MENU
 ******************************************/
#define NUM_PAN_TREM_LEVEL_MENUS 1
const char pan_trem_level_text1[] PROGMEM = "Pan/Trem Level";
LiquidLine pan_trem_level_line1(1, 0, pan_trem_level_text1);
LiquidLine pan_trem_level_line2(1, 1, configuration.pan_trem_level);
LiquidScreen pan_trem_level_screen;
LiquidMenu pan_trem_level_menu(lcd);

/******************************************
   OVERDRIVE MENU
 ******************************************/
#define NUM_OVERDRIVE_MENUS 1
const char overdrive_text1[] PROGMEM = "Overdrive";
LiquidLine overdrive_line1(1, 0, overdrive_text1);
LiquidLine overdrive_line2(1, 1, configuration.overdrive);
LiquidScreen overdrive_screen;
LiquidMenu overdrive_menu(lcd);

/******************************************
   COMP_GAIN MENU
 ******************************************/
#define NUM_COMP_GAIN_MENUS 1
const char comp_gain_text1[] PROGMEM = "Comp. Gain";
LiquidLine comp_gain_line1(1, 0, comp_gain_text1);
//LiquidLine comp_gain_line2(1, 1, configuration.comp_gain);
LiquidLine comp_gain_line2(1, 1, get_comp_gain_value_text);
LiquidScreen comp_gain_screen;
LiquidMenu comp_gain_menu(lcd);

/******************************************
   COMP_RESPONSE MENU
 ******************************************/
#define NUM_COMP_RESPONSE_MENUS 1
const char comp_response_text1[] PROGMEM = "Comp. Response";
LiquidLine comp_response_line1(1, 0, comp_response_text1);
LiquidLine comp_response_line2(1, 1, get_comp_response_value_text);
LiquidScreen comp_response_screen;
LiquidMenu comp_response_menu(lcd);

/******************************************
   COMP_LIMIT MENU
 ******************************************/
#define NUM_COMP_LIMIT_MENUS 1
const char comp_limit_text1[] PROGMEM = "Comp. Limit";
LiquidLine comp_limit_line1(1, 0, comp_limit_text1);
LiquidLine comp_limit_line2(1, 1, get_comp_limit_value_text);
LiquidScreen comp_limit_screen;
LiquidMenu comp_limit_menu(lcd);

/******************************************
   COMP_THRESHOLD MENU
 ******************************************/
#define NUM_COMP_THRESHOLD_MENUS 1
const char comp_threshold_text1[] PROGMEM = "Comp. Threshold";
LiquidLine comp_threshold_line1(1, 0, comp_threshold_text1);
LiquidLine comp_threshold_line2(1, 1, get_comp_threshold_value_text);
LiquidScreen comp_threshold_screen;
LiquidMenu comp_threshold_menu(lcd);

/******************************************
   COMP_ATTACK MENU
 ******************************************/
#define NUM_COMP_ATTACK_MENUS 1
const char comp_attack_text1[] PROGMEM = "Comp. Attack";
LiquidLine comp_attack_line1(1, 0, comp_attack_text1);
LiquidLine comp_attack_line2(1, 1, get_comp_attack_value_text);
LiquidScreen comp_attack_screen;
LiquidMenu comp_attack_menu(lcd);

/******************************************
   COMP_DECAY MENU
 ******************************************/
#define NUM_COMP_DECAY_MENUS 1
const char comp_decay_text1[] PROGMEM = "Comp. Decay";
LiquidLine comp_decay_line1(1, 0, comp_decay_text1);
//LiquidLine comp_decay_line2(1, 1, configuration.comp_decay);
LiquidLine comp_decay_line2(1, 1, get_comp_decay_value_text);
LiquidScreen comp_decay_screen;
LiquidMenu comp_decay_menu(lcd);

/******************************************
   REVERB_ROOMSIZE MENU
 ******************************************/
#define NUM_REVERB_ROOMSIZE_MENUS 1
const char reverb_roomsize_text1[] PROGMEM = "Reverb Roomsize";
LiquidLine reverb_roomsize_line1(1, 0, reverb_roomsize_text1);
LiquidLine reverb_roomsize_line2(1, 1, configuration.reverb_roomsize);
LiquidScreen reverb_roomsize_screen;
LiquidMenu reverb_roomsize_menu(lcd);

/******************************************
   REVERB_DAMPING MENU
 ******************************************/
#define NUM_REVERB_DAMPING_MENUS 1
const char reverb_damping_text1[] PROGMEM = "Reverb Damping";
LiquidLine reverb_damping_line1(1, 0, reverb_damping_text1);
LiquidLine reverb_damping_line2(1, 1, configuration.reverb_damping);
LiquidScreen reverb_damping_screen;
LiquidMenu reverb_damping_menu(lcd);

/******************************************
   REVERB_LEVEL MENU
 ******************************************/
#define NUM_REVERB_LEVEL_MENUS 1
const char reverb_level_text1[] PROGMEM = "Reverb Level";
LiquidLine reverb_level_line1(1, 0, reverb_level_text1);
LiquidLine reverb_level_line2(1, 1, configuration.reverb_level);
LiquidScreen reverb_level_screen;
LiquidMenu reverb_level_menu(lcd);

/******************************************
   CHORUS_FREQUENCY MENU
 ******************************************/
#define NUM_CHORUS_FREQUENCY_MENUS 1
const char chorus_frequency_text1[] PROGMEM = "Chorus Freq.";
LiquidLine chorus_frequency_line1(1, 0, chorus_frequency_text1);
LiquidLine chorus_frequency_line2(1, 1, get_chorus_frequency_value_text);
LiquidScreen chorus_frequency_screen;
LiquidMenu chorus_frequency_menu(lcd);

/******************************************
   CHORUS_DELAY MENU
 ******************************************/
#define NUM_CHORUS_DELAY_MENUS 1
const char chorus_delay_text1[] PROGMEM = "Chorus Delay";
LiquidLine chorus_delay_line1(1, 0, chorus_delay_text1);
LiquidLine chorus_delay_line2(1, 1, get_chorus_delay_value_text);
LiquidScreen chorus_delay_screen;
LiquidMenu chorus_delay_menu(lcd);

/******************************************
   CHORUS_INTENSITY MENU
 ******************************************/
#define NUM_CHORUS_INTENSITY_MENUS 1
const char chorus_intensity_text1[] PROGMEM = "Chorus Intens.";
LiquidLine chorus_intensity_line1(1, 0, chorus_intensity_text1);
LiquidLine chorus_intensity_line2(1, 1, configuration.chorus_intensity);
LiquidScreen chorus_intensity_screen;
LiquidMenu chorus_intensity_menu(lcd);

/******************************************
   CHORUS_FEEDBACK MENU
 ******************************************/
#define NUM_CHORUS_FEEDBACK_MENUS 1
const char chorus_feedback_text1[] PROGMEM = "Chorus Feedback";
LiquidLine chorus_feedback_line1(1, 0, chorus_feedback_text1);
LiquidLine chorus_feedback_line2(1, 1, configuration.chorus_feedback);
LiquidScreen chorus_feedback_screen;
LiquidMenu chorus_feedback_menu(lcd);

/******************************************
   CHORUS_WAVEFORM MENU
 ******************************************/
#define NUM_CHORUS_WAVEFORM_MENUS 1
const char chorus_waveform_text1[] PROGMEM = "Chorus Waveform";
LiquidLine chorus_waveform_line1(1, 0, chorus_waveform_text1);
LiquidLine chorus_waveform_line2(1, 1, get_chorus_waveform_value_text);
LiquidScreen chorus_waveform_screen;
LiquidMenu chorus_waveform_menu(lcd);

/******************************************
   CHORUS_LEVEL MENU
 ******************************************/
#define NUM_CHORUS_LEVEL_MENUS 1
const char chorus_level_text1[] PROGMEM = "Chorus Level";
LiquidLine chorus_level_line1(1, 0, chorus_level_text1);
LiquidLine chorus_level_line2(1, 1, configuration.chorus_level);
LiquidScreen chorus_level_screen;
LiquidMenu chorus_level_menu(lcd);

/******************************************
   BASS_LR_LEVEL MENU
 ******************************************/
#define NUM_BASS_LR_LEVEL_MENUS 1
const char bass_lr_level_text1[] PROGMEM = "Bass L/R Level";
LiquidLine bass_lr_level_line1(1, 0, bass_lr_level_text1);
LiquidLine bass_lr_level_line2(1, 1, configuration.bass_lr_level);
LiquidScreen bass_lr_level_screen;
LiquidMenu bass_lr_level_menu(lcd);

/******************************************
   BASS_MONO_LEVEL MENU
 ******************************************/
#define NUM_BASS_MONO_LEVEL_MENUS 1
const char bass_mono_level_text1[] PROGMEM = "Bass mono Level";
LiquidLine bass_mono_level_line1(1, 0, bass_mono_level_text1);
LiquidLine bass_mono_level_line2(1, 1, configuration.bass_mono_level);
LiquidScreen bass_mono_level_screen;
LiquidMenu bass_mono_level_menu(lcd);

/******************************************
   EQ_BASS MENU
 ******************************************/
#define NUM_EQ_BASS_MENUS 1
const char eq_bass_text1[] PROGMEM = "EQ Bass";
LiquidLine eq_bass_line1(1, 0, eq_bass_text1);
LiquidLine eq_bass_line2(1, 1, configuration.eq_bass);
LiquidScreen eq_bass_screen;
LiquidMenu eq_bass_menu(lcd);

/******************************************
   EQ_TREBLE MENU
 ******************************************/
#define NUM_EQ_TREBLE_MENUS 1
const char eq_treble_text1[] PROGMEM = "EQ Treble";
LiquidLine eq_treble_line1(1, 0, eq_treble_text1);
LiquidLine eq_treble_line2(1, 1, configuration.eq_treble);
LiquidScreen eq_treble_screen;
LiquidMenu eq_treble_menu(lcd);

/******************************************
   SAVE SOUND MENU
 ******************************************/
#define NUM_SAVE_SOUNDS_MENUS 2
const char save_sound_text1[] PROGMEM = "Save Sound";
LiquidLine save_sound_line1(1, 0, save_sound_text1);
LiquidLine save_sound_line2(1, 1, sound);
LiquidScreen save_sound_screen;
LiquidMenu save_sound_menu(lcd);

/******************************************
   SYSTEM MENU
 ******************************************/
#define NUM_SYSTEM_MENUS 5
const char system_text1[] PROGMEM = "Loudness";
const char system_text2[] PROGMEM = "MIDI Channel";
const char system_text3[] PROGMEM = "MIDI Soft-Thru";
const char system_text4[] PROGMEM = "Max. Polyphony";
const char system_text5[] PROGMEM = "Mono/Stereo";
LiquidLine system_line1(1, 0, system_text1);
LiquidLine system_line2(1, 1, system_text2);
LiquidLine system_line3(1, 1, system_text3);
LiquidLine system_line4(1, 1, system_text4);
LiquidLine system_line5(1, 1, system_text5);
LiquidScreen system_screen;
LiquidMenu system_menu(lcd);

/******************************************
   LOUDNESS MENU
 ******************************************/
#define NUM_LOUDNESS_MENUS 1
const char loudness_text1[] PROGMEM = "Loudness";
LiquidLine loudness_line1(1, 0, loudness_text1);
LiquidLine loudness_line2(1, 1, configuration.loudness);
LiquidScreen loudness_screen;
LiquidMenu loudness_menu(lcd);

/******************************************
   MIDI_CHANNEL MENU
 ******************************************/
#define NUM_MIDI_CHANNEL_MENUS 1
const char midi_channel_text1[] PROGMEM = "MIDI Channel";
LiquidLine midi_channel_line1(1, 0, midi_channel_text1);
LiquidLine midi_channel_line2(1, 1, get_midi_channel_value_text);
LiquidScreen midi_channel_screen;
LiquidMenu midi_channel_menu(lcd);

/******************************************
   MIDI_SOFT_THRU MENU
 ******************************************/
#define NUM_MIDI_SOFT_THRU_MENUS 1
const char midi_soft_thru_text1[] PROGMEM = "MIDI Soft Thru";
LiquidLine midi_soft_thru_line1(1, 0, midi_soft_thru_text1);
LiquidLine midi_soft_thru_line2(1, 1, get_midi_soft_thru_value_text);
LiquidScreen midi_soft_thru_screen;
LiquidMenu midi_soft_thru_menu(lcd);

/******************************************
   MAX_POLY MENU
 ******************************************/
#define NUM_MAX_POLY_MENUS 1
const char max_poly_text1[] PROGMEM = "Max. Polyphony";
LiquidLine max_poly_line1(1, 0, max_poly_text1);
LiquidLine max_poly_line2(1, 1, configuration.max_poly);
LiquidScreen max_poly_screen;
LiquidMenu max_poly_menu(lcd);

/******************************************
   MONO/STEREO MENU
 ******************************************/
#define NUM_MONO_MENUS 1
const char mono_text1[] PROGMEM = "Mono/Stereo";
LiquidLine mono_line1(1, 0, mono_text1);
LiquidLine mono_line2(1, 1, get_mono_value_text);
LiquidScreen mono_screen;
LiquidMenu mono_menu(lcd);

/******************************************
   INFO MENU
 ******************************************/
#define NUM_INFO_MENUS 1
const char info_text1[] PROGMEM = "MicroMDAEPiano";
const char info_text2[] PROGMEM = MICRO_MDAEPIANO_VERSION;
LiquidLine info_line1(0, 0, info_text1);
LiquidLine info_line2(0, 1, info_text2);
LiquidScreen info_screen;
LiquidMenu info_menu(lcd);

/******************************************
  MASTER_VOLUME DISPLAY
 ******************************************/
const char master_volume_text1[] PROGMEM = "Master Volume";
LiquidLine master_volume_line1(1, 0, master_volume_text1);
LiquidLine master_volume_line2(1, 1, master_volume);
LiquidScreen master_volume_screen;
LiquidMenu master_volume_menu(lcd);

/******************************************
  STORE_QUESTION DISPLAY
 ******************************************/
const char store_question_text1[] PROGMEM = "Overwrite?";
LiquidLine store_question_line1(1, 0, store_question_text1);
LiquidLine store_question_line2(1, 1, get_yes_no_value_text);
LiquidScreen store_question_screen;
LiquidMenu store_question_menu(lcd);

/******************************************
   GLOBAL MENU OBJECTS
 ******************************************/
LiquidSystem menu_system;

/******************************************
   LOAD SOUND CALLBACKS
 ******************************************/
void callback_load_sound_function(void) {
#ifdef SHOW_DEBUG
  Serial.println(F("callback_load_sound_function"));
#endif
  menu_system.change_menu(load_sound_menu);
  menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = sound;
  enc[RIGHT_ENCODER].write(sound, 1, MAX_SOUNDS);
  menu_system.update();
}

/******************************************
   EDIT SOUND CALLBACKS
 ******************************************/
void callback_edit_sound_function(void)
{
#ifdef SHOW_DEBUG
  Serial.print(F("callback_edit_sound_function, focus position:"));
  Serial.println(menu_position[EDIT_SOUND], DEC);
#endif
  menu_system.change_menu(edit_sound_menu);
  menu_system.set_focusPosition(Position::LEFT);
  menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  if (menu_position[EDIT_SOUND] < 0)
  {
    menu_position[EDIT_SOUND] = 0;
    encoder_value[RIGHT_ENCODER] = 0;
    enc[RIGHT_ENCODER].write(0, 0, NUM_EDIT_SOUND_MENUS - 1);
    menu_system.switch_focus();
  }
  else
  {
    encoder_value[RIGHT_ENCODER] = menu_position[EDIT_SOUND];
    enc[RIGHT_ENCODER].write(menu_position[EDIT_SOUND], 0, NUM_EDIT_SOUND_MENUS - 1);
  }
  menu_system.update();
}

void callback_decay_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_decay_function"));
#endif
  menu_system.change_menu(decay_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.decay;
  enc[RIGHT_ENCODER].write(configuration.decay, ENC_DECAY_MIN, ENC_DECAY_MAX);
  menu_system.update();
}

void callback_release_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_release_function"));
#endif
  menu_system.change_menu(release_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.release;
  enc[RIGHT_ENCODER].write(configuration.release, ENC_RELEASE_MIN, ENC_RELEASE_MAX);
  menu_system.update();
}

void callback_hardness_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_hardness_function"));
#endif
  menu_system.change_menu(hardness_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.hardness;
  enc[RIGHT_ENCODER].write(configuration.hardness, ENC_HARDNESS_MIN, ENC_HARDNESS_MAX);
  menu_system.update();
}

void callback_treble_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_treble_function"));
#endif
  menu_system.change_menu(treble_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.treble;
  enc[RIGHT_ENCODER].write(configuration.treble, ENC_TREBLE_MIN, ENC_TREBLE_MAX);
  menu_system.update();
}

void callback_stereo_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_stereo_function"));
#endif
  menu_system.change_menu(stereo_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.stereo;
  enc[RIGHT_ENCODER].write(configuration.stereo, ENC_STEREO_MIN, ENC_STEREO_MAX);
  menu_system.update();
}

void callback_transpose_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_transpose_function"));
#endif
  menu_system.change_menu(transpose_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.transpose;
  enc[RIGHT_ENCODER].write(configuration.transpose, ENC_TRANSPOSE_MIN, ENC_TRANSPOSE_MAX);
  menu_system.update();
}

void callback_tune_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_tune_function"));
#endif
  menu_system.change_menu(tune_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.tune;
  enc[RIGHT_ENCODER].write(configuration.tune, ENC_TUNE_MIN, ENC_TUNE_MAX);
  menu_system.update();
}

void callback_detune_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_detune_function"));
#endif
  menu_system.change_menu(detune_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.detune;
  enc[RIGHT_ENCODER].write(configuration.detune, ENC_DETUNE_MIN, ENC_DETUNE_MAX);
  menu_system.update();
}

void callback_velocity_sense_function(void)
{
#ifdef SHOW_DEBUG
  Serial.print(F("callback_velocity_sense_function"));
#endif
  menu_system.change_menu(velocity_sense_menu);
  menu_position[EDIT_SOUND] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.velocity_sense;
  enc[RIGHT_ENCODER].write(configuration.velocity_sense, ENC_VELOCITY_SENSE_MIN, ENC_VELOCITY_SENSE_MAX);
  menu_system.update();
}

/******************************************
   EFFECTS CALLBACKS
 ******************************************/
void callback_effect_function(void)
{
#ifdef SHOW_DEBUG
  Serial.print(F("callback_effect_function, focus position:"));
  Serial.println(menu_position[EFFECTS]);
#endif
  menu_system.change_menu(effects_menu);
  menu_system.set_focusPosition(Position::LEFT);
  menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  if (menu_position[EFFECTS] < 0)
  {
    menu_position[EFFECTS] = 0;
    encoder_value[RIGHT_ENCODER] = 0;
    enc[RIGHT_ENCODER].write(0, 0, NUM_EFFECTS_MENUS - 1);
    menu_system.switch_focus();
  }
  else
  {
    encoder_value[RIGHT_ENCODER] = menu_position[EFFECTS];
    enc[RIGHT_ENCODER].write(menu_position[EFFECTS], 0, NUM_EFFECTS_MENUS - 1);
  }
  menu_system.update();
}

void callback_pan_trem_frequency_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_pan_trem_frequency_function"));
#endif
  menu_system.change_menu(pan_trem_frequency_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.pan_trem_frequency;
  enc[RIGHT_ENCODER].write(configuration.pan_trem_frequency, ENC_PAN_TREM_FREQUENCY_MIN, ENC_PAN_TREM_FREQUENCY_MAX);
  menu_system.update();
}

void callback_pan_trem_level_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_pan_trem_level_function"));
#endif
  menu_system.change_menu(pan_trem_level_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.pan_trem_level;
  enc[RIGHT_ENCODER].write(configuration.pan_trem_level, ENC_PAN_TREM_LEVEL_MIN, ENC_PAN_TREM_LEVEL_MAX);
  menu_system.update();
}

void callback_overdrive_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_overdrive_function"));
#endif
  menu_system.change_menu(overdrive_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.overdrive;
  enc[RIGHT_ENCODER].write(configuration.overdrive, ENC_OVERDRIVE_MIN, ENC_OVERDRIVE_MAX);
  menu_system.update();
}

void callback_comp_gain_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_comp_gain_function"));
#endif
  menu_system.change_menu(comp_gain_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.comp_gain;
  enc[RIGHT_ENCODER].write(configuration.comp_gain, ENC_COMP_GAIN_MIN, ENC_COMP_GAIN_MAX);
  menu_system.update();
}

void callback_comp_response_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_comp_response_function"));
#endif
  menu_system.change_menu(comp_response_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.comp_response;
  enc[RIGHT_ENCODER].write(configuration.comp_response, ENC_COMP_RESPONSE_MIN, ENC_COMP_RESPONSE_MAX);
  menu_system.update();
}

void callback_comp_limit_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_comp_limit_function"));
#endif
  menu_system.change_menu(comp_limit_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.comp_limit;
  enc[RIGHT_ENCODER].write(configuration.comp_limit, ENC_COMP_LIMIT_MIN, ENC_COMP_LIMIT_MAX);
  menu_system.update();
}

void callback_comp_threshold_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_comp_threshold_function"));
#endif
  menu_system.change_menu(comp_threshold_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.comp_threshold;
  enc[RIGHT_ENCODER].write(configuration.comp_threshold, ENC_COMP_THRESHOLD_MIN, ENC_COMP_THRESHOLD_MAX);
  menu_system.update();
}

void callback_comp_attack_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_comp_attack_function"));
#endif
  menu_system.change_menu(comp_attack_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.comp_attack;
  enc[RIGHT_ENCODER].write(configuration.comp_attack, ENC_COMP_ATTACK_MIN, ENC_COMP_ATTACK_MAX);
  menu_system.update();
}

void callback_comp_decay_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_comp_decay_function"));
#endif
  menu_system.change_menu(comp_decay_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.comp_decay;
  enc[RIGHT_ENCODER].write(configuration.comp_decay, ENC_COMP_DECAY_MIN, ENC_COMP_DECAY_MAX);
  menu_system.update();
}

void callback_reverb_roomsize_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_reverb_roomsize_function"));
#endif
  menu_system.change_menu(reverb_roomsize_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.reverb_roomsize;
  enc[RIGHT_ENCODER].write(configuration.reverb_roomsize, ENC_REVERB_ROOMSIZE_MIN, ENC_REVERB_ROOMSIZE_MAX);
  menu_system.update();
}

void callback_reverb_damping_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_reverb_damping_function"));
#endif
  menu_system.change_menu(reverb_damping_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.reverb_damping;
  enc[RIGHT_ENCODER].write(configuration.reverb_damping, ENC_REVERB_DAMPING_MIN, ENC_REVERB_DAMPING_MAX);
  menu_system.update();
}

void callback_reverb_level_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_reverb_level_function"));
#endif
  menu_system.change_menu(reverb_level_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.reverb_level;
  enc[RIGHT_ENCODER].write(configuration.reverb_level, ENC_REVERB_LEVEL_MIN, ENC_REVERB_LEVEL_MAX);
  menu_system.update();
}

void callback_chorus_frequency_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_chorus_frequency_function"));
#endif
  menu_system.change_menu(chorus_frequency_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.chorus_frequency;
  enc[RIGHT_ENCODER].write(configuration.chorus_frequency, ENC_CHORUS_FREQUENCY_MIN, ENC_CHORUS_FREQUENCY_MAX);
  menu_system.update();
}

void callback_chorus_delay_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_chorus_delay_function"));
#endif
  menu_system.change_menu(chorus_delay_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.chorus_delay;
  enc[RIGHT_ENCODER].write(configuration.chorus_delay, ENC_CHORUS_DELAY_MIN, ENC_CHORUS_DELAY_MAX);
  menu_system.update();
}

void callback_chorus_intensity_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_chorus_intensity_function"));
#endif
  menu_system.change_menu(chorus_intensity_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.chorus_intensity;
  enc[RIGHT_ENCODER].write(configuration.chorus_intensity, ENC_CHORUS_INTENSITY_MIN, ENC_CHORUS_INTENSITY_MAX);
  menu_system.update();
}

void callback_chorus_feedback_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_chorus_feedback_function"));
#endif
  menu_system.change_menu(chorus_feedback_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.chorus_feedback;
  enc[RIGHT_ENCODER].write(configuration.chorus_feedback, ENC_CHORUS_FEEDBACK_MIN, ENC_CHORUS_FEEDBACK_MAX);
  menu_system.update();
}

void callback_chorus_waveform_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_chorus_waveform_function"));
#endif
  menu_system.change_menu(chorus_waveform_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.chorus_waveform;
  enc[RIGHT_ENCODER].write(configuration.chorus_waveform, ENC_CHORUS_WAVEFORM_MIN, ENC_CHORUS_WAVEFORM_MAX);
  menu_system.update();
}

void callback_chorus_level_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_chorus_level_function"));
#endif
  menu_system.change_menu(chorus_level_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.chorus_level;
  enc[RIGHT_ENCODER].write(configuration.chorus_level, ENC_CHORUS_LEVEL_MIN, ENC_CHORUS_LEVEL_MAX);
  menu_system.update();
}

void callback_bass_lr_level_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_bass_lr_level_function"));
#endif
  menu_system.change_menu(bass_lr_level_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.bass_lr_level;
  enc[RIGHT_ENCODER].write(configuration.bass_lr_level, ENC_BASS_LR_LEVEL_MIN, ENC_BASS_LR_LEVEL_MAX);
  menu_system.update();
}

void callback_bass_mono_level_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_bass_mono_level_function"));
#endif
  menu_system.change_menu(bass_mono_level_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.bass_mono_level;
  enc[RIGHT_ENCODER].write(configuration.bass_mono_level, ENC_BASS_MONO_LEVEL_MIN, ENC_BASS_MONO_LEVEL_MAX);
  menu_system.update();
}

void callback_eq_bass_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_eq_bass_function"));
#endif
  menu_system.change_menu(eq_bass_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.eq_bass;
  enc[RIGHT_ENCODER].write(configuration.eq_bass, ENC_EQ_BASS_MIN, ENC_EQ_BASS_MAX);
  menu_system.update();
}

void callback_eq_treble_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_eq_treble_function"));
#endif
  menu_system.change_menu(eq_treble_menu);
  menu_position[EFFECTS] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.eq_treble;
  enc[RIGHT_ENCODER].write(configuration.eq_treble, ENC_EQ_TREBLE_MIN, ENC_EQ_TREBLE_MAX);
  menu_system.update();
}

/******************************************
   SAVE SOUND CALLBACKS
 ******************************************/
void callback_save_sound_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_save_sound_function"));
#endif
  menu_system.change_menu(save_sound_menu);
  menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = sound;
  enc[RIGHT_ENCODER].write(sound, 1, MAX_SOUNDS);
  menu_system.update();
}

void callback_store_question_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_store_question_function"));
#endif
  menu_system.change_menu(store_question_menu);
  //menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = yes_no;
  enc[RIGHT_ENCODER].write(yes_no, 0, 1);
  menu_system.update();
}
/******************************************
   SYSTEM MENU CALLBACKS
 ******************************************/
void callback_system_function(void)
{
#ifdef SHOW_DEBUG
  Serial.print(F("callback_system_function, focus position:"));
  Serial.println(menu_position[SYSTEM]);
#endif
  menu_system.change_menu(system_menu);
  menu_system.set_focusPosition(Position::LEFT);
  menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  if (menu_position[SYSTEM] < 0)
  {
    menu_position[SYSTEM] = 0;
    encoder_value[RIGHT_ENCODER] = 0;
    enc[RIGHT_ENCODER].write(0, 0, NUM_SYSTEM_MENUS - 1);
    menu_system.switch_focus();
  }
  else
  {
    encoder_value[RIGHT_ENCODER] = menu_position[SYSTEM];
    enc[RIGHT_ENCODER].write(menu_position[SYSTEM], 0, NUM_SYSTEM_MENUS - 1);
  }
  menu_system.update();
}

void callback_loudness_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_loudness_function"));
#endif
  menu_system.change_menu(loudness_menu);
  menu_position[SYSTEM] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.loudness;
  enc[RIGHT_ENCODER].write(configuration.loudness, ENC_LOUDNESS_MIN, ENC_LOUDNESS_MAX);
  menu_system.update();
}

void callback_midi_channel_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_midi_channel_function"));
#endif
  menu_system.change_menu(midi_channel_menu);
  menu_position[SYSTEM] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.midi_channel;
  enc[RIGHT_ENCODER].write(configuration.midi_channel, ENC_MIDI_CHANNEL_MIN, ENC_MIDI_CHANNEL_MAX);
  menu_system.update();
}

void callback_midi_soft_thru_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_midi_soft_thru_function"));
#endif
  menu_system.change_menu(midi_soft_thru_menu);
  menu_position[SYSTEM] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.midi_soft_thru;
  enc[RIGHT_ENCODER].write(configuration.midi_soft_thru, ENC_MIDI_SOFT_THRU_MIN, ENC_MIDI_SOFT_THRU_MAX);
  menu_system.update();
}

void callback_max_poly_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_max_poly_function"));
#endif
  menu_system.change_menu(max_poly_menu);
  menu_position[SYSTEM] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.max_poly;
  enc[RIGHT_ENCODER].write(configuration.max_poly, ENC_MAX_POLY_MIN, ENC_MAX_POLY_MAX);
  menu_system.update();
}

void callback_mono_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_mono_function"));
#endif
  menu_system.change_menu(mono_menu);
  menu_position[SYSTEM] = encoder_value[RIGHT_ENCODER];
  encoder_value[RIGHT_ENCODER] = configuration.mono;
  enc[RIGHT_ENCODER].write(configuration.mono, ENC_MONO_MIN, ENC_MONO_MAX);
  menu_system.update();
}

/******************************************
   INFO MENU CALLBACKS
 ******************************************/
void callback_info_function(void)
{
#ifdef SHOW_DEBUG
  Serial.println(F("callback_info_function"));
#endif
  menu_system.change_menu(info_menu);
  menu_position[MAIN] = encoder_value[RIGHT_ENCODER];
  menu_system.update();
}

/******************************************
   HELPER MENU FUNCTION
 ******************************************/

float mapfloat(float val, float in_min, float in_max, float out_min, float out_max)
// e.g. mapfloat(float(effect_delay_feedback), 0, ENC_DELAY_FB_STEPS, 0.0, 1.0)
{
  return (val - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

void encoder_switch_focus(uint8_t encoder_last, uint8_t encoder_value)
{
  uint8_t i;
  int8_t diff;

  diff = encoder_value - encoder_last;

  for (i = 0; i < abs(diff); i++)
  {
    if (diff < 0)
      menu_system.switch_focus(true);
    else
      menu_system.switch_focus(false);
  }
}

void goto_main_menu(uint8_t menu_number)
{
  menu_position[menu_number] = enc[RIGHT_ENCODER].read();
  menu_system.change_menu(main_menu);
  menu_system.set_focusPosition(Position::LEFT);
  encoder_value[RIGHT_ENCODER] = menu_position[MAIN];
  enc[RIGHT_ENCODER].write(menu_position[MAIN], 0, NUM_MAIN_MENUS - 1);
}

void goto_edit_sound_menu(uint8_t menu_number)
{
  menu_position[menu_number] = enc[RIGHT_ENCODER].read();
  menu_system.change_menu(edit_sound_menu);
  menu_system.set_focusPosition(Position::LEFT);
  encoder_value[RIGHT_ENCODER] = menu_position[EDIT_SOUND];
  enc[RIGHT_ENCODER].write(menu_position[EDIT_SOUND], 0, NUM_EDIT_SOUND_MENUS - 1);
}

void goto_effects_menu(uint8_t menu_number)
{
  menu_position[menu_number] = enc[RIGHT_ENCODER].read();
  menu_system.change_menu(effects_menu);
  menu_system.set_focusPosition(Position::LEFT);
  encoder_value[RIGHT_ENCODER] = menu_position[EFFECTS];
  enc[RIGHT_ENCODER].write(menu_position[EFFECTS], 0, NUM_EFFECTS_MENUS - 1);
}

void goto_system_menu(uint8_t menu_number)
{
  menu_position[menu_number] = enc[RIGHT_ENCODER].read();
  menu_system.change_menu(system_menu);
  menu_system.set_focusPosition(Position::LEFT);
  encoder_value[RIGHT_ENCODER] = menu_position[SYSTEM];
  enc[RIGHT_ENCODER].write(menu_position[SYSTEM], 0, NUM_SYSTEM_MENUS - 1);
}

void goto_store_question_menu(uint8_t menu_number)
{
  menu_position[menu_number] = enc[RIGHT_ENCODER].read();
  menu_system.change_menu(store_question_menu);
  menu_system.set_focusPosition(Position::LEFT);
  //encoder_value[RIGHT_ENCODER] = menu_position[STORE_QUESTION];
  enc[RIGHT_ENCODER].write(menu_position[STORE_QUESTION], 0, 1);
}

/******************************************
   INIT MENU FUNCTION
 ******************************************/
void init_menus(void)
{
  uint8_t i;

  // LCD display setup
  lcd.init();
  lcd.blink_off();
  lcd.cursor_off();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(1, 0);
  lcd.print("MicroMDAEPiano");
  lcd.setCursor(0, 1);
  lcd.print("(c)parasiTstudio");
  delay(1000);

  // setup main menu
  main_screen.add_line(main_line1);
  main_screen.add_line(main_line2);
  main_screen.add_line(main_line3);
  main_screen.add_line(main_line4);
  main_screen.add_line(main_line5);
  main_screen.add_line(main_line6);
  main_screen.set_displayLineCount(2);
  main_menu.add_screen(main_screen);

  main_line1.attach_function(LOAD_SOUND, callback_load_sound_function);
  main_line2.attach_function(EDIT_SOUND, callback_edit_sound_function);
  main_line3.attach_function(EFFECTS, callback_effect_function);
  main_line4.attach_function(SAVE_SOUND, callback_save_sound_function);
  main_line5.attach_function(SYSTEM, callback_system_function);
  main_line6.attach_function(INFO, callback_info_function);

  // setup load_sound menu
  load_sound_screen.add_line(load_sound_line1);
  load_sound_screen.add_line(load_sound_line2);
  load_sound_screen.set_displayLineCount(2);
  load_sound_menu.add_screen(load_sound_screen);

  // setup sound menu
  edit_sound_screen.add_line(edit_sound_line1);
  edit_sound_screen.add_line(edit_sound_line2);
  edit_sound_screen.add_line(edit_sound_line3);
  edit_sound_screen.add_line(edit_sound_line4);
  edit_sound_screen.add_line(edit_sound_line5);
  edit_sound_screen.add_line(edit_sound_line6);
  edit_sound_screen.add_line(edit_sound_line7);
  edit_sound_screen.add_line(edit_sound_line8);
  edit_sound_screen.add_line(edit_sound_line9);
  edit_sound_screen.set_displayLineCount(2);
  edit_sound_menu.add_screen(edit_sound_screen);

  edit_sound_line1.attach_function(DECAY, callback_decay_function);
  edit_sound_line2.attach_function(RELEASE, callback_release_function);
  edit_sound_line3.attach_function(HARDNESS, callback_hardness_function);
  edit_sound_line4.attach_function(TREBLE, callback_treble_function);
  edit_sound_line5.attach_function(STEREO_LEVEL, callback_stereo_function);
  edit_sound_line6.attach_function(TRANSPOSE, callback_transpose_function);
  edit_sound_line7.attach_function(TUNE, callback_tune_function);
  edit_sound_line8.attach_function(DETUNE, callback_detune_function);
  edit_sound_line9.attach_function(VELOCITY_SENSE, callback_velocity_sense_function);

  // setup decay menu
  decay_screen.add_line(decay_line1);
  decay_screen.add_line(decay_line2);
  decay_screen.set_displayLineCount(2);
  decay_menu.add_screen(decay_screen);

  // setup release menu
  release_screen.add_line(release_line1);
  release_screen.add_line(release_line2);
  release_screen.set_displayLineCount(2);
  release_menu.add_screen(release_screen);

  // setup hardness menu
  hardness_screen.add_line(hardness_line1);
  hardness_screen.add_line(hardness_line2);
  hardness_screen.set_displayLineCount(2);
  hardness_menu.add_screen(hardness_screen);

  // setup treble menu
  treble_screen.add_line(treble_line1);
  treble_screen.add_line(treble_line2);
  treble_screen.set_displayLineCount(2);
  treble_menu.add_screen(treble_screen);

  // setup stereo menu
  stereo_screen.add_line(stereo_line1);
  stereo_screen.add_line(stereo_line2);
  stereo_screen.set_displayLineCount(2);
  stereo_menu.add_screen(stereo_screen);

  // setup transpose menu
  transpose_screen.add_line(transpose_line1);
  transpose_screen.add_line(transpose_line2);
  transpose_screen.set_displayLineCount(2);
  transpose_menu.add_screen(transpose_screen);

  // setup tune menu
  tune_screen.add_line(tune_line1);
  tune_screen.add_line(tune_line2);
  tune_screen.set_displayLineCount(2);
  tune_menu.add_screen(tune_screen);

  // setup detune menu
  detune_screen.add_line(detune_line1);
  detune_screen.add_line(detune_line2);
  detune_screen.set_displayLineCount(2);
  detune_menu.add_screen(detune_screen);

  // setup velocity_sense menu
  velocity_sense_screen.add_line(velocity_sense_line1);
  velocity_sense_screen.add_line(velocity_sense_line2);
  velocity_sense_screen.set_displayLineCount(2);
  velocity_sense_menu.add_screen(velocity_sense_screen);

  // setup effects menu
  effects_screen.add_line(effects_line1);
  effects_screen.add_line(effects_line2);
  effects_screen.add_line(effects_line3);
  effects_screen.add_line(effects_line4);
  effects_screen.add_line(effects_line5);
  effects_screen.add_line(effects_line6);
  effects_screen.add_line(effects_line7);
  effects_screen.add_line(effects_line8);
  effects_screen.add_line(effects_line9);
  effects_screen.add_line(effects_line10);
  effects_screen.add_line(effects_line11);
  effects_screen.add_line(effects_line12);
  effects_screen.add_line(effects_line13);
  effects_screen.add_line(effects_line14);
  effects_screen.add_line(effects_line15);
  effects_screen.add_line(effects_line16);
  effects_screen.add_line(effects_line17);
  effects_screen.add_line(effects_line18);
  effects_screen.add_line(effects_line19);
  effects_screen.add_line(effects_line20);
  effects_screen.add_line(effects_line21);
  effects_screen.add_line(effects_line22);
  effects_screen.set_displayLineCount(2);
  effects_menu.add_screen(effects_screen);

  effects_line1.attach_function(PAN_TREM_FREQUENCY, callback_pan_trem_frequency_function);
  effects_line2.attach_function(PAN_TREM_LEVEL, callback_pan_trem_level_function);
  effects_line3.attach_function(OVERDRIVE, callback_overdrive_function);
  effects_line4.attach_function(COMP_GAIN, callback_comp_gain_function);
  effects_line5.attach_function(COMP_RESPONSE, callback_comp_response_function);
  effects_line6.attach_function(COMP_LIMIT, callback_comp_limit_function);
  effects_line7.attach_function(COMP_THRESHOLD, callback_comp_threshold_function);
  effects_line8.attach_function(COMP_ATTACK, callback_comp_attack_function);
  effects_line9.attach_function(COMP_DECAY, callback_comp_decay_function);
  effects_line10.attach_function(REV_ROOMSIZE, callback_reverb_roomsize_function);
  effects_line11.attach_function(REV_DAMPING, callback_reverb_damping_function);
  effects_line12.attach_function(REV_LEVEL, callback_reverb_level_function);
  effects_line13.attach_function(CHORUS_FREQ, callback_chorus_frequency_function);
  effects_line14.attach_function(CHORUS_DELAY, callback_chorus_delay_function);
  effects_line15.attach_function(CHORUS_INTENSITY, callback_chorus_intensity_function);
  effects_line16.attach_function(CHORUS_FEEDBACK, callback_chorus_feedback_function);
  effects_line17.attach_function(CHORUS_WAVEFORM, callback_chorus_waveform_function);
  effects_line18.attach_function(CHORUS_LEVEL, callback_chorus_level_function);
  effects_line19.attach_function(BASS_LR_LEVEL, callback_bass_lr_level_function);
  effects_line20.attach_function(BASS_MONO_LEVEL, callback_bass_mono_level_function);
  effects_line21.attach_function(EQ_BASS, callback_eq_bass_function);
  effects_line22.attach_function(EQ_TREBLE, callback_eq_treble_function);

  // setup pan_trem_frequency menu
  pan_trem_frequency_screen.add_line(pan_trem_frequency_line1);
  pan_trem_frequency_screen.add_line(pan_trem_frequency_line2);
  pan_trem_frequency_screen.set_displayLineCount(2);
  pan_trem_frequency_menu.add_screen(pan_trem_frequency_screen);

  // setup pan_trem_level menu
  pan_trem_level_screen.add_line(pan_trem_level_line1);
  pan_trem_level_screen.add_line(pan_trem_level_line2);
  pan_trem_level_screen.set_displayLineCount(2);
  pan_trem_level_menu.add_screen(pan_trem_level_screen);

  // setup overdrive menu
  overdrive_screen.add_line(overdrive_line1);
  overdrive_screen.add_line(overdrive_line2);
  overdrive_screen.set_displayLineCount(2);
  overdrive_menu.add_screen(overdrive_screen);

  // setup comp_gain menu
  comp_gain_screen.add_line(comp_gain_line1);
  comp_gain_screen.add_line(comp_gain_line2);
  comp_gain_screen.set_displayLineCount(2);
  comp_gain_menu.add_screen(comp_gain_screen);

  // setup comp_response menu
  comp_response_screen.add_line(comp_response_line1);
  comp_response_screen.add_line(comp_response_line2);
  comp_response_screen.set_displayLineCount(2);
  comp_response_menu.add_screen(comp_response_screen);

  // setup comp_limit menu
  comp_limit_screen.add_line(comp_limit_line1);
  comp_limit_screen.add_line(comp_limit_line2);
  comp_limit_screen.set_displayLineCount(2);
  comp_limit_menu.add_screen(comp_limit_screen);

  // setup comp_threshold menu
  comp_threshold_screen.add_line(comp_threshold_line1);
  comp_threshold_screen.add_line(comp_threshold_line2);
  comp_threshold_screen.set_displayLineCount(2);
  comp_threshold_menu.add_screen(comp_threshold_screen);

  // setup comp_attack menu
  comp_attack_screen.add_line(comp_attack_line1);
  comp_attack_screen.add_line(comp_attack_line2);
  comp_attack_screen.set_displayLineCount(2);
  comp_attack_menu.add_screen(comp_attack_screen);

  // setup comp_decay menu
  comp_decay_screen.add_line(comp_decay_line1);
  comp_decay_screen.add_line(comp_decay_line2);
  comp_decay_screen.set_displayLineCount(2);
  comp_decay_menu.add_screen(comp_decay_screen);

  // setup reverb_roomsize menu
  reverb_roomsize_screen.add_line(reverb_roomsize_line1);
  reverb_roomsize_screen.add_line(reverb_roomsize_line2);
  reverb_roomsize_screen.set_displayLineCount(2);
  reverb_roomsize_menu.add_screen(reverb_roomsize_screen);

  // setup reverb_damping menu
  reverb_damping_screen.add_line(reverb_damping_line1);
  reverb_damping_screen.add_line(reverb_damping_line2);
  reverb_damping_screen.set_displayLineCount(2);
  reverb_damping_menu.add_screen(reverb_damping_screen);

  // setup reverb_level menu
  reverb_level_screen.add_line(reverb_level_line1);
  reverb_level_screen.add_line(reverb_level_line2);
  reverb_level_screen.set_displayLineCount(2);
  reverb_level_menu.add_screen(reverb_level_screen);

  // setup chorus_frequency menu
  chorus_frequency_screen.add_line(chorus_frequency_line1);
  chorus_frequency_screen.add_line(chorus_frequency_line2);
  chorus_frequency_screen.set_displayLineCount(2);
  chorus_frequency_menu.add_screen(chorus_frequency_screen);

  // setup chorus_delay menu
  chorus_delay_screen.add_line(chorus_delay_line1);
  chorus_delay_screen.add_line(chorus_delay_line2);
  chorus_delay_screen.set_displayLineCount(2);
  chorus_delay_menu.add_screen(chorus_delay_screen);

  // setup chorus_intensity menu
  chorus_intensity_screen.add_line(chorus_intensity_line1);
  chorus_intensity_screen.add_line(chorus_intensity_line2);
  chorus_intensity_screen.set_displayLineCount(2);
  chorus_intensity_menu.add_screen(chorus_intensity_screen);

  // setup chorus_feedback menu
  chorus_feedback_screen.add_line(chorus_feedback_line1);
  chorus_feedback_screen.add_line(chorus_feedback_line2);
  chorus_feedback_screen.set_displayLineCount(2);
  chorus_feedback_menu.add_screen(chorus_feedback_screen);

  // setup chorus_waveform menu
  chorus_waveform_screen.add_line(chorus_waveform_line1);
  chorus_waveform_screen.add_line(chorus_waveform_line2);
  chorus_waveform_screen.set_displayLineCount(2);
  chorus_waveform_menu.add_screen(chorus_waveform_screen);

  // setup chorus_level menu
  chorus_level_screen.add_line(chorus_level_line1);
  chorus_level_screen.add_line(chorus_level_line2);
  chorus_level_screen.set_displayLineCount(2);
  chorus_level_menu.add_screen(chorus_level_screen);

  // setup bass_lr_level menu
  bass_lr_level_screen.add_line(bass_lr_level_line1);
  bass_lr_level_screen.add_line(bass_lr_level_line2);
  bass_lr_level_screen.set_displayLineCount(2);
  bass_lr_level_menu.add_screen(bass_lr_level_screen);

  // setup bass_mono_level menu
  bass_mono_level_screen.add_line(bass_mono_level_line1);
  bass_mono_level_screen.add_line(bass_mono_level_line2);
  bass_mono_level_screen.set_displayLineCount(2);
  bass_mono_level_menu.add_screen(bass_mono_level_screen);

  // setup eq_bass menu
  eq_bass_screen.add_line(eq_bass_line1);
  eq_bass_screen.add_line(eq_bass_line2);
  eq_bass_screen.set_displayLineCount(2);
  eq_bass_menu.add_screen(eq_bass_screen);

  // setup eq_treble menu
  eq_treble_screen.add_line(eq_treble_line1);
  eq_treble_screen.add_line(eq_treble_line2);
  eq_treble_screen.set_displayLineCount(2);
  eq_treble_menu.add_screen(eq_treble_screen);

  // setup save_sound menu
  save_sound_screen.add_line(save_sound_line1);
  save_sound_screen.add_line(save_sound_line2);
  save_sound_screen.set_displayLineCount(2);
  save_sound_menu.add_screen(save_sound_screen);

  // setup store_question display
  store_question_line1.attach_function(STORE_QUESTION, callback_store_question_function);

  store_question_screen.add_line(store_question_line1);
  store_question_screen.add_line(store_question_line2);
  store_question_screen.set_displayLineCount(2);
  store_question_menu.add_screen(store_question_screen);

  // setup effects menu
  system_screen.add_line(system_line1);
  system_screen.add_line(system_line2);
  system_screen.add_line(system_line3);
  system_screen.add_line(system_line4);
  system_screen.add_line(system_line5);
  system_screen.set_displayLineCount(2);
  system_menu.add_screen(system_screen);

  system_line1.attach_function(LOUDNESS, callback_loudness_function);
  system_line2.attach_function(MIDI_CHANNEL, callback_midi_channel_function);
  system_line3.attach_function(MIDI_SOFT_THRU, callback_midi_soft_thru_function);
  system_line4.attach_function(MAX_POLY, callback_max_poly_function);
  system_line5.attach_function(MONO, callback_mono_function);

  // setup loudness
  loudness_screen.add_line(loudness_line1);
  loudness_screen.add_line(loudness_line2);
  loudness_screen.set_displayLineCount(2);
  loudness_menu.add_screen(loudness_screen);

  // setup midi_channel
  midi_channel_screen.add_line(midi_channel_line1);
  midi_channel_screen.add_line(midi_channel_line2);
  midi_channel_screen.set_displayLineCount(2);
  midi_channel_menu.add_screen(midi_channel_screen);

  // setup midi_soft_thru
  midi_soft_thru_screen.add_line(midi_soft_thru_line1);
  midi_soft_thru_screen.add_line(midi_soft_thru_line2);
  midi_soft_thru_screen.set_displayLineCount(2);
  midi_soft_thru_menu.add_screen(midi_soft_thru_screen);

  // setup max_poly
  max_poly_screen.add_line(max_poly_line1);
  max_poly_screen.add_line(max_poly_line2);
  max_poly_screen.set_displayLineCount(2);
  max_poly_menu.add_screen(max_poly_screen);

  // setup mono
  mono_screen.add_line(mono_line1);
  mono_screen.add_line(mono_line2);
  mono_screen.set_displayLineCount(2);
  mono_menu.add_screen(mono_screen);

  // setup info menu
  info_screen.add_line(info_line1);
  info_screen.add_line(info_line2);
  info_screen.set_displayLineCount(2);
  info_menu.add_screen(info_screen);

  // setup master_volume display
  master_volume_screen.add_line(master_volume_line1);
  master_volume_screen.add_line(master_volume_line2);
  master_volume_screen.set_displayLineCount(2);
  master_volume_menu.add_screen(master_volume_screen);

  // setup global system menu
  menu_system.add_menu(main_menu);
  menu_system.add_menu(load_sound_menu);
  menu_system.add_menu(edit_sound_menu);
  menu_system.add_menu(effects_menu);
  menu_system.add_menu(decay_menu);
  menu_system.add_menu(release_menu);
  menu_system.add_menu(hardness_menu);
  menu_system.add_menu(treble_menu);
  menu_system.add_menu(stereo_menu);
  menu_system.add_menu(transpose_menu);
  menu_system.add_menu(tune_menu);
  menu_system.add_menu(detune_menu);
  menu_system.add_menu(velocity_sense_menu);
  menu_system.add_menu(effects_menu);
  menu_system.add_menu(pan_trem_frequency_menu);
  menu_system.add_menu(pan_trem_level_menu);
  menu_system.add_menu(overdrive_menu);
  menu_system.add_menu(comp_gain_menu);
  menu_system.add_menu(comp_response_menu);
  menu_system.add_menu(comp_limit_menu);
  menu_system.add_menu(comp_threshold_menu);
  menu_system.add_menu(comp_attack_menu);
  menu_system.add_menu(comp_decay_menu);
  menu_system.add_menu(reverb_roomsize_menu);
  menu_system.add_menu(reverb_damping_menu);
  menu_system.add_menu(reverb_level_menu);
  menu_system.add_menu(chorus_frequency_menu);
  menu_system.add_menu(chorus_delay_menu);
  menu_system.add_menu(chorus_intensity_menu);
  menu_system.add_menu(chorus_feedback_menu);
  menu_system.add_menu(chorus_waveform_menu);
  menu_system.add_menu(chorus_level_menu);
  menu_system.add_menu(bass_lr_level_menu);
  menu_system.add_menu(bass_mono_level_menu);
  menu_system.add_menu(eq_bass_menu);
  menu_system.add_menu(eq_treble_menu);
  menu_system.add_menu(save_sound_menu);
  menu_system.add_menu(store_question_menu);
  menu_system.add_menu(system_menu);
  menu_system.add_menu(loudness_menu);
  menu_system.add_menu(midi_channel_menu);
  menu_system.add_menu(midi_soft_thru_menu);
  menu_system.add_menu(max_poly_menu);
  menu_system.add_menu(mono_menu);
  menu_system.add_menu(info_menu);
  menu_system.add_menu(master_volume_menu);

  menu_system.set_focusPosition(Position::LEFT);
  menu_system.switch_focus();
  menu_system.update();
  for ( i = 0; i < NUM_MENUS; i++)
    menu_position[i] = -1;
  menu_position[MAIN] = 0;

  // setup encoder
  for (i = 0; i < NUM_ENCODER; i++)
    but[i].update();
  master_volume = EEPROM.read(EEPROM_MASTER_VOLUME);
  enc[LEFT_ENCODER].write(master_volume, ENC_MASTER_VOLUME_MIN, ENC_MASTER_VOLUME_MAX);
  encoder_value[LEFT_ENCODER] = master_volume;
  enc[RIGHT_ENCODER].write(0, 0, NUM_MAIN_MENUS - 1);
  encoder_value[RIGHT_ENCODER] = 0;
}

void load_sound(void)
{
#ifdef SHOW_DEBUG
  Serial.print(F("Load sound "));
  Serial.println(sound, DEC);
#endif
  EEPROM.update(EEPROM_SOUND, sound);
  config_from_eeprom();
}

void save_sound(void)
{
#ifdef SHOW_DEBUG
  Serial.print(F("Save sound "));
  Serial.println(sound);
#endif
  eeprom_config_write(sound);
  yes_no = false;
}

void set_decay(uint8_t value)
{
  if (value > ENC_DECAY_MAX)
    value = ENC_DECAY_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set DECAY "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_DECAY_MIN, ENC_DECAY_MAX, 0.0, 1.0);
  ep->setDecay(tmp);
  configuration.decay = value;
}

void set_release(uint8_t value)
{
  if (value > ENC_RELEASE_MAX)
    value = ENC_RELEASE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set RELEASE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_RELEASE_MIN, ENC_RELEASE_MAX, 0.0, 1.0);
  ep->setRelease(tmp);
  configuration.release = value;
}

void set_hardness(uint8_t value)
{
  if (value > ENC_HARDNESS_MAX)
    value = ENC_HARDNESS_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set HARDNESS "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_HARDNESS_MIN, ENC_HARDNESS_MAX, 0.0, 1.0);
  ep->setHardness(tmp);
  configuration.hardness = value;
}

void set_treble(uint8_t value)
{
  if (value > ENC_TREBLE_MAX)
    value = ENC_TREBLE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set TREBLE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_TREBLE_MIN, ENC_TREBLE_MAX, 0.0, 1.0);
  ep->setTreble(tmp);
  configuration.treble = value;
}

void set_stereo(uint8_t value)
{
  if (value > ENC_STEREO_MAX)
    value = ENC_STEREO_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set STEREO "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_STEREO_MIN, ENC_STEREO_MAX, 0.0, 1.0);
  ep->setStereo(tmp);
  configuration.stereo = value;
}

void set_transpose(int8_t value)
{
  if (value < ENC_TRANSPOSE_MIN)
    value = ENC_TRANSPOSE_MIN;
  if (value > ENC_TRANSPOSE_MAX)
    value = ENC_TRANSPOSE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set TRANSPOSE "));
  Serial.println(value);
#endif
  // Nothing special todo, because value will be added inside NoteOn/NoteOff
  configuration.transpose = value;
}

void set_tune(int8_t value)
{
  if (value < ENC_TUNE_MIN)
    value = ENC_TUNE_MIN;
  if (value > ENC_TUNE_MAX)
    value = ENC_TUNE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set TUNE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_TUNE_MIN, ENC_TUNE_MAX, 0.0, 1.0);
  ep->setTune(tmp);
  configuration.tune = value;
}

void set_detune(uint8_t value)
{
  if (value > ENC_DETUNE_MAX)
    value = ENC_DETUNE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set DETUNE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_DETUNE_MIN, ENC_DETUNE_MAX, 0.0, 1.0);
  ep->setDetune(tmp);
  configuration.detune = value;
}

void set_velocity_sense(uint8_t value)
{
  if (value > ENC_VELOCITY_SENSE_MAX)
    value = ENC_VELOCITY_SENSE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set VELOCITY_SENSE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_VELOCITY_SENSE_MIN, ENC_VELOCITY_SENSE_MAX, 0.0, 1.0);
  ep->setVelocitySense(tmp);
  configuration.velocity_sense = value;
}

void set_pan_trem_frequency(uint8_t value)
{
  if (value > ENC_PAN_TREM_FREQUENCY_MAX)
    value = ENC_PAN_TREM_FREQUENCY_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set PAN_TREM_FREQENCY "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_PAN_TREM_FREQUENCY_MIN, ENC_PAN_TREM_FREQUENCY_MAX, 0.0, 1.0);
  ep->setPanLFO(tmp);
  configuration.pan_trem_frequency = value;
}

void set_pan_trem_level(uint8_t value)
{
  if (value > ENC_PAN_TREM_LEVEL_MAX)
    value = ENC_PAN_TREM_LEVEL_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set PAN_TREM_LEVEL "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_PAN_TREM_LEVEL_MIN, ENC_PAN_TREM_LEVEL_MAX, 0.0, 1.0);
  ep->setPanTremolo(tmp);
  configuration.pan_trem_level = value;
}

void set_overdrive(uint8_t value)
{
  if (value > ENC_OVERDRIVE_MAX)
    value = ENC_OVERDRIVE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set OVERDRIVE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_OVERDRIVE_MIN, ENC_OVERDRIVE_MAX, 0.0, 1.0);
  ep->setOverdrive(tmp);
  configuration.overdrive = value;
}

void set_comp_gain(uint8_t value)
{
  if (value > ENC_COMP_GAIN_MAX)
    value = ENC_COMP_GAIN_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set COMP_GAIN "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_COMP_GAIN_MIN, ENC_COMP_GAIN_MAX, 0.0, 1.0);
  sgtl5000_1.autoVolumeControl(tmp, configuration.comp_response, configuration.comp_limit, (float)configuration.comp_threshold, (float)configuration.comp_attack / 10, (float)configuration.comp_decay / 10); // maxGain, response, hardLimit, threshold, attack, decay, e.g.: 1, 1, 1, 0.9, 0.01, 0.05
  configuration.comp_gain = value;
}

void set_comp_response(uint8_t value)
{
  if (value > ENC_COMP_RESPONSE_MAX)
    value = ENC_COMP_RESPONSE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set COMP_RESPONSE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_COMP_RESPONSE_MIN, ENC_COMP_RESPONSE_MAX, 0.0, 1.0);
  sgtl5000_1.autoVolumeControl(configuration.comp_gain, tmp, configuration.comp_limit, (float)configuration.comp_threshold, (float)configuration.comp_attack / 10, (float)configuration.comp_decay / 10); // maxGain, response, hardLimit, threshold, attack, decay, e.g.: 1, 1, 1, 0.9, 0.01, 0.05
  configuration.comp_response = value;
}

void set_comp_limit(uint8_t value)
{
  if (value > ENC_COMP_LIMIT_MAX)
    value = ENC_COMP_LIMIT_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set COMP_LIMIT "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_COMP_LIMIT_MIN, ENC_COMP_LIMIT_MAX, 0.0, 1.0);
  sgtl5000_1.autoVolumeControl(configuration.comp_gain, configuration.comp_response, tmp, (float)configuration.comp_threshold, (float)configuration.comp_attack / 10, (float)configuration.comp_decay / 10); // maxGain, response, hardLimit, threshold, attack, decay, e.g.: 1, 1, 1, 0.9, 0.01, 0.05
  configuration.comp_limit = value;
}

void set_comp_threshold(uint8_t value)
{
  if (value > ENC_COMP_THRESHOLD_MAX)
    value = ENC_COMP_THRESHOLD_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set COMP_THRESHOLD "));
  Serial.println(value);
#endif
  //float tmp = mapfloat(float(value), ENC_COMP_THRESHOLD_MIN, ENC_COMP_THRESHOLD_MAX, 0.0, 1.0);
  sgtl5000_1.autoVolumeControl(configuration.comp_gain, configuration.comp_response, configuration.comp_limit, (float)value, (float)configuration.comp_attack / 10, (float)configuration.comp_decay / 10); // maxGain, response, hardLimit, threshold, attack, decay, e.g.: 1, 1, 1, 0.9, 0.01, 0.05
  configuration.comp_threshold = value;
}

void set_comp_attack(uint8_t value)
{
  if (value > ENC_COMP_ATTACK_MAX)
    value = ENC_COMP_ATTACK_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set COMP_ATTACK "));
  Serial.println(value);
#endif
  //float tmp = mapfloat(float(value), ENC_COMP_ATTACK_MIN, ENC_COMP_ATTACK_MAX, 0.0, 1.0);
  sgtl5000_1.autoVolumeControl(configuration.comp_gain, configuration.comp_response, configuration.comp_limit, (float)configuration.comp_threshold, (float)value / 10, (float)configuration.comp_decay / 10); // maxGain, response, hardLimit, threshold, attack, decay, e.g.: 1, 1, 1, 0.9, 0.01, 0.05
  configuration.comp_attack = value;
}

void set_comp_decay(uint8_t value)
{
  if (value > ENC_COMP_DECAY_MAX)
    value = ENC_COMP_DECAY_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set COMP_DECAY "));
  Serial.println(value);
#endif
  //float tmp = mapfloat(float(value), ENC_COMP_DECAY_MIN, ENC_COMP_DECAY_MAX, 0.0, 1.0);
  sgtl5000_1.autoVolumeControl(configuration.comp_gain, configuration.comp_response, configuration.comp_limit, (float)configuration.comp_threshold, (float)configuration.comp_attack / 10, (float)value / 10); // maxGain, response, hardLimit, threshold, attack, decay, e.g.: 1, 1, 1, 0.9, 0.01, 0.05
  configuration.comp_decay = value;
}

void set_reverb_roomsize(uint8_t value)
{
  if (value > ENC_REVERB_ROOMSIZE_MAX)
    value = ENC_REVERB_ROOMSIZE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set REVERB_ROOMSIZE "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_REVERB_ROOMSIZE_MIN, ENC_REVERB_ROOMSIZE_MAX, 0.0, 1.0);
  freeverb_r.roomsize(tmp);
  freeverb_l.roomsize(tmp);
  configuration.reverb_roomsize = value;
}

void set_reverb_damping(uint8_t value)
{
  if (value > ENC_REVERB_DAMPING_MAX)
    value = ENC_REVERB_DAMPING_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set REVERB_DAMPING "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_REVERB_DAMPING_MIN, ENC_REVERB_DAMPING_MAX, 0.0, 1.0);
  freeverb_r.damping(tmp);
  freeverb_l.damping(tmp);
  configuration.reverb_damping = value;
}

void set_reverb_level(uint8_t value)
{
  if (value > ENC_REVERB_LEVEL_MAX)
    value = ENC_REVERB_LEVEL_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set REVERB_LEVEL "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_REVERB_LEVEL_MIN, ENC_REVERB_LEVEL_MAX, 0.0, 1.0);
  mixer_r.gain(1, tmp);
  mixer_l.gain(1, tmp);
  configuration.reverb_level = value;
}

void set_chorus_frequency(uint8_t value)
{
  if (value > ENC_CHORUS_FREQUENCY_MAX)
    value = ENC_CHORUS_FREQUENCY_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set CHORUS_FREQUENCY "));
  Serial.println(value);
#endif
  modulator.frequency(float(value) / 10);
  configuration.chorus_frequency = value;
}

void set_chorus_delay(uint8_t value)
{
  if (value > ENC_CHORUS_DELAY_MAX)
    value = ENC_CHORUS_DELAY_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set CHORUS_DELAY "));
  Serial.print(value);
  Serial.print(F("/"));
  Serial.print(float(value) / 10);
  Serial.print(F("/"));
  Serial.print(uint16_t(TIME_MS2SAMPLES(float(value) / 10)));
  Serial.println();
#endif
  modchorus_r.offset(TIME_MS2SAMPLES(float(value) / 10));
  modchorus_l.offset(TIME_MS2SAMPLES(float(value) / 10));
  configuration.chorus_delay = value;
}

void set_chorus_intensity(uint8_t value)
{
  if (value > ENC_CHORUS_INTENSITY_MAX)
    value = ENC_CHORUS_INTENSITY_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set CHORUS_INTENSITY "));
  Serial.println(value);
#endif
  modulator.amplitude(mapfloat(float(value), ENC_CHORUS_INTENSITY_MIN, ENC_CHORUS_INTENSITY_MAX, 0.0, 1.0));
  configuration.chorus_intensity = value;
}

void set_chorus_feedback(uint8_t value)
{
  if (value > ENC_CHORUS_FEEDBACK_MAX)
    value = ENC_CHORUS_FEEDBACK_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set CHORUS_FEEDBACK "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_CHORUS_FEEDBACK_MIN, ENC_CHORUS_FEEDBACK_MAX, 0.0, 0.5);
  modchorus_fbk_mixer_r.gain(0, 1.0 - tmp);
  modchorus_fbk_mixer_l.gain(0, 1.0 - tmp);
  modchorus_fbk_mixer_r.gain(1, tmp);
  modchorus_fbk_mixer_l.gain(1, tmp);
  configuration.chorus_feedback = value;
}

void set_chorus_waveform(uint8_t value)
{
#ifdef SHOW_DEBUG
  Serial.print(F("Set CHORUS_WAVEFORM "));
#endif
  switch (value)
  {
    case 1:
      modulator.begin(WAVEFORM_TRIANGLE);
      break;
    case 2:
      modulator.begin(WAVEFORM_SINE);
      break;
    default:
      modulator.begin(WAVEFORM_TRIANGLE);
      value = 1;
      break;
  }
  configuration.chorus_waveform = value;
  Serial.println(value);
}

void set_chorus_level(uint8_t value)
{
  if (value > ENC_CHORUS_LEVEL_MAX)
    value = ENC_CHORUS_LEVEL_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set CHORUS_LEVEL "));
  Serial.println(value);
#endif
  float tmp = mapfloat(float(value), ENC_CHORUS_LEVEL_MIN, ENC_CHORUS_LEVEL_MAX, 0.0, 0.5);
  mixer_r.gain(0, 1.0 - tmp);
  mixer_l.gain(0, 1.0 - tmp);
  mixer_r.gain(2, tmp);
  mixer_l.gain(2, tmp);
  configuration.chorus_level = value;
}

void set_bass_lr_level(uint8_t value)
{
  if (value > ENC_BASS_MONO_LEVEL_MAX)
    value = ENC_BASS_MONO_LEVEL_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set BASS_LR_LEVEL "));
  Serial.println(value);
#endif
  float tmp1 = mapfloat(float(value), ENC_BASS_LR_LEVEL_MIN, ENC_BASS_LR_LEVEL_MAX, 0.0, 1.0);
  float tmp2 = mapfloat(float(configuration.bass_mono_level), ENC_BASS_MONO_LEVEL_MIN, ENC_BASS_MONO_LEVEL_MAX, 0.0, 1.0);
  sgtl5000_1.enhanceBass(tmp1, tmp2);
  configuration.bass_lr_level = value;
}

void set_bass_mono_level(uint8_t value)
{
  if (value > ENC_BASS_LR_LEVEL_MAX)
    value = ENC_BASS_LR_LEVEL_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set BASS_MONO_LEVEL "));
  Serial.println(value);
#endif
  float tmp1 = mapfloat(float(configuration.bass_lr_level), ENC_BASS_LR_LEVEL_MIN, ENC_BASS_LR_LEVEL_MAX, 0.0, 1.0);
  float tmp2 = mapfloat(float(value), ENC_BASS_MONO_LEVEL_MIN, ENC_BASS_MONO_LEVEL_MAX, 0.0, 1.0);
  sgtl5000_1.enhanceBass(tmp1, tmp2);
  configuration.bass_mono_level = value;
}

void set_eq_bass(int8_t value)
{
  if (value > ENC_EQ_TREBLE_MAX)
    value = ENC_EQ_TREBLE_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set EQ_BASS "));
  Serial.println(value);
#endif
  float tmp1 = mapfloat(float(value), ENC_EQ_BASS_MIN, ENC_EQ_BASS_MAX, -1.0, 1.0);
  float tmp2 = mapfloat(float(configuration.eq_treble), ENC_EQ_TREBLE_MIN, ENC_EQ_TREBLE_MAX, -1.0, 1.0);
  sgtl5000_1.eqBands(tmp1, tmp2);
  configuration.eq_bass = value;
}

void set_eq_treble(int8_t value)
{
  if (value > ENC_EQ_BASS_MAX )
    value = ENC_EQ_BASS_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set EQ_TREBLE "));
  Serial.println(value);
#endif
  float tmp1 = mapfloat(float(configuration.eq_bass), ENC_EQ_BASS_MIN, ENC_EQ_BASS_MAX, -1.0, 1.0);
  float tmp2 = mapfloat(float(value), ENC_EQ_TREBLE_MIN, ENC_EQ_TREBLE_MAX, -1.0, 1.0);
  sgtl5000_1.eqBands(tmp1, tmp2);
  configuration.eq_treble = value;
}

void set_loudness(uint8_t value)
{
  if (value > ENC_LOUDNESS_MAX)
    value = ENC_LOUDNESS_MAX;
#ifdef SHOW_DEBUG
  Serial.print(F("Set LOUDNESS "));
  Serial.println(value);
#endif
  ep->setLoudness(mapfloat(float(value), ENC_LOUDNESS_MIN, ENC_LOUDNESS_MAX, 0.0, 1.0));
  //volume_r.gain(tmp);
  //volume_l.gain(tmp);
  configuration.loudness = value;
}

void set_midi_channel(uint8_t value)
{
  if (value > 16)
    value = 16;
#ifdef SHOW_DEBUG
  Serial.print(F("Set MIDI_CHANNEL "));
  Serial.println(value);
#endif
  configuration.midi_channel = value;
}

void set_midi_soft_thru(uint8_t value)
{
  if (value > 1)
    value = 1;
#ifdef SHOW_DEBUG
  Serial.print(F("Set MIDI_SOFT_THRU "));
  Serial.println(value);
#endif
  configuration.midi_soft_thru = value;
}

void set_max_poly(uint8_t value)
{
  if (value > ENC_MAX_POLY_DEFAULT)
    value = ENC_MAX_POLY_DEFAULT;
#ifdef SHOW_DEBUG
  Serial.print(F("Set MAX_POLY "));
  Serial.println(value);
#endif
  ep->setMaxPolyphony(value);
  configuration.max_poly = value;
  ep->reset_voices();
}

void set_mono(uint8_t mode)
{
#ifdef SHOW_DEBUG
  Serial.print(F("Set MONO "));
  Serial.println(mode);
#endif
  if (mode == 0)
  {
    ep->setStereo(mapfloat(float(configuration.stereo), ENC_STEREO_MIN, ENC_STEREO_MAX, 0.0, 1.0));
    inverter.gain(-1.0); // change phase for second modulated delay (faked stereo mode)
    configuration.mono = 0;
  }
  else
  {
    ep->setStereo(0.0);
    inverter.gain(1.0);
    configuration.mono = 1;
  }
}

void set_complete_configuration(void)
{
  set_decay(configuration.decay);
  set_release(configuration.release);
  set_hardness(configuration.hardness);
  set_treble(configuration.treble);
  set_stereo(configuration.stereo);
  set_tune(configuration.tune);
  set_detune(configuration.detune);
  set_velocity_sense(configuration.velocity_sense);
  set_pan_trem_frequency(configuration.pan_trem_frequency);
  set_pan_trem_level(configuration.pan_trem_level);
  set_overdrive(configuration.overdrive);
  set_comp_gain(configuration.comp_gain);
  set_comp_response(configuration.comp_response);
  set_comp_limit(configuration.comp_limit);
  set_comp_threshold(configuration.comp_threshold);
  set_comp_attack(configuration.comp_attack);
  set_comp_decay(configuration.comp_decay);
  set_reverb_roomsize(configuration.reverb_roomsize);
  set_reverb_damping(configuration.reverb_damping);
  set_reverb_level(configuration.reverb_level);
  set_chorus_frequency(configuration.chorus_frequency);
  set_chorus_delay(configuration.chorus_delay);
  set_chorus_intensity(configuration.chorus_intensity);
  set_chorus_feedback(configuration.chorus_feedback);
  set_chorus_waveform(configuration.chorus_waveform);
  set_chorus_level(configuration.chorus_level);
  set_bass_lr_level(configuration.bass_lr_level);
  set_bass_mono_level(configuration.bass_mono_level);
  set_eq_bass(configuration.eq_bass);
  set_eq_treble(configuration.eq_treble);
  set_loudness(configuration.loudness);
  set_midi_channel(configuration.midi_channel);
  set_midi_soft_thru(configuration.midi_soft_thru);
  set_max_poly(configuration.max_poly);
  set_mono(configuration.mono);
}

//********************************************************************************************+
void handle_ui(void)
{
  uint8_t i;
  int32_t encoder_tmp;

  if (back_to_main > BACK_TO_MAIN_MS && menu_system.get_currentScreen() == &master_volume_screen)
  {
    {
#ifdef SHOW_DEBUG
      Serial.println(F("from master_volume to main"));
#endif
      goto_main_menu(MASTER_VOLUME);
    }
  }

  for (i = 0; i < NUM_ENCODER; i++)
  {
    but[i].update();

    switch (i)
    {
      case RIGHT_ENCODER:
        // Encoder handling
        encoder_tmp = enc[RIGHT_ENCODER].read();

        if (menu_system.get_currentScreen() == &load_sound_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            sound = encoder_tmp;
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &decay_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_decay(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &release_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_release(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &hardness_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_hardness(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &treble_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_treble(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &stereo_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_stereo(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &transpose_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_transpose(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &tune_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_tune(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &detune_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_detune(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &velocity_sense_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_velocity_sense(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &pan_trem_frequency_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_pan_trem_frequency(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &pan_trem_level_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_pan_trem_level(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &overdrive_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_overdrive(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &comp_gain_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_comp_gain(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &comp_response_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_comp_response(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &comp_limit_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_comp_limit(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &comp_threshold_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_comp_threshold(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &comp_attack_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_comp_attack(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &comp_decay_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_comp_decay(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &reverb_roomsize_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_reverb_roomsize(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &reverb_damping_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_reverb_damping(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &reverb_level_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_reverb_level(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &chorus_frequency_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_chorus_frequency(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &chorus_delay_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_chorus_delay(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &chorus_intensity_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_chorus_intensity(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &chorus_feedback_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_chorus_feedback(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &chorus_waveform_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_chorus_waveform(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &chorus_level_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_chorus_level(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &bass_lr_level_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_bass_lr_level(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &bass_mono_level_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_bass_mono_level(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &eq_bass_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_eq_bass(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &eq_treble_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_eq_treble(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &save_sound_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            sound = encoder_tmp;
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &store_question_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            yes_no = encoder_tmp;
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &loudness_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_loudness(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &midi_channel_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_midi_channel(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &midi_soft_thru_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_midi_soft_thru(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &max_poly_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_max_poly(encoder_tmp);
            menu_system.update();
          }
        }
        else if (menu_system.get_currentScreen() == &mono_screen)
        {
          if (encoder_tmp != encoder_value[RIGHT_ENCODER])
          {
            // value up/down
            set_mono(encoder_tmp);
            menu_system.update();
          }
        }
        else
        {
          // Move menu focus
          if (encoder_tmp > encoder_value[RIGHT_ENCODER])
          {
            // move down
#ifdef SHOW_DEBUG
            Serial.print(F("ENC-R-DOWN: "));
            Serial.println(encoder_tmp);
#endif
            encoder_switch_focus(encoder_tmp, encoder_value[RIGHT_ENCODER]);
            menu_system.softUpdate();
          }
          else if (encoder_tmp < encoder_value[RIGHT_ENCODER])
          {
            // move up
#ifdef SHOW_DEBUG
            Serial.print(F("ENC-R-UP: "));
            Serial.println(encoder_tmp);
#endif
            encoder_switch_focus(encoder_tmp, encoder_value[RIGHT_ENCODER]);
            menu_system.softUpdate();
          }
        }
        encoder_value[RIGHT_ENCODER] = encoder_tmp;

        // button handling
        if (but[i].fallingEdge()) // SELECT
        {
#ifdef SHOW_DEBUG
          Serial.println(F("SELECT-R"));
#endif

          if (menu_system.get_currentScreen() == &load_sound_screen)
          {
            // load sound
#ifdef SHOW_DEBUG
            Serial.print("Load sound ");
            Serial.println();
#endif
            load_sound();
            goto_main_menu(LOAD_SOUND);
          }
          else if (menu_system.get_currentScreen() == &save_sound_screen)
          {
            // ask for storing sound
#ifdef SHOW_DEBUG
            Serial.print("Storing sound?");
            Serial.println();
#endif
            goto_store_question_menu(SAVE_SOUND);
          }
          else if (menu_system.get_currentScreen() == &store_question_screen)
          {
            // save sound
            if (encoder_tmp == 1)
            {
#ifdef SHOW_DEBUG
              Serial.print(F("Save sound "));
              Serial.println(sound, DEC);
#endif
              save_sound();
            }
#ifdef SHOW_DEBUG
            else
              Serial.println(F("Not saving sound!"));
#endif
            goto_main_menu(SAVE_SOUND);
          }
          else
          {
            uint8_t menu_callback_offset = 0;

            if (menu_system.get_currentScreen() == &edit_sound_screen)
              menu_callback_offset = NUM_MAIN_MENUS;
            else if (menu_system.get_currentScreen() == &effects_screen)
              menu_callback_offset = NUM_MAIN_MENUS + NUM_EDIT_SOUND_MENUS;
            else if (menu_system.get_currentScreen() == &system_screen)
              menu_callback_offset = NUM_MAIN_MENUS + NUM_EDIT_SOUND_MENUS + NUM_EFFECTS_MENUS;

#ifdef SHOW_DEBUG
            Serial.print(F("Starting callback number "));
            Serial.println(encoder_value[RIGHT_ENCODER] + menu_callback_offset, DEC);
            Serial.print(F("encoder_value[RIGHT_ENCODER]="));
            Serial.print(encoder_value[RIGHT_ENCODER], DEC);
            Serial.print(F(" menu_callback_offset="));
            Serial.println(menu_callback_offset, DEC);
#endif

            if (menu_system.is_callable(encoder_value[RIGHT_ENCODER] + 1 + menu_callback_offset))
            {
              // change menu
              menu_system.call_function(encoder_value[RIGHT_ENCODER] + 1 + menu_callback_offset);
              //menu_system.update();
            }
#ifdef SHOW_DEBUG
            else
            {
              Serial.print(F("No callback for "));
              Serial.println(encoder_value[RIGHT_ENCODER] + 1 + menu_callback_offset, DEC);
            }
#endif
          }
        }
        break;
      case LEFT_ENCODER:
        // Encoder handling
        encoder_tmp = enc[LEFT_ENCODER].read();

        // Change volume
        if (encoder_tmp > encoder_value[LEFT_ENCODER])
        {
          // move down
#ifdef SHOW_DEBUG
          Serial.print(F("ENC-L-DOWN: "));
          Serial.println(encoder_tmp);
#endif
        }
        else if (encoder_tmp < encoder_value[LEFT_ENCODER])
        {
          // move up
#ifdef SHOW_DEBUG
          Serial.print(F("ENC-L-UP: "));
          Serial.println(encoder_tmp);
#endif
        }
        if (encoder_tmp != encoder_value[LEFT_ENCODER])
        {
          master_volume = encoder_tmp;
          set_master_volume(master_volume);
#ifdef SHOW_DEBUG
          Serial.print(F("master_volume: "));
          Serial.println(master_volume);
#endif
          menu_system.change_menu(master_volume_menu);
          menu_system.update();
          back_to_main = 0;
        }
        encoder_value[LEFT_ENCODER] = encoder_tmp;

        // button handling
        if (but[i].fallingEdge()) // BACK
        {
#ifdef SHOW_DEBUG
          Serial.print("Back press detected: ");
#endif
          if (menu_system.get_currentScreen() == &load_sound_screen) // load_sound menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from load_sound to main"));
#endif
            goto_main_menu(LOAD_SOUND);
          }
          else if (menu_system.get_currentScreen() == &edit_sound_screen) // sound menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from edit_sound to main"));
#endif
            goto_main_menu(EDIT_SOUND);

          }
          else if (menu_system.get_currentScreen() == &decay_screen) // decay menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from decay to edit_sound"));
#endif
            goto_edit_sound_menu(DECAY);
          }
          else if (menu_system.get_currentScreen() == &release_screen) // release menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from release to edit_sound"));
#endif
            goto_edit_sound_menu(RELEASE);
          }
          else if (menu_system.get_currentScreen() == &hardness_screen) // hardness menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from hardness to edit_sound"));
#endif
            goto_edit_sound_menu(HARDNESS);
          }
          else if (menu_system.get_currentScreen() == &treble_screen) // treble menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from treble to edit_sound"));
#endif
            goto_edit_sound_menu(TREBLE);
          }
          else if (menu_system.get_currentScreen() == &stereo_screen) // stereo menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from stereo to edit_sound"));
#endif
            goto_edit_sound_menu(STEREO_LEVEL);
          }
          else if (menu_system.get_currentScreen() == &transpose_screen) // transpose menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from transpose to edit_sound"));
#endif
            goto_edit_sound_menu(TRANSPOSE);
          }
          else if (menu_system.get_currentScreen() == &tune_screen) // tune menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from tune to edit_sound"));
#endif
            goto_edit_sound_menu(TUNE);
          }
          else if (menu_system.get_currentScreen() == &detune_screen) // detune menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from detune to edit_sound"));
#endif
            goto_edit_sound_menu(DETUNE);
          }
          else if (menu_system.get_currentScreen() == &velocity_sense_screen) // velocity_sense menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from velocity_sense to edit_sound"));
#endif
            goto_edit_sound_menu(VELOCITY_SENSE);
          }
          else if (menu_system.get_currentScreen() == &effects_screen) // effect menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from effect to main"));
#endif
            goto_main_menu(EFFECTS);
          }
          else if (menu_system.get_currentScreen() == &pan_trem_frequency_screen) //pan_trem_frequency  menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from pan_trem_frequency to effects"));
#endif
            goto_effects_menu(PAN_TREM_FREQUENCY);
          }
          else if (menu_system.get_currentScreen() == &pan_trem_level_screen) // pan_trem_level menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from pan_trem_level to effects"));
#endif
            goto_effects_menu(PAN_TREM_LEVEL);
          }
          else if (menu_system.get_currentScreen() == &overdrive_screen) // overdrive menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from overdrive to effects"));
#endif
            goto_effects_menu(OVERDRIVE);
          }
          else if (menu_system.get_currentScreen() == &comp_gain_screen) // comp_gain menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from comp_gain to effects"));
#endif
            goto_effects_menu(COMP_GAIN);
          }
          else if (menu_system.get_currentScreen() == &comp_response_screen) // comp_response menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from comp_response to effects"));
#endif
            goto_effects_menu(COMP_RESPONSE);
          }
          else if (menu_system.get_currentScreen() == &comp_limit_screen) // comp_limit menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from  comp_limit to effects"));
#endif
            goto_effects_menu(COMP_LIMIT);
          }
          else if (menu_system.get_currentScreen() == &comp_threshold_screen) // comp_threshold menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from comp_threshold to effects"));
#endif
            goto_effects_menu(COMP_THRESHOLD);
          }
          else if (menu_system.get_currentScreen() == &comp_attack_screen) // comp_attack menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from comp_attack to effects"));
#endif
            goto_effects_menu(COMP_ATTACK);
          }
          else if (menu_system.get_currentScreen() == &comp_decay_screen) // comp_decay menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from comp_decay to effects"));
#endif
            goto_effects_menu(COMP_DECAY);
          }
          else if (menu_system.get_currentScreen() == &reverb_roomsize_screen) // reverb_roomsize menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from reverb_roomsize to effects"));
#endif
            goto_effects_menu(REV_ROOMSIZE);
          }
          else if (menu_system.get_currentScreen() == &reverb_damping_screen) // reverb_damping menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from reverb_damping to effects"));
#endif
            goto_effects_menu(REV_DAMPING);
          }
          else if (menu_system.get_currentScreen() == &reverb_level_screen) // reverb_level menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from reverb_level to effects"));
#endif
            goto_effects_menu(REV_LEVEL);
          }
          else if (menu_system.get_currentScreen() == &chorus_frequency_screen) // chorus_frequency menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from chorus_frequency to effects"));
#endif
            goto_effects_menu(CHORUS_FREQ);
          }
          else if (menu_system.get_currentScreen() == &chorus_delay_screen) // chorus_delay menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from chorus_delay to effects"));
#endif
            goto_effects_menu(CHORUS_DELAY);
          }
          else if (menu_system.get_currentScreen() == &chorus_intensity_screen) // chorus_intensity menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from chorus_intensity to effects"));
#endif
            goto_effects_menu(CHORUS_INTENSITY);
          }
          else if (menu_system.get_currentScreen() == &chorus_feedback_screen) // chorus_feedback menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from chorus_feedback to effects"));
#endif
            goto_effects_menu(CHORUS_FEEDBACK);
          }
          else if (menu_system.get_currentScreen() == &chorus_waveform_screen) // chorus_waveform menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from chorus_waveform to effects"));
#endif
            goto_effects_menu(CHORUS_WAVEFORM);
          }
          else if (menu_system.get_currentScreen() == &chorus_level_screen) // chorus_level menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from chorus_level to effects"));
#endif
            goto_effects_menu(CHORUS_LEVEL);
          }
          else if (menu_system.get_currentScreen() == &bass_lr_level_screen) // bass_lr_level menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from bass_lr_level to effects"));
#endif
            goto_effects_menu(BASS_LR_LEVEL);
          }
          else if (menu_system.get_currentScreen() == &bass_mono_level_screen) // bass_mono_level menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from bass_mono_level to effects"));
#endif
            goto_effects_menu(BASS_MONO_LEVEL);
          }
          else if (menu_system.get_currentScreen() == &eq_bass_screen) // eq_bass menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from eq_bass to effects"));
#endif
            goto_effects_menu(EQ_BASS);
          }
          else if (menu_system.get_currentScreen() == &eq_treble_screen) // eq_treble menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from eq_treble to main"));
#endif
            goto_effects_menu(EQ_TREBLE);
          }
          else if (menu_system.get_currentScreen() == &save_sound_screen) // save_sound menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from save_sound to main"));
#endif
            goto_main_menu(SAVE_SOUND);
          }
          else if (menu_system.get_currentScreen() == &store_question_screen) // store_question menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from store_question to main"));
#endif
            goto_main_menu(SAVE_SOUND);
          }
          else if (menu_system.get_currentScreen() == &system_screen) // system menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from system to main"));
#endif
            goto_main_menu(SYSTEM);
          }
          else if (menu_system.get_currentScreen() == &loudness_screen) // loudness menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from loudness to system"));
#endif
            goto_system_menu(LOUDNESS);
          }
          else if (menu_system.get_currentScreen() == &midi_channel_screen) // midi_channel menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from midi_channel to system"));
#endif
            goto_system_menu(MIDI_CHANNEL);
          }
          else if (menu_system.get_currentScreen() == &midi_soft_thru_screen) // midi_soft_thru menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from midi_soft_thru to system"));
#endif
            goto_system_menu(MIDI_SOFT_THRU);
          }
          else if (menu_system.get_currentScreen() == &max_poly_screen) // max_poly menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from max_poly to system"));
#endif
            goto_system_menu(MAX_POLY);
          }
          else if (menu_system.get_currentScreen() == &mono_screen) // mono menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from mono to system"));
#endif
            goto_system_menu(MONO);
          }
          else if (menu_system.get_currentScreen() == &info_screen) // info menu
          {
#ifdef SHOW_DEBUG
            Serial.println(F("from info to main"));
#endif
            goto_main_menu(INFO);
          }
        }
    }
  }
}
#endif