MicroDexed/UI.hpp

/*
   MicroDexed

   MicroDexed is a port of the Dexed sound engine
   (https://github.com/asb2m10/dexed) for the Teensy-3.5/3.6 with audio shield.
   Dexed ist heavily based on https://github.com/google/music-synthesizer-for-android

   (c)2018,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
*/

#ifdef ENABLE_LCD_UI
#ifndef _UI_HPP_
#define _UI_HPP_

#include "config.h"
#include "Disp_Plus.h"
#include "effect_modulated_delay.h"
#include "effect_stereo_mono.h"
#include "dexed.h"

#define ENCODER_USE_INTERRUPTS

#include <LCDMenuLib2.h>
#include <Encoder.h>

#define _LCDML_DISP_cols  LCD_cols
#define _LCDML_DISP_rows  LCD_rows

#ifdef I2C_DISPLAY
#define _LCDML_DISP_cfg_cursor                     0x7E   // cursor Symbol
#else
#define _LCDML_DISP_cfg_cursor                     0x8d   // cursor Symbol
#endif
#define _LCDML_DISP_cfg_scrollbar                  1      // enable a scrollbar

extern config_t configuration;
extern uint8_t dexed_setup_number;
extern void set_volume(uint8_t v, uint8_t m);
extern char bank_names[NUM_DEXED][MAX_BANKS][BANK_NAME_LEN];
extern char bank_name[NUM_DEXED][BANK_NAME_LEN];
extern char voice_name[NUM_DEXED][VOICE_NAME_LEN];
extern char voice_names[NUM_DEXED][MAX_VOICES][VOICE_NAME_LEN];
extern void strip_extension(char* s, char *target);
extern void eeprom_write(void);
extern bool get_voice_names_from_bank(uint8_t b, uint8_t instance_id);
extern bool load_sysex(uint8_t b, uint8_t v);
#ifdef DISPLAY_LCD_SPI
extern void change_disp_sd(bool d);
#endif
#ifdef USE_FX
extern AudioEffectDelay          delay_r;
extern AudioEffectDelay          delay_l;
extern AudioEffectFreeverb       freeverb_r;
extern AudioEffectFreeverb       freeverb_l;
extern AudioMixer4               reverb_send_mixer_r;
extern AudioMixer4               reverb_send_mixer_l;
extern AudioEffectModulatedDelay modchorus_r;
extern AudioEffectModulatedDelay modchorus_l;
extern AudioSynthWaveform       chorus_modulator;
extern AudioMixer4              chorus_send_mixer_r;
extern AudioMixer4              chorus_send_mixer_l;
extern AudioMixer4              delay_send_mixer_r;
extern AudioMixer4              delay_send_mixer_l;
extern AudioMixer4              delay_fb_mixer_r;
extern AudioMixer4              delay_fb_mixer_l;
#endif
extern AudioMixer4              master_mixer_r;
extern AudioMixer4              master_mixer_l;
extern AudioAmplifier           volume_r;
extern AudioAmplifier           volume_l;
extern AudioEffectStereoMono    stereo2mono;
extern AudioSourceMicroDexed*   MicroDexed[NUM_DEXED];
extern AudioEffectMonoStereo*   mono2stereo[NUM_DEXED];
extern AudioSynthWaveformDc*    pan[NUM_DEXED];
extern uint8_t selected_dexed_instance;

/***********************************************************************
   GLOBAL
************************************************************************/
elapsedMillis back_from_volume;

#ifdef I2C_DISPLAY
#include <LiquidCrystal_I2C.h>
Disp_Plus<LiquidCrystal_I2C> lcd(LCD_I2C_ADDRESS, _LCDML_DISP_cols, _LCDML_DISP_rows);
#endif

#ifdef U8X8_DISPLAY
#include <U8x8lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif
Disp_Plus<U8X8_DISPLAY_CLASS> lcd(/* cs=*/ U8X8_CS_PIN, /* dc=*/ U8X8_DC_PIN, /* reset=*/ U8X8_RESET_PIN);
//Disp_Plus<U8X8_DISPLAY_CLASS> lcd(U8X8_PIN_NONE);
#endif

const uint8_t scroll_bar[5][8] = {
  {B10001, B10001, B10001, B10001, B10001, B10001, B10001, B10001}, // scrollbar top
  {B11111, B11111, B10001, B10001, B10001, B10001, B10001, B10001}, // scroll state 1
  {B10001, B10001, B11111, B11111, B10001, B10001, B10001, B10001}, // scroll state 2
  {B10001, B10001, B10001, B10001, B11111, B11111, B10001, B10001}, // scroll state 3
  {B10001, B10001, B10001, B10001, B10001, B10001, B11111, B11111}  // scrollbar bottom
};

const uint8_t block_bar[5][8] = {
  {B10000, B10000, B10000, B10000, B10000, B10000, B10000, B10000},
  {B11000, B11000, B11000, B11000, B11000, B11000, B11000, B11000},
  {B11100, B11100, B11100, B11100, B11100, B11100, B11100, B11100},
  {B11110, B11110, B11110, B11110, B11110, B11110, B11110, B11110},
  {B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111}
};

enum { SCROLLBAR, BLOCKBAR };
enum { ENC_R, ENC_L };
enum { MENU_START, MENU_VOICE, MENU_EDIT, MENU_VOLUME };
enum {MENU_VOICE_BANK, MENU_VOICE_SOUND};
uint8_t menu_state = MENU_START;
uint8_t menu_voice = MENU_VOICE_SOUND;
void lcdml_menu_display(void);
void lcdml_voice_menu_display(void);
void lcdml_menu_clear(void);
void lcdml_menu_control(void);
void encoder_right_up(void);
void encoder_right_down(void);
void encoder_right_button_long(void);
void encoder_right_button_short(void);
void encoder_left_up(void);
void encoder_left_down(void);
void encoder_left_button_long(void);
void encoder_left_button_short(void);
void lcdml_voice_menu_control(void);
void UI_func_sound(uint8_t param);
#ifdef USE_FX
void UI_func_reverb_roomsize(uint8_t param);
void UI_func_reverb_damping(uint8_t param);
void UI_func_reverb_send(uint8_t param);
void UI_func_reverb_level(uint8_t param);
void UI_func_chorus_frequency(uint8_t param);
void UI_func_chorus_waveform(uint8_t param);
void UI_func_chorus_depth(uint8_t param);
void UI_func_chorus_send(uint8_t param);
void UI_func_chorus_level(uint8_t param);
void UI_func_delay_time(uint8_t param);
void UI_func_delay_feedback(uint8_t param);
void UI_func_delay_send(uint8_t param);
void UI_func_delay_level(uint8_t param);
void UI_func_filter_cutoff(uint8_t param);
void UI_func_filter_resonance(uint8_t param);
#endif
void UI_func_transpose(uint8_t param);
void UI_func_tune(uint8_t param);
void UI_func_midi_channel(uint8_t param);
void UI_func_sound_intensity(uint8_t param);
void UI_func_panorama(uint8_t param);
void UI_func_stereo_mono(uint8_t param);
void UI_func_polyphony(uint8_t param);
void UI_func_engine(uint8_t param);
void UI_func_mono_poly(uint8_t param);
void UI_func_pb_range(uint8_t param);
void UI_func_pb_step(uint8_t param);
void UI_func_mw_range(uint8_t param);
void UI_func_mw_assign(uint8_t param);
void UI_func_fc_range(uint8_t param);
void UI_func_fc_assign(uint8_t param);
void UI_func_bc_range(uint8_t param);
void UI_func_bc_assign(uint8_t param);
void UI_func_at_range(uint8_t param);
void UI_func_at_assign(uint8_t param);
void UI_func_portamento_mode(uint8_t param);
void UI_func_portamento_glissando(uint8_t param);
void UI_func_portamento_time(uint8_t param);
void UI_func_OP1(uint8_t param);
void UI_func_OP2(uint8_t param);
void UI_func_OP3(uint8_t param);
void UI_func_OP4(uint8_t param);
void UI_func_OP5(uint8_t param);
void UI_func_OP6(uint8_t param);
void UI_handle_OP(uint8_t param, uint8_t op, uint8_t instance_id);
void UI_func_information(uint8_t param);
void UI_func_voice_selection(uint8_t param);
void UI_func_volume(uint8_t param);
void UI_func_load(uint8_t param);
void UI_func_save(uint8_t param);
void UI_func_midi_soft_thru(uint8_t param);
void UI_function_not_enabled(void);
void UI_function_not_implemented(uint8_t param);
void lcd_display_int(int16_t var, uint8_t size, bool zeros, bool brackets, bool sign);
void lcd_display_float(float var, uint8_t size_number, uint8_t size_fraction, bool zeros, bool brackets, bool sign);
void lcd_display_bar(const char* title, uint32_t value, uint32_t min_value, uint32_t max_value, bool init);
void lcd_special_chars(uint8_t mode);

// normal menu
LCDMenuLib2_menu LCDML_0(255, 0, 0, NULL, NULL); // normal root menu element (do not change)
LCDMenuLib2 LCDML(LCDML_0, _LCDML_DISP_rows, _LCDML_DISP_cols, lcdml_menu_display, lcdml_menu_clear, lcdml_menu_control);

#if defined(NUM_DEXED)>1 && defined(USE_FX)
#include "UI_2_FX.h"
#elif defined(NUM_DEXED)==1 && defined(USE_FX)
#include "UI_1_FX.h"
#elif defined(NUM_DEXED)==2 && !defined(USE_FX)
#include "UI_2.h"
#else
#include "UI_1.h"
#endif

// create menu
LCDML_createMenu(_LCDML_DISP_cnt);

/***********************************************************************
   CONTROL
 ***********************************************************************/
#define g_LCDML_CONTROL_button_long_press LONG_BUTTON_PRESS
#define g_LCDML_CONTROL_button_short_press BUT_DEBOUNCE_MS

//#define ENCODER_OPTIMIZE_INTERRUPTS //Only when using pin2/3 (or 20/21 on mega)
Encoder ENCODER[NUM_ENCODER] = {Encoder(ENC_R_PIN_B, ENC_R_PIN_A), Encoder(ENC_L_PIN_B, ENC_L_PIN_A)};

long  g_LCDML_CONTROL_button_press_time[NUM_ENCODER] = {0, 0};
bool  g_LCDML_CONTROL_button_prev[NUM_ENCODER] = {HIGH, HIGH};
uint8_t g_LCDML_CONTROL_prev[NUM_ENCODER] = {0, 0};

#ifdef U8X8_DISPLAY
const uint8_t * flipped_scroll_bar[5];
const uint8_t * flipped_block_bar[5];

uint8_t * rotTile(const uint8_t * tile) {
  uint8_t * newt = new uint8_t[8];
  for (int x = 0; x < 8; x++) {
    uint8_t newb = 0;
    for (int y = 0 ; y < 8; y++) {
      newb |= (tile[y] << x) & 0x80;
      newb >>= 1;
    }
    newt[x] = newb;
  }
  return newt;
}
#endif

void setup_ui(void) {
  // LCD Begin
#ifdef I2C_DISPLAY
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.blink_off();
  lcd.cursor_off();
  lcd.backlight();
#else
  lcd.begin();
  lcd.clear();
  lcd.setFont(u8x8_font_amstrad_cpc_extended_f);
#endif
  lcd.setCursor(3, 0);
  lcd.print(F("MicroDexed"));
  lcd.setCursor(0, 1);
  lcd.print(F("(c)parasiTstudio"));

  lcd_special_chars(SCROLLBAR);

  // LCDMenuLib Setup
  LCDML_setup(_LCDML_DISP_cnt);
  // Enable Menu Rollover
  //LCDML.MENU_enRollover();
  // Enable Screensaver (screensaver menu function, time to activate in ms)
  //LCDML.SCREEN_enable(UI_func_voice_selection, VOICE_SELECTION_MS); // set to 10 seconds
}

void lcdml_menu_control(void)
{
  // If something must init, put in in the setup condition
  if (LCDML.BT_setup())
  {
    pinMode(BUT_R_PIN, INPUT_PULLUP);
    pinMode(BUT_L_PIN, INPUT_PULLUP);
  }

  if (back_from_volume > BACK_FROM_VOLUME_MS && menu_state == MENU_VOLUME)
  {
    lcd_special_chars(SCROLLBAR);
    UI_func_voice_selection(0);
    return;
  }

  //Volatile Variable
  long g_LCDML_CONTROL_Encoder_position[NUM_ENCODER] = {ENCODER[ENC_R].read(), ENCODER[ENC_L].read()};
  bool button[NUM_ENCODER] = {digitalRead(BUT_R_PIN), digitalRead(BUT_L_PIN)};

  /************************************************************************************
    Basic encoder handlying (from LCDMenuLib2)
   ************************************************************************************/
  // RIGHT
  if (g_LCDML_CONTROL_Encoder_position[ENC_R] <= -3)
  {
    if (!button[ENC_R])
    {
      LCDML.BT_left();
      g_LCDML_CONTROL_button_prev[ENC_R] = LOW;
      g_LCDML_CONTROL_button_press_time[ENC_R] = -1;
    }
    else
    {
      encoder_right_up();
    }
    ENCODER[ENC_R].write(g_LCDML_CONTROL_Encoder_position[ENC_R] + 4);
  }
  else if (g_LCDML_CONTROL_Encoder_position[ENC_R] >= 3)
  {

    if (!button[ENC_R])
    {
      LCDML.BT_right();
      g_LCDML_CONTROL_button_prev[ENC_R] = LOW;
      g_LCDML_CONTROL_button_press_time[ENC_R] = -1;
    }
    else
    {
      encoder_right_down();
    }
    ENCODER[ENC_R].write(g_LCDML_CONTROL_Encoder_position[ENC_R] - 4);
  }
  else
  {
    if (!button[ENC_R] && g_LCDML_CONTROL_button_prev[ENC_R]) //falling edge, button[ENC_R] pressed
    {
      g_LCDML_CONTROL_button_prev[ENC_R] = LOW;
      g_LCDML_CONTROL_button_press_time[ENC_R] = millis();
    }
    else if (button[ENC_R] && !g_LCDML_CONTROL_button_prev[ENC_R]) //rising edge, button[ENC_R] not active
    {
      g_LCDML_CONTROL_button_prev[ENC_R] = HIGH;

      if (g_LCDML_CONTROL_button_press_time[ENC_R] < 0)
      {
        g_LCDML_CONTROL_button_press_time[ENC_R] = millis();
        //Reset for left right action
      }
      else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_R]) >= g_LCDML_CONTROL_button_long_press)
      {
        encoder_right_button_long();
      }
      else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_R]) >= g_LCDML_CONTROL_button_short_press)
      {
        encoder_right_button_short();
      }
    }
  }
  // LEFT
  if (g_LCDML_CONTROL_Encoder_position[ENC_L] <= -3)
  {
    if (!button[ENC_L])
    {
      //LCDML.BT_left();
      g_LCDML_CONTROL_button_prev[ENC_L] = LOW;
      g_LCDML_CONTROL_button_press_time[ENC_L] = -1;
    }
    else
    {
      encoder_left_up();
    }
    ENCODER[ENC_L].write(g_LCDML_CONTROL_Encoder_position[ENC_L] + 4);
  }
  else if (g_LCDML_CONTROL_Encoder_position[ENC_L] >= 3)
  {

    if (!button[ENC_L])
    {
      //LCDML.BT_right();
      g_LCDML_CONTROL_button_prev[ENC_L] = LOW;
      g_LCDML_CONTROL_button_press_time[ENC_L] = -1;
    }
    else
    {
      encoder_left_down();
    }
    ENCODER[ENC_L].write(g_LCDML_CONTROL_Encoder_position[ENC_L] - 4);
  }
  else
  {
    if (!button[ENC_L] && g_LCDML_CONTROL_button_prev[ENC_L]) //falling edge, button[ENC_L] pressed
    {
      g_LCDML_CONTROL_button_prev[ENC_L] = LOW;
      g_LCDML_CONTROL_button_press_time[ENC_L] = millis();
    }
    else if (button[ENC_L] && !g_LCDML_CONTROL_button_prev[ENC_L]) //rising edge, button[ENC_L] not active
    {
      g_LCDML_CONTROL_button_prev[ENC_L] = HIGH;

      if (g_LCDML_CONTROL_button_press_time[ENC_L] < 0)
      {
        g_LCDML_CONTROL_button_press_time[ENC_L] = millis();
        //Reset for left right action
      }
      else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_L]) >= g_LCDML_CONTROL_button_long_press)
      {
        //LCDML.BT_quit();
        encoder_left_button_long();
      }
      else if ((millis() - g_LCDML_CONTROL_button_press_time[ENC_L]) >= g_LCDML_CONTROL_button_short_press)
      {
        //LCDML.BT_enter();
        encoder_left_button_short();
      }
    }
  }
}

/************************************************************************************
  RIGHT Encoder functions
 ************************************************************************************/
void encoder_right_up(void)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2 && LCDML.FUNC_getID() != 255)
    instance_id = 1;

  switch (menu_state)
  {
    case MENU_EDIT:
    case MENU_VOLUME:
      menu_state = MENU_EDIT;
      LCDML.BT_down();
      break;
    case MENU_VOICE:
#ifdef DEBUG
      Serial.println(F("State: MENU_VOICE, Encoder left up"));
#endif
      switch (menu_voice)
      {
        case MENU_VOICE_BANK:
          if (configuration.dexed[instance_id].bank < MAX_BANKS - 1)
          {
            configuration.dexed[instance_id].bank++;
#ifdef DISPLAY_LCD_SPI
            change_disp_sd(false);
#endif
            load_sysex(configuration.dexed[instance_id].bank, configuration.dexed[instance_id].voice, instance_id);
            get_voice_names_from_bank(configuration.dexed[instance_id].bank, instance_id);
#ifdef DISPLAY_LCD_SPI
            change_disp_sd(true);
#endif
            eeprom_write();
          }
          break;
        case MENU_VOICE_SOUND:
          if (configuration.dexed[instance_id].voice < MAX_VOICES - 1)
            configuration.dexed[instance_id].voice++;
          else
          {
            if (configuration.dexed[instance_id].bank < MAX_BANKS - 1)
            {
              configuration.dexed[instance_id].bank++;
              configuration.dexed[instance_id].voice = 0;
            }
          }
#ifdef DISPLAY_LCD_SPI
          change_disp_sd(false);
#endif
          load_sysex(configuration.dexed[instance_id].bank, configuration.dexed[instance_id].voice, instance_id);
          get_voice_names_from_bank(configuration.dexed[instance_id].bank, instance_id);
#ifdef DISPLAY_LCD_SPI
          change_disp_sd(true);
#endif
          eeprom_write();
      }
      UI_func_voice_selection(0);
      break;
  }
}

void encoder_right_down(void)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2 && LCDML.FUNC_getID() != 255)
    instance_id = 1;

  switch (menu_state)
  {
    case MENU_EDIT:
    case MENU_VOLUME:
      menu_state = MENU_EDIT;
      LCDML.BT_up();
      break;
    case MENU_VOICE:
#ifdef DEBUG
      Serial.println(F("State: MENU_VOICE, Encoder left down"));
#endif
      switch (menu_voice)
      {
        case MENU_VOICE_BANK:
          if (configuration.dexed[instance_id].bank > 0)
          {
            configuration.dexed[instance_id].bank--;
#ifdef DISPLAY_LCD_SPI
            change_disp_sd(false);
#endif

            load_sysex(configuration.dexed[instance_id].bank, configuration.dexed[instance_id].voice, instance_id);
            get_voice_names_from_bank(configuration.dexed[instance_id].bank, instance_id);
#ifdef DISPLAY_LCD_SPI
            change_disp_sd(true);
#endif
            eeprom_write();
          }
          break;
        case MENU_VOICE_SOUND:
          if (configuration.dexed[instance_id].voice > 0)
            configuration.dexed[instance_id].voice--;
          else
          {
            if (configuration.dexed[instance_id].bank > 0)
            {
              configuration.dexed[instance_id].bank--;
              configuration.dexed[instance_id].voice = 31;
            }
          }
#ifdef DISPLAY_LCD_SPI
          change_disp_sd(false);
#endif
          load_sysex(configuration.dexed[instance_id].bank, configuration.dexed[instance_id].voice, instance_id);
          get_voice_names_from_bank(configuration.dexed[instance_id].bank, instance_id);
#ifdef DISPLAY_LCD_SPI
          change_disp_sd(true);
#endif
          eeprom_write();
      }
      UI_func_voice_selection(0);
      break;
  }
}

void encoder_right_button_long(void)
{
#ifdef DEBUG
  Serial.println(F("Encoder right long press"));
#endif
  LCDML.BT_quit();
}

void encoder_right_button_short(void)
{
#ifdef DEBUG
  Serial.println(F("Encoder right short press"));
#endif
  if (menu_state == MENU_EDIT)
  {
    LCDML.BT_enter();
  }
  else if (menu_state == MENU_VOICE)
  {
#ifdef DEBUG
    Serial.println(F("State: MENU_VOICE, button short press"));
#endif
    if (menu_voice == MENU_VOICE_BANK)
      menu_voice = MENU_VOICE_SOUND;
    else
      menu_voice = MENU_VOICE_BANK;
    UI_func_voice_selection(0);
  }
}

/************************************************************************************
  LEFT Encoder functions
 ************************************************************************************/
void encoder_left_up(void)
{
#ifdef DEBUG
  Serial.println(F("Volume +"));
#endif
  configuration.vol = constrain(configuration.vol + VOLUME_ENC_STEPS, VOLUME_MIN, VOLUME_MAX);
  //eeprom_write();
  //set_volume(configuration.vol, configuration.mono);

  UI_func_volume(0);
}

void encoder_left_down(void)
{
#ifdef DEBUG
  Serial.println(F("Volume -"));
#endif
  configuration.vol = constrain(configuration.vol - VOLUME_ENC_STEPS, VOLUME_MIN, VOLUME_MAX);
  //eeprom_write();
  //set_volume(configuration.vol, configuration.mono);

  UI_func_volume(0);
}

void encoder_left_button_long(void)
{
#ifdef DEBUG
  Serial.println(F("Encoder left long press"));
#endif
  if (menu_state == MENU_EDIT)
  {
    menu_state = MENU_VOICE;
    UI_func_voice_selection(0);
  }
  else if (menu_state == MENU_VOICE)
  {
    menu_state = MENU_EDIT;
    LCDML.MENU_goRoot();
  }
}

void encoder_left_button_short(void)
{
#ifdef DEBUG
  Serial.println(F("Encoder left short press"));
#endif
  if (menu_state == MENU_EDIT)
  {
    //LCDML.FUNC_goBackToMenu();
    LCDML.BT_quit();
  }
  else if (menu_state == MENU_VOICE)
  {
    menu_state = MENU_EDIT;
    LCDML.MENU_goRoot();
  }
}

/***********************************************************************
   DISPLAY
 ***********************************************************************/
void lcdml_menu_clear(void)
{
  lcd.clear();
  lcd.setCursor(0, 0);
}

void lcdml_menu_display(void)
{
  // update content
  // ***************
  if (LCDML.DISP_checkMenuUpdate()) {
    // clear menu
    // ***************
    LCDML.DISP_clear();

    // declaration of some variables
    // ***************
    // content variable
    char content_text[_LCDML_DISP_cols];  // save the content text of every menu element
    // menu element object
    LCDMenuLib2_menu *tmp;
    // some limit values
    uint8_t i = LCDML.MENU_getScroll();
    uint8_t maxi = _LCDML_DISP_rows + i;
    uint8_t n = 0;

    // check if this element has children
    if ((tmp = LCDML.MENU_getDisplayedObj()) != NULL)
    {
      // loop to display lines
      do
      {
        // check if a menu element has a condition and if the condition be true
        if (tmp->checkCondition())
        {
          // check the type off a menu element
          if (tmp->checkType_menu() == true)
          {
            // display normal content
            LCDML_getContent(content_text, tmp->getID());
            lcd.setCursor(1, n);
            lcd.print(content_text);
          }
          else
          {
            if (tmp->checkType_dynParam()) {
              tmp->callback(n);
            }
          }
          // increment some values
          i++;
          n++;
        }
        // try to go to the next sibling and check the number of displayed rows
      } while (((tmp = tmp->getSibling(1)) != NULL) && (i < maxi));
    }
  }

  if (LCDML.DISP_checkMenuCursorUpdate())
  {
    // init vars
    uint8_t n_max             = (LCDML.MENU_getChilds() >= _LCDML_DISP_rows) ? _LCDML_DISP_rows : (LCDML.MENU_getChilds());
    uint8_t scrollbar_min     = 0;
    uint8_t scrollbar_max     = LCDML.MENU_getChilds();
    uint8_t scrollbar_cur_pos = LCDML.MENU_getCursorPosAbs();
    uint8_t scroll_pos        = ((1.*n_max * _LCDML_DISP_rows) / (scrollbar_max - 1) * scrollbar_cur_pos);

    // display rows
    for (uint8_t n = 0; n < n_max; n++)
    {
      //set cursor
      lcd.setCursor(0, n);

      //set cursor char
      if (n == LCDML.MENU_getCursorPos()) {
        lcd.write(_LCDML_DISP_cfg_cursor);
      } else {
        lcd.write(' ');
      }

      // delete or reset scrollbar
      if (_LCDML_DISP_cfg_scrollbar == 1) {
        if (scrollbar_max > n_max) {
#ifdef I2C_DISPLAY
          lcd.setCursor((_LCDML_DISP_cols - 1), n);
          lcd.write((uint8_t)0);
#else
          lcd.drawTile((_LCDML_DISP_cols - 1), n, 1, flipped_scroll_bar[0]);
          lcd.setCursor((_LCDML_DISP_cols), n + 1);
#endif
        }
        else {
          lcd.setCursor((_LCDML_DISP_cols - 1), n);
          lcd.print(F(" "));
        }
      }
    }

    // display scrollbar
    if (_LCDML_DISP_cfg_scrollbar == 1) {
      if (scrollbar_max > n_max) {
        //set scroll position
        if (scrollbar_cur_pos == scrollbar_min) {
          // min pos
#ifdef I2C_DISPLAY
          lcd.setCursor((_LCDML_DISP_cols - 1), 0);
          lcd.write((uint8_t)1);
#else
          lcd.drawTile((_LCDML_DISP_cols - 1), 0, 1, flipped_scroll_bar[1]);
          lcd.setCursor((_LCDML_DISP_cols), 1);
#endif
        } else if (scrollbar_cur_pos == (scrollbar_max - 1)) {
          // max pos
#ifdef I2C_DISPLAY
          lcd.setCursor((_LCDML_DISP_cols - 1), (n_max - 1));
          lcd.write((uint8_t)4);
#else
          lcd.drawTile((_LCDML_DISP_cols - 1), (n_max - 1), 1, flipped_scroll_bar[4]);
          lcd.setCursor((_LCDML_DISP_cols), (n_max));
#endif
        } else {
          // between
#ifdef I2C_DISPLAY
          lcd.setCursor((_LCDML_DISP_cols - 1), scroll_pos / n_max);
          lcd.write((uint8_t)(scroll_pos % n_max) + 1);
#else
          lcd.drawTile((_LCDML_DISP_cols - 1), scroll_pos / n_max, 1, flipped_scroll_bar[(scroll_pos % n_max) + 1]);
          lcd.setCursor((_LCDML_DISP_cols), (scroll_pos / n_max) + 1);
#endif
        }
      }
    }
  }
}

//####################################################################################################################################################################################################

/***********************************************************************
   MENU
 ***********************************************************************/

#ifdef USE_FX
void UI_func_reverb_roomsize(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Reverb Roomsize"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_reverb_roomsize()"));
    Serial.print(F("configuration.roomsize="));
    Serial.println(configuration.reverb_roomsize, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.reverb_roomsize < REVERB_ROOMSIZE_MAX)
        {
          configuration.reverb_roomsize++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.reverb_roomsize > REVERB_ROOMSIZE_MIN)
        {
          configuration.reverb_roomsize--;
        }
      }

      freeverb_r.roomsize(mapfloat(configuration.reverb_roomsize, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 0.0, 1.0));
      freeverb_l.roomsize(mapfloat(configuration.reverb_roomsize, REVERB_ROOMSIZE_MIN, REVERB_ROOMSIZE_MAX, 0.0, 1.0));
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.reverb_roomsize, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_reverb_roomsize()"));
    Serial.print(F("reverb_roomsize="));
    Serial.println(configuration.reverb_roomsize, DEC);
#endif
    eeprom_write();
  }
}

void UI_func_reverb_damping(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Reverb Damping"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_reverb_damping()"));
    Serial.print(F("reverb_damping="));
    Serial.println(configuration.reverb_damping, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.reverb_damping < REVERB_DAMPING_MAX)
        {
          configuration.reverb_damping++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.reverb_damping > REVERB_DAMPING_MIN)
        {
          configuration.reverb_damping--;
        }
      }

      freeverb_r.damping(mapfloat(configuration.reverb_damping, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 0.0, 1.0));
      freeverb_l.damping(mapfloat(configuration.reverb_damping, REVERB_DAMPING_MIN, REVERB_DAMPING_MAX, 0.0, 1.0));
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.reverb_damping, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_reverb_damping()"));
    Serial.print(F("configuration.reverb_damping="));
    Serial.println(configuration.reverb_damping, DEC);
#endif
    eeprom_write();
  }
}

void UI_func_reverb_send(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Reverb Send"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_reverb_send()"));
    Serial.print(F("configuration.dexed["));
    Serial.print(instance_id, DEC);
    Serial.print(F("].reverb_send="));
    Serial.println(configuration.dexed[instance_id].reverb_send, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].reverb_send < REVERB_SEND_MAX)
        {
          configuration.dexed[instance_id].reverb_send++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].reverb_send > REVERB_SEND_MIN)
        {
          configuration.dexed[instance_id].reverb_send--;

        }
      }

      reverb_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].reverb_send / 100.0);
      reverb_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].reverb_send / 100.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].reverb_send, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_reverb_send()"));
    Serial.print(F("configuration.dexed["));
    Serial.print(instance_id, DEC);
    Serial.print(F("].reverb_send="));
    Serial.println(configuration.dexed[instance_id].reverb_send, DEC);
#endif
    eeprom_write();
  }
}

void UI_func_reverb_level(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Reverb Level"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_reverb_level()"));
    Serial.print(F("reverb_level="));
    Serial.println(configuration.reverb_level, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.reverb_level < REVERB_LEVEL_MAX)
        {
          configuration.reverb_level++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.reverb_level > REVERB_LEVEL_MIN)
        {
          configuration.reverb_level--;
        }
      }

      master_mixer_r.gain(REVERB, mapfloat(configuration.reverb_level, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 0.0, 1.0));
      master_mixer_l.gain(REVERB, mapfloat(configuration.reverb_level, REVERB_LEVEL_MIN, REVERB_LEVEL_MAX, 0.0, 1.0));
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.reverb_level, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_reverb_level()"));
    Serial.print(F("configuration.reverb_levelg="));
    Serial.println(configuration.reverb_level, DEC);
#endif
    eeprom_write();
  }
}

void UI_func_chorus_frequency(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Chorus Frequency"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_chorus_frequency()"));
    Serial.print(F("configuration.chorus_frequency="));
    Serial.println(configuration.chorus_frequency, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.chorus_frequency < CHORUS_FREQUENCY_MAX)
        {
          configuration.chorus_frequency++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.chorus_frequency > CHORUS_FREQUENCY_MIN)
        {
          configuration.chorus_frequency--;
        }
      }

      chorus_modulator.frequency(configuration.chorus_frequency / 10.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_float(configuration.chorus_frequency / 10.0, 2, 1, false, true, false);
    lcd.print(F(" Hz"));
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_chorus_frequency()"));
    Serial.print(F("configuration.chorus_frequency="));
    Serial.println(configuration.chorus_frequency, DEC);
#endif
    eeprom_write();
  }
}

void UI_func_chorus_waveform(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Chorus Waveform"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown())
    {
      if (configuration.chorus_waveform < CHORUS_WAVEFORM_MAX)
      {
        configuration.chorus_waveform++;
      }
    }
    else if (LCDML.BT_checkUp())
    {
      if (configuration.chorus_waveform > CHORUS_WAVEFORM_MIN)
      {
        configuration.chorus_waveform--;
      }
    }

    lcd.setCursor(0, 1);
    switch (configuration.chorus_waveform)
    {
      case 0:
        chorus_modulator.begin(WAVEFORM_TRIANGLE);
        lcd.print(F("[TRIANGLE]"));
        break;
      case 1:
        chorus_modulator.begin(WAVEFORM_SINE);
        lcd.print(F("[SINE    ]"));
        break;
      default:
        chorus_modulator.begin(WAVEFORM_TRIANGLE);
        lcd.print(F("[TRIANGLE]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_chorus_depth(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Chorus Depth"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.chorus_depth < CHORUS_DEPTH_MAX)
        {
          configuration.chorus_depth++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.chorus_depth > CHORUS_DEPTH_MIN)
        {
          configuration.chorus_depth--;
        }
      }

      chorus_modulator.amplitude(configuration.chorus_depth / 100.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.chorus_depth, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_chorus_send(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Chorus Send"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].chorus_send < CHORUS_SEND_MAX)
        {
          configuration.dexed[instance_id].chorus_send++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].chorus_send > CHORUS_SEND_MIN)
        {
          configuration.dexed[instance_id].chorus_send--;
        }
      }

      chorus_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].chorus_send / 100.0);
      chorus_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].chorus_send / 100.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].chorus_send, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_chorus_level(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Chorus Level"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_chorus_level()"));
    Serial.print(F("chorus_level="));
    Serial.println(configuration.chorus_level, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.chorus_level < CHORUS_LEVEL_MAX)
        {
          configuration.chorus_level++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.chorus_level > CHORUS_LEVEL_MIN)
        {
          configuration.chorus_level--;
        }
      }

      master_mixer_r.gain(CHORUS, mapfloat(configuration.chorus_level, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 0.0, 1.0));
      master_mixer_l.gain(CHORUS, mapfloat(configuration.chorus_level, CHORUS_LEVEL_MIN, CHORUS_LEVEL_MAX, 0.0, 1.0));
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.chorus_level, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_chorus_level()"));
    Serial.print(F("configuration.chorus_level="));
    Serial.println(configuration.chorus_level, DEC);
#endif
    eeprom_write();
  }
}

void UI_func_delay_time(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Delay Time"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.delay_time < DELAY_TIME_MAX / 10)
        {
          configuration.delay_time += 1;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.delay_time > DELAY_TIME_MIN)
        {
          configuration.delay_time -= 1;
        }
      }

      delay_r.delay(0, configuration.delay_time * 10);
      delay_l.delay(0, configuration.delay_time * 10);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.delay_time * 10, 3, true, true, false);
    lcd.print(F(" ms"));
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_delay_feedback(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Delay Feedback"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.delay_feedback < DELAY_FEEDBACK_MAX)
        {
          configuration.delay_feedback++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.delay_feedback > DELAY_FEEDBACK_MIN)
        {
          configuration.delay_feedback--;
        }
      }

      delay_fb_mixer_r.gain(1, configuration.delay_feedback / 100.0); // amount of feedback
      delay_fb_mixer_l.gain(1, configuration.delay_feedback / 100.0); // amount of feedback
      //delay_fb_mixer.gain(0, 1.0 - configuration.delay_feedback / 200.0); // original signal
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.delay_feedback, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_delay_send(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Delay Send"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].delay_send < DELAY_SEND_MAX)
        {
          configuration.dexed[instance_id].delay_send++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].delay_send > DELAY_SEND_MIN)
        {
          configuration.dexed[instance_id].delay_send--;
        }
      }

      delay_send_mixer_r.gain(instance_id, configuration.dexed[instance_id].delay_send / 100.0);
      delay_send_mixer_l.gain(instance_id, configuration.dexed[instance_id].delay_send / 100.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].delay_send, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_delay_level(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Delay Level"));
#ifdef DEBUG
    Serial.println(F("Entering UI_func_delay_level()"));
    Serial.print(F("delay_level="));
    Serial.println(configuration.delay_level, DEC);
#endif
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.delay_level < DELAY_LEVEL_MAX)
        {
          configuration.delay_level++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.delay_level > DELAY_LEVEL_MIN)
        {
          configuration.delay_level--;
        }
      }

      master_mixer_r.gain(DELAY, mapfloat(configuration.delay_level, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 0.0, 1.0));
      master_mixer_l.gain(DELAY, mapfloat(configuration.delay_level, DELAY_LEVEL_MIN, DELAY_LEVEL_MAX, 0.0, 1.0));
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.delay_level, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
#ifdef DEBUG
    Serial.println(F("Leaving UI_func_delay_level()"));
    Serial.print(F("configuration.delay_levelg="));
    Serial.println(configuration.delay_level, DEC);
#endif
    eeprom_write();
  }
}
#endif

void UI_func_filter_cutoff(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Filter Cut-Off"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].filter_cutoff < FILTER_CUTOFF_MAX)
        {
          configuration.dexed[instance_id].filter_cutoff++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].filter_cutoff > FILTER_CUTOFF_MIN)
        {
          configuration.dexed[instance_id].filter_cutoff--;
        }
      }

      MicroDexed[instance_id]->fx.Cutoff = mapfloat(configuration.dexed[instance_id].filter_cutoff, FILTER_CUTOFF_MIN, FILTER_CUTOFF_MAX, 1.0, 0.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].filter_cutoff, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_filter_resonance(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Filter Resonance"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].filter_resonance < FILTER_RESONANCE_MAX)
        {
          configuration.dexed[instance_id].filter_resonance++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].filter_resonance > FILTER_RESONANCE_MIN)
        {
          configuration.dexed[instance_id].filter_resonance--;
        }
      }

      MicroDexed[instance_id]->fx.Reso = mapfloat(configuration.dexed[instance_id].filter_resonance, FILTER_RESONANCE_MIN, FILTER_RESONANCE_MAX, 1.0, 0.0);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].filter_resonance, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_transpose(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Transpose"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].transpose < TRANSPOSE_MAX)
        {
          configuration.dexed[instance_id].transpose++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].transpose > TRANSPOSE_MIN)
        {
          configuration.dexed[instance_id].transpose--;
        }
      }

      MicroDexed[instance_id]->data[DEXED_VOICE_OFFSET + DEXED_TRANSPOSE] = configuration.dexed[instance_id].transpose;
      MicroDexed[instance_id]->notesOff();
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].transpose - 24, 1, false, true, true);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_tune(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Tune"));
    lcd.setCursor(6, 1);
    lcd.print(F("cent"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].tune < TUNE_MAX)
          configuration.dexed[instance_id].tune++;
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].tune > TUNE_MIN)
          configuration.dexed[instance_id].tune--;
      }

      MicroDexed[instance_id]->controllers.masterTune = (int((configuration.dexed[instance_id].tune - 100) / 100.0 * 0x4000) << 11) * (1.0 / 12);
      MicroDexed[instance_id]->doRefreshVoice();
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].tune - 100, 1, false, true, true);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_midi_channel(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("MIDI Channel"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown())
    {
      if (configuration.dexed[instance_id].midi_channel < MIDI_CHANNEL_MAX)
      {
        configuration.dexed[instance_id].midi_channel++;
      }
    }
    else if (LCDML.BT_checkUp())
    {
      if (configuration.dexed[instance_id].midi_channel > MIDI_CHANNEL_MIN)
      {
        configuration.dexed[instance_id].midi_channel--;
      }
    }
    lcd.setCursor(0, 1);

    if (configuration.dexed[instance_id].midi_channel == 0)
    {
      lcd.print(F("[OMNI]"));
    }
    else
    {
      lcd_display_int(configuration.dexed[instance_id].midi_channel, 4, false, true, false);
    }
  }


  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_sound_intensity(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Sound Intens."));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].sound_intensity < SOUND_INTENSITY_MAX)
        {
          configuration.dexed[instance_id].sound_intensity++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].sound_intensity > SOUND_INTENSITY_MIN)
        {
          configuration.dexed[instance_id].sound_intensity--;
        }
      }

      MicroDexed[instance_id]->fx.Gain = configuration.dexed[instance_id].sound_intensity / 100.0;
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].sound_intensity, 3, true, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_panorama(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Panorama"));
    if (configuration.mono > 0)
    {
      lcd.setCursor(0, 1);
      lcd.print(F("MONO-disabled"));
      return;
    }
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() && configuration.mono == 0)
    {
      if (configuration.dexed[instance_id].pan < PANORAMA_MAX)
      {
        configuration.dexed[instance_id].pan++;
      }
    }
    else if (LCDML.BT_checkUp() && configuration.mono == 0)
    {
      if (configuration.dexed[instance_id].pan > PANORAMA_MIN)
      {
        configuration.dexed[instance_id].pan--;
      }
    }

    if (configuration.mono == 0)
    {
      lcd.setCursor(0, 1);
      lcd_display_int(configuration.dexed[instance_id].pan - 20, 1, false, true, true);
      mono2stereo[instance_id]->panorama(mapfloat(configuration.dexed[instance_id].pan, PANORAMA_MIN, PANORAMA_MAX, -1.0, 1.0));
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_stereo_mono(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Stereo/Mono"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown())
    {
      if (configuration.mono < MONO_MAX)
      {
        configuration.mono++;
      }
    }
    else if (LCDML.BT_checkUp())
    {
      if (configuration.mono > MONO_MIN)
      {
        configuration.mono--;
      }
    }
    lcd.setCursor(0, 1);
    switch (configuration.mono)
    {
      case 0:
        lcd.print(F("[STEREO]"));
        stereo2mono.stereo(true);
        break;
      case 1:
        lcd.print(F("[MONO  ]"));
        stereo2mono.stereo(false);
        break;
      case 2:
        lcd.print(F("[MONO-R]"));
        stereo2mono.stereo(false);
        break;
      case 3:
        lcd.print(F("[MONO-L]"));
        stereo2mono.stereo(false);
        break;
    }
    set_volume(configuration.vol, configuration.mono);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_polyphony(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Polyphony"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].polyphony < POLYPHONY_MAX)
        {
          configuration.dexed[instance_id].polyphony++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].polyphony > POLYPHONY_MIN)
        {
          configuration.dexed[instance_id].polyphony--;
        }
      }

      MicroDexed[instance_id]->setMaxNotes(configuration.dexed[instance_id].polyphony);
    }

    lcd.setCursor(0, 1);
    lcd_display_int(configuration.dexed[instance_id].polyphony, 2, false, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_engine(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Engine"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].engine < ENGINE_MAX)
        {
          configuration.dexed[instance_id].engine++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].engine > ENGINE_MIN)
        {
          configuration.dexed[instance_id].engine--;
        }
      }

      MicroDexed[instance_id]->setEngineType(configuration.dexed[instance_id].engine);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].engine)
    {
      case 0:
        lcd.print(F("[MODERN]"));
        break;
      case 1:
        lcd.print(F("[MARK 1]"));
        break;
      case 2:
        lcd.print(F("[OPL   ]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_mono_poly(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Mono/Polyphonic"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].monopoly < MONOPOLY_MAX)
        {
          configuration.dexed[instance_id].monopoly++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].monopoly > MONOPOLY_MIN)
        {
          configuration.dexed[instance_id].monopoly--;
        }
      }

      MicroDexed[instance_id]->setMonoMode(!configuration.dexed[instance_id].monopoly);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].monopoly)
    {
      case 0:
        lcd.print(F("[MONOPHONIC]"));
        break;
      case 1:
        lcd.print(F("[POLYPHONIC]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_pb_range(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("PB Range", configuration.dexed[instance_id].pb_range, PB_RANGE_MIN, PB_RANGE_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].pb_range < PB_RANGE_MAX)
        {
          configuration.dexed[instance_id].pb_range++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].pb_range > PB_RANGE_MIN)
        {
          configuration.dexed[instance_id].pb_range--;
        }
      }

      MicroDexed[instance_id]->setPBController(configuration.dexed[instance_id].pb_range, configuration.dexed[instance_id].pb_step);
    }

    lcd_display_bar("PB Range", configuration.dexed[instance_id].pb_range, PB_RANGE_MIN, PB_RANGE_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_pb_step(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("PB Step", configuration.dexed[instance_id].pb_step, PB_STEP_MIN, PB_STEP_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].pb_step < PB_STEP_MAX)
        {
          configuration.dexed[instance_id].pb_step++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].pb_step > PB_STEP_MIN)
        {
          configuration.dexed[instance_id].pb_step--;
        }
      }

      MicroDexed[instance_id]->setPBController(configuration.dexed[instance_id].pb_range, configuration.dexed[instance_id].pb_step);
    }

    lcd_display_bar("PB Step", configuration.dexed[instance_id].pb_step, PB_STEP_MIN, PB_STEP_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_mw_range(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("MW Range", configuration.dexed[instance_id].mw_range, MW_RANGE_MIN, MW_RANGE_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].mw_range < MW_RANGE_MAX)
        {
          configuration.dexed[instance_id].mw_range++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].mw_range > MW_RANGE_MIN)
        {
          configuration.dexed[instance_id].mw_range--;
        }
      }

      MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign);
    }

    lcd_display_bar("MW Range", configuration.dexed[instance_id].mw_range, MW_RANGE_MIN, MW_RANGE_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_mw_assign(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("MW Assign"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].mw_assign < MW_ASSIGN_MAX)
        {
          configuration.dexed[instance_id].mw_assign++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].mw_assign > MW_ASSIGN_MIN)
        {
          configuration.dexed[instance_id].mw_assign--;
        }
      }

      MicroDexed[instance_id]->setMWController(configuration.dexed[instance_id].mw_range, configuration.dexed[instance_id].mw_assign);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].mw_assign)
    {
      case 0:
        lcd.print(F("[     NONE     ]"));
        break;
      case 1:
        lcd.print(F("[PTCH          ]"));
        break;
      case 2:
        lcd.print(F("[     AMP      ]"));
        break;
      case 3:
        lcd.print(F("[PTCH AMP      ]"));
        break;
      case 4:
        lcd.print(F("[         EG-BS]"));
        break;
      case 5:
        lcd.print(F("[PTCH     EG-BS]"));
        break;
      case 6:
        lcd.print(F("[     AMP EG-BS]"));
        break;
      case 7:
        lcd.print(F("[PTCH AMP EG-BS]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_fc_range(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("FC Range", configuration.dexed[instance_id].fc_range, FC_RANGE_MIN, FC_RANGE_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].fc_range < FC_RANGE_MAX)
        {
          configuration.dexed[instance_id].fc_range++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].fc_range > FC_RANGE_MIN)
        {
          configuration.dexed[instance_id].fc_range--;
        }
      }

      MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign);
    }

    lcd_display_bar("FC Range", configuration.dexed[instance_id].fc_range, FC_RANGE_MIN, FC_RANGE_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_fc_assign(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("FC Assign"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].fc_assign < FC_ASSIGN_MAX)
        {
          configuration.dexed[instance_id].fc_assign++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].fc_assign > FC_ASSIGN_MIN)
        {
          configuration.dexed[instance_id].fc_assign--;
        }
      }


      MicroDexed[instance_id]->setFCController(configuration.dexed[instance_id].fc_range, configuration.dexed[instance_id].fc_assign);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].fc_assign)
    {
      case 0:
        lcd.print(F("[     NONE     ]"));
        break;
      case 1:
        lcd.print(F("[PTCH          ]"));
        break;
      case 2:
        lcd.print(F("[     AMP      ]"));
        break;
      case 3:
        lcd.print(F("[PTCH AMP      ]"));
        break;
      case 4:
        lcd.print(F("[         EG-BS]"));
        break;
      case 5:
        lcd.print(F("[PTCH     EG-BS]"));
        break;
      case 6:
        lcd.print(F("[     AMP EG-BS]"));
        break;
      case 7:
        lcd.print(F("[PTCH AMP EG-BS]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_bc_range(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("BC Range", configuration.dexed[instance_id].bc_range, BC_RANGE_MIN, BC_RANGE_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].bc_range < BC_RANGE_MAX)
        {
          configuration.dexed[instance_id].bc_range++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].bc_range > BC_RANGE_MIN)
        {
          configuration.dexed[instance_id].bc_range--;
        }
      }

      MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign);
    }

    lcd_display_bar("BC Range", configuration.dexed[instance_id].bc_range, BC_RANGE_MIN, BC_RANGE_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_bc_assign(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("BC Assign"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].bc_assign < BC_ASSIGN_MAX)
        {
          configuration.dexed[instance_id].bc_assign++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].bc_assign > BC_ASSIGN_MIN)
        {
          configuration.dexed[instance_id].bc_assign--;
        }
      }

      MicroDexed[instance_id]->setBCController(configuration.dexed[instance_id].bc_range, configuration.dexed[instance_id].bc_assign);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].bc_assign)
    {
      case 0:
        lcd.print(F("[     NONE     ]"));
        break;
      case 1:
        lcd.print(F("[PTCH          ]"));
        break;
      case 2:
        lcd.print(F("[     AMP      ]"));
        break;
      case 3:
        lcd.print(F("[PTCH AMP      ]"));
        break;
      case 4:
        lcd.print(F("[         EG-BS]"));
        break;
      case 5:
        lcd.print(F("[PTCH     EG-BS]"));
        break;
      case 6:
        lcd.print(F("[     AMP EG-BS]"));
        break;
      case 7:
        lcd.print(F("[PTCH AMP EG-BS]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_at_range(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("AT Range", configuration.dexed[instance_id].at_range, AT_RANGE_MIN, AT_RANGE_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].at_range < AT_RANGE_MAX)
        {
          configuration.dexed[instance_id].at_range++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].at_range > AT_RANGE_MIN)
        {
          configuration.dexed[instance_id].at_range--;
        }
      }

      MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign);
    }

    lcd_display_bar("AT Range", configuration.dexed[instance_id].at_range, AT_RANGE_MIN, AT_RANGE_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_at_assign(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("AT Assign"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].at_assign < AT_ASSIGN_MAX)
        {
          configuration.dexed[instance_id].at_assign++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].at_assign > AT_ASSIGN_MIN)
        {
          configuration.dexed[instance_id].at_assign--;
        }
      }

      MicroDexed[instance_id]->setATController(configuration.dexed[instance_id].at_range, configuration.dexed[instance_id].at_assign);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].at_assign)
    {
      case 0:
        lcd.print(F("[     NONE     ]"));
        break;
      case 1:
        lcd.print(F("[PTCH          ]"));
        break;
      case 2:
        lcd.print(F("[     AMP      ]"));
        break;
      case 3:
        lcd.print(F("[PTCH AMP      ]"));
        break;
      case 4:
        lcd.print(F("[         EG-BS]"));
        break;
      case 5:
        lcd.print(F("[PTCH     EG-BS]"));
        break;
      case 6:
        lcd.print(F("[     AMP EG-BS]"));
        break;
      case 7:
        lcd.print(F("[PTCH AMP EG-BS]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_portamento_mode(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Portamento Mode"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].portamento_mode < PORTAMENTO_MODE_MAX)
        {
          configuration.dexed[instance_id].portamento_mode++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].portamento_mode > PORTAMENTO_MODE_MIN)
        {
          configuration.dexed[instance_id].portamento_mode--;
        }
      }

      MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].portamento_mode)
    {
      case 0:
        if (configuration.dexed[instance_id].monopoly == 1)
          lcd.print(F("[RETAIN  ]"));
        else
          lcd.print(F("[FINGERED]"));
        break;
      case 1:
        if (configuration.dexed[instance_id].monopoly == 1)
          lcd.print(F("[FOLLOW  ]"));
        else
          lcd.print(F("[FULL    ]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_portamento_glissando(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Portam. Gliss."));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].portamento_glissando < PORTAMENTO_GLISSANDO_MAX)
        {
          configuration.dexed[instance_id].portamento_glissando++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].portamento_glissando > PORTAMENTO_GLISSANDO_MIN)
        {
          configuration.dexed[instance_id].portamento_glissando--;
        }
      }

      MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
    }

    lcd.setCursor(0, 1);
    switch (configuration.dexed[instance_id].portamento_glissando)
    {
      case 0:
        lcd.print(F("[OFF           ]"));
        break;
      case 1:
        lcd.print(F("[ON            ]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_portamento_time(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("Portam. Time", configuration.dexed[instance_id].portamento_time, PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX, true);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.dexed[instance_id].portamento_time < PORTAMENTO_TIME_MAX)
        {
          configuration.dexed[instance_id].portamento_time++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.dexed[instance_id].portamento_time > PORTAMENTO_TIME_MIN)
        {
          configuration.dexed[instance_id].portamento_time--;
        }
      }

      MicroDexed[instance_id]->setPortamentoMode(configuration.dexed[instance_id].portamento_mode, configuration.dexed[instance_id].portamento_glissando, configuration.dexed[instance_id].portamento_time);
    }

    lcd_display_bar("Portam. Time", configuration.dexed[instance_id].portamento_time, PORTAMENTO_TIME_MIN, PORTAMENTO_TIME_MAX, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    lcd_special_chars(SCROLLBAR);
    eeprom_write();
  }
}

void UI_func_OP1(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  UI_handle_OP(param, 0, instance_id);
}

void UI_func_OP2(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  UI_handle_OP(param, 1, instance_id);
}

void UI_func_OP3(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  UI_handle_OP(param, 2, instance_id);
}

void UI_func_OP4(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  UI_handle_OP(param, 3, instance_id);
}

void UI_func_OP5(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  UI_handle_OP(param, 4, instance_id);
}

void UI_func_OP6(uint8_t param)
{
  uint8_t instance_id = 0;

  if (LCDML.FUNC_getID() > MENU_ID_OF_INSTANCE_2)
    instance_id = 1;

  UI_handle_OP(param, 5, instance_id);
}

void UI_handle_OP(uint8_t param, uint8_t op, uint8_t instance_id)
{
  bool state = bitRead(configuration.dexed[instance_id].op_enabled, op);

  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Operator "));
    lcd.print(op + 1);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkUp() && state == true)
      bitClear(configuration.dexed[instance_id].op_enabled, op);
    else if (LCDML.BT_checkDown() && state == false)
      bitSet(configuration.dexed[instance_id].op_enabled, op);
  }

  lcd.setCursor(0, 1);
  if (state == true)
  {
    lcd.print(F("[ENABLED ]"));
  }
  else
  {
    lcd.print(F("[DISABLED]"));
  }
  MicroDexed[instance_id]->setOPs(configuration.dexed[instance_id].op_enabled);
  MicroDexed[instance_id]->doRefreshVoice();

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_information(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("MicroDexed"));
    lcd.setCursor(0, 1);
    lcd.print(VERSION);
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    // loop function, can be run in a loop when LCDML_DISP_triggerMenu(xx) is set
    // the quit button works in every DISP function without any checks; it starts the loop_end function
    if (LCDML.BT_checkEnter()) { // check if any button is pressed (enter, up, down, left, right)
      // LCDML_goToMenu stops a running menu function and goes to the menu
      LCDML.FUNC_goBackToMenu();
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
  }
}

void UI_func_midi_soft_thru(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("MIDI Soft THRU"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (configuration.soft_midi_thru < SOFT_MIDI_THRU_MAX)
        {
          configuration.soft_midi_thru++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (configuration.soft_midi_thru > SOFT_MIDI_THRU_MIN)
        {
          configuration.soft_midi_thru--;
        }
      }
    }

    lcd.setCursor(0, 1);
    switch (configuration.soft_midi_thru)
    {
      case 0:
        lcd.print(F("[OFF]"));
        break;
      case 1:
        lcd.print(F("[ON ]"));
        break;
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_voice_selection(uint8_t param)
{
#ifdef DEBUG
  Serial.println(F("UI_func_voice_selection()"));
#endif

  menu_state = MENU_VOICE;

  strip_extension(bank_names[selected_dexed_instance][configuration.dexed[selected_dexed_instance].bank], bank_name[selected_dexed_instance]);

  //LCDML.DISP_clear();

  // display bank and voice number
  lcd.show(0, 0, 2, configuration.dexed[selected_dexed_instance].bank);
  lcd.show(1, 0, 2, configuration.dexed[selected_dexed_instance].voice + 1);

  // display names
  lcd.show(0, 4, 10, bank_name[selected_dexed_instance]);
  lcd.show(1, 4, 10, voice_names[selected_dexed_instance][configuration.dexed[selected_dexed_instance].voice]);

  // display selected Dexed instance
  /*  if (selected_dexed_instance == 1)
    {
    #if NUM_DEXED > 1
      lcd.show(0, 15, 1, "o");
    #else
      lcd.show(0, 15, 1, " ");
    #endif
      lcd.show(1, 15, 1, "*");
    }
    else
    {
      selected_dexed_instance = 0;
      lcd.show(0, 15, 1, "*");
    #if NUM_DEXED > 1
      lcd.show(1, 15, 1, "o");
    #else
      lcd.show(1, 15, 1, " ");
    #endif
    } */

  lcd.show(0, 15, 1, " ");
  lcd.show(1, 15, 1, " ");

  // display selections
  switch (menu_voice)
  {
    case MENU_VOICE_BANK:
      lcd.show(0, 2, 2, " [");
      lcd.show(0, 14, 1, "]");
      lcd.show(1, 2, 2, "  ");
      lcd.show(1, 14, 1, " ");
      break;
    case MENU_VOICE_SOUND:
      lcd.show(0, 2, 2, "  ");
      lcd.show(0, 14, 1, "  ");
      lcd.show(1, 2, 2, " [");
      lcd.show(1, 14, 1, "]");
      break;
  }
  for (int x = 2; x < LCD_rows; x++) {
    lcd.show(x, 0, LCD_cols, " ");
  }
}

void UI_func_volume(uint8_t param)
{
#ifdef DEBUG
  Serial.println(F("UI_func_volume()"));
#endif

  back_from_volume = 0;

  if (menu_state != MENU_VOLUME)
  {
    lcd_special_chars(BLOCKBAR);
    lcd_display_bar("Volume", configuration.vol, VOLUME_MIN, VOLUME_MAX, true);
    menu_state = MENU_VOLUME;
  }
  else
    lcd_display_bar("Volume", configuration.vol, VOLUME_MIN, VOLUME_MAX, false);

  set_volume(configuration.vol, configuration.mono);
  eeprom_write();

}

void UI_func_load(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Load setup"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (dexed_setup_number < 100)
        {
          dexed_setup_number++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (dexed_setup_number > 1)
        {
          dexed_setup_number--;
        }
      }

      //LOAD SYSEX FILE
    }

    lcd.setCursor(0, 1);
    lcd_display_int(dexed_setup_number, 2, false, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_func_save(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Save setup"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
    else if (LCDML.BT_checkDown() || LCDML.BT_checkUp())
    {
      if (LCDML.BT_checkDown())
      {
        if (dexed_setup_number < 100)
        {
          dexed_setup_number++;
        }
      }
      else if (LCDML.BT_checkUp())
      {
        if (dexed_setup_number > 1)
        {
          dexed_setup_number--;
        }
      }

      //SAVE SYSEX FILE
    }

    lcd.setCursor(0, 1);
    lcd_display_int(dexed_setup_number, 2, false, true, false);
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
    eeprom_write();
  }
}

void UI_function_not_enabled(void)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Function not"));
    lcd.setCursor(0, 1);
    lcd.print(F("enbaled!"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
  }
}

void UI_function_not_implemented(uint8_t param)
{
  if (LCDML.FUNC_setup())         // ****** SETUP *********
  {
    // setup function
    lcd.setCursor(0, 0);
    lcd.print(F("Function not"));
    lcd.setCursor(0, 1);
    lcd.print(F("implemented!"));
  }

  if (LCDML.FUNC_loop())          // ****** LOOP *********
  {
    if (LCDML.BT_checkEnter())
    {
      LCDML.FUNC_goBackToMenu();
    }
  }

  if (LCDML.FUNC_close())     // ****** STABLE END *********
  {
    // you can here reset some global vars or do nothing
  }
}

void lcd_display_int(int16_t var, uint8_t size, bool zeros, bool brackets, bool sign)
{
  int16_t tmp = 0;
  uint16_t p;
  bool non_zero_found = false;

  if (size < 1)
    return;

  if (brackets == true)
    lcd.print(F("["));

  if (sign == true)
  {
    size++;
    if (var < 0)
    {
      lcd.print(F("-"));
      var = abs(var);
    }
    else if (var > 0)
      lcd.print(F("+"));
    else
      lcd.print(F(" "));
  }

  if (var == 0 && zeros == false)
  {
    for (int8_t i = size - 1 ; i > 0; i--)
      lcd.print(F(" "));
    lcd.print(F("0"));
  }
  else
  {
    for (int8_t i = size - 1 ; i >= 0; i--)
    {
      p = int(pow(10, i));
      tmp = int(var / p);

      if (tmp == 0)
      {
        if (zeros == true)
          lcd.print(F("0"));
        else
        {
          if (non_zero_found == true)
            lcd.print(F("0"));
          else
            lcd.print(F(" "));
        }
      }
      else
      {
        non_zero_found = true;
        lcd.print(tmp);
      }
      var -= (tmp * p);
    }
  }

  if (brackets == true)
    lcd.print(F("]"));
}

void lcd_display_float(float var, uint8_t size_number, uint8_t size_fraction, bool zeros, bool brackets, bool sign)
{
  float fraction;
  float number;

  if (size_number < 1 || size_fraction < 1)
    return;

  fraction = modff(var, &number);

  if (brackets == true)
    lcd.print(F("["));

  if (int(number) == 0)
  {
    if (zeros == true)
      lcd.print(F("00"));
    else
      lcd.print(F(" 0"));
  }
  else
    lcd_display_int(int(number), size_number, zeros, false, sign);
  lcd.print(F("."));
  lcd_display_int(round(fraction * pow(10, size_fraction)), size_fraction, true, false, false);

  if (brackets == true)
    lcd.print(F("]"));
}

void lcd_display_bar(const char* title, uint32_t value, uint32_t min_value, uint32_t max_value, bool init)
{
  float _v = float(value * LCD_cols) / (max_value - min_value);
  float _vi;
  uint8_t vf = uint8_t(modff(_v, &_vi) * 10.0);
  uint8_t vi = uint8_t(_vi);

  if (init == true)
  {
    lcd.show(0, 0, LCD_cols, title);
    lcd.setCursor(strlen(title) + 1, 0);
    lcd_display_int(value, 3, true, false, false);
    lcd.setCursor(0, 1);

    if (vi == 0 && uint8_t(vf / 2) == 0)
    {
      lcd.setCursor(0, 1);
      lcd.write((uint8_t)0); // minimal block
    }
    else
    {
      for (uint8_t i = 0; i < LCD_cols; i++)
      {
        if (i < vi)
          lcd.write((uint8_t)4); // full block
        else
          lcd.print(F(" "));
      }

      if (vf > 1)
      {
        lcd.setCursor(vi - 1, 1);
        lcd.write((uint8_t)int(vf / 2) - 1);
      }
    }
  }
  else
  {
    uint8_t ca = (float((LCD_cols) / (max_value - min_value)) + 0.5) + 1;

    lcd.setCursor(strlen(title) + 1, 0);
    lcd_display_int(value, 3, true, false, false);

    if (vi == 0 && uint8_t(vf / 2) == 0)
    {
      lcd.setCursor(0, 1);
      lcd.write((uint8_t)0); // minimal block
      for (uint8_t n = 1; n <= ca; n++)
        lcd.print(F(" "));
    }
    else if (vi == LCD_cols && uint8_t(vf / 2) == 0)
    {
      lcd.setCursor(LCD_cols - ca - 1, 1);
      lcd.write((uint8_t)4); // full block
      for (uint8_t n = LCD_cols - ca; n < LCD_cols; n++)
        lcd.write((uint8_t)4); // full block
    }
    else
    {
      uint8_t b, e;

      if (vi - ca < 0)
        b = 0;
      else
        b = vi - ca;
      if (vi + ca >= LCD_cols)
        e = LCD_cols;
      else
        e = vi + ca;

      Serial.print("ca=");
      Serial.print(ca);
      Serial.print(" b=");
      Serial.print(b);
      Serial.print(" e=");
      Serial.print(e);
      Serial.println();

      lcd.setCursor(b - 1, 1);
      for (uint8_t n = b; n <= e; n++)
      {
        if (n < vi)
          lcd.write((uint8_t)4); // full block
        else if (n == vi && uint8_t(vf / 2) != 0)
          lcd.write((uint8_t)uint8_t(vf / 2) - 1);
        else
          lcd.print(F(" "));
      }
    }
  }
}

void lcd_special_chars(uint8_t mode)
{
  switch (mode)
  {
    case SCROLLBAR:
      // set special chars for scrollbar
      for (uint8_t i = 0; i < 5; i++)
      {
#ifdef I2C_DISPLAY
        lcd.createChar(i, (uint8_t*)scroll_bar[i]);
#else
        flipped_scroll_bar[i] = rotTile(scroll_bar[i]);
#endif
      }
      break;
    case BLOCKBAR:
      // set special chars for volumebar
      for (uint8_t i = 0; i < 5; i++)
      {
#ifdef I2C_DISPLAY
        lcd.createChar(i, (uint8_t*)block_bar[i]);
#else
        flipped_block_bar[i] = rotTile(block_bar[i]);
#endif
      }
      break;
  }
}
#endif
#endif