MainWindow.xaml.cs

using Kiroll.Surface;
using NITHlibrary.Tools.Logging;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using Kiroll.Modules;
using Timer = System.Windows.Forms.Timer;

namespace Kiroll
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        // Bool variables for checking activation and deactivation of buttons

        #region BoolVariables

        private bool btnBlinkOn = false;
        private bool btnBreathOn = false;
        private bool btnEyeOn = false;
        private bool btnKeyboardOn = false;
        private bool btnKeyNameOn = true;
        private bool btnSharpNotesOn = false;
        private bool btnSlidePlayOn = false;

        //If settings are opened the instrument will not play and keyboard opacity will be set to 0.6;
        private bool kirollSettingsOpened = false;

        private bool KirollStarted = false;
        private bool playMetronome = false;
        public bool KirollSettingsOpened { get => kirollSettingsOpened; }
        #endregion BoolVariables



        // Variables to control blinkKeyboard behave

        #region BlinkKeyboard_variables

        private StackPanel blinkKeyboard;
        private bool flag = false;
        private bool letBlink = false;
        public bool LetBlink { get => letBlink; set => letBlink = value; }

        #endregion BlinkKeyboard_variables

        // Sensors params and behaviors

        #region SensorParams&behaviors

        //Used to track doubleClose eyes behave
        private bool click = false;

        public bool Click
        {
            get => click;
            set
            {
                if (value != click)
                {
                    click = value;
                }
            }
        }

        public int SensorPort
        {
            get { return Rack.UserSettings.SensorPort; }
            set
            {
                if (value > 0)
                {
                    Rack.UserSettings.SensorPort = value;
                }
            }
        }

        #endregion SensorParams&behaviors

        // Dictionaries used to select Scale, Octave and Code

        #region Scale-Octave-Code

        private int codeIndex = 0;

        private Dictionary<int, string> comboCode = new()
        {
            { 0, "maj" }, { 1, "min" }, { 2, "min_arm" }, { 3, "min_mel" }
        };

        private Dictionary<int, string> comboOctave = new()
        {
            { 0, "2" }, { 1, "3" }, { 2, "4" }, { 3, "5" }, { 4, "6" }
        };

        private Dictionary<int, string> comboScale = new()
        {
            { 0, "C" }, { 1, "C#" }, { 2, "D" }, { 3, "D#" }, { 4, "E" }, { 5, "F" }, { 6, "F#" }, { 7, "G" }, { 8, "G#" }, { 9, "A" }, { 10, "A#" }, { 11, "B"}
        };

        private int octaveIndex = 2;
        private int oldCodeIndex = 0;
        private int oldOctaveIndex = 2;
        private int oldScaleIndex = 0;
        private int scaleIndex = 0;
        public int CodeIndex { get => codeIndex; set => codeIndex = value; }
        public Dictionary<int, string> ComboCode { get => comboCode; }
        public Dictionary<int, string> ComboOctave { get => comboOctave; }
        public Dictionary<int, string> ComboScale { get => comboScale; }
        public int OctaveIndex { get => octaveIndex; set => octaveIndex = value; }
        public int ScaleIndex { get => scaleIndex; set => scaleIndex = value; }

        #endregion Scale-Octave-Code

        // Dictionaries to manage Blink and Blow Behaviors

        #region BlinkAndBlowBehaviors

        private Dictionary<int, string> blinkBehaviors = new()
        {
            { 0, "Key" }, { 1, "Octave" }, { 2, "Scale" }
        };

        //Blink Behaviors
        private int blinkIndex = 0;

        private Dictionary<int, string> blowBehaviors = new()
        {
            { 0, "Dynamic" }, { 1, "Static" }
        };

        //Blow Behaviors
        private int blowIndex = 0;

        #endregion BlinkAndBlowBehaviors

        //Colors and backgrounds are used to highlight activation or deactivation of features clicking on the relevant buttons

        #region ColorsAndBackgrounds

        private readonly SolidColorBrush ActiveBrush = new(Colors.LightYellow);
        private readonly SolidColorBrush DisableBrush = new(Colors.Transparent);

        // SelectionBrush is used just when eyetracker control is ON, because the mouse could not be seen anymore.
        private readonly SolidColorBrush SelectionBrush = new(Colors.Yellow);

        private readonly SolidColorBrush WarningBrush = new(Colors.DarkRed);
        private readonly SolidColorBrush IdleButtonBrush = new(Color.FromArgb(0xFF, 0x00, 0x86, 0x89));

        //Icons and Backgrounds TODO these are dead since new codebase
        //BitmapImage startIcon = new BitmapImage(
        //            new Uri(Environment.CurrentDirectory + @"Images\Icons\Start.png"));

        //BitmapImage pauseIcon = new BitmapImage(
        //            new Uri(Environment.CurrentDirectory + @"Images\Icons\Pause.png"));

        //BitmapImage settingsIcon = new BitmapImage(
        //            new Uri(Environment.CurrentDirectory + @"Images\Icons\Settings.png"));

        //BitmapImage closeSettingsIcon = new BitmapImage(
        //            new Uri(Environment.CurrentDirectory + @"Images\Icons\CloseSettings_1.png"));

        //ImageBrush IdleButtonBrush = new ImageBrush(new BitmapImage(
        //            new Uri(Environment.CurrentDirectory + @"Images\Backgrounds\Buttons.jpeg")));

        #endregion ColorsAndBackgrounds

        private readonly MediaPlayer _metronomeMediaPlayer = new();

        private Timer metronomeTimer;

        private dynamic oldBackGround;

        // Timers
        private Timer updater;

        public MainWindow()
        {
            InitializeComponent();

            TraceAdder.AddTrace(); // Used to log errors

            metronomeTimer = new Timer();
            updater = new Timer();
            // " (1000 * 60) / (Rack.UserSettings.BPMmetronome" is used to convert BPM into ms (milliseconds).
            metronomeTimer.Interval = Convert.ToInt32(1000 * 60 / (Rack.UserSettings.BPMmetronome));
            updater.Interval = 10;

            metronomeTimer.Tick += Metronome;
            updater.Tick += Update;

            metronomeTimer.Start();
        }

        #region Timers Behaviors

        private void Metronome(object sender, EventArgs e)
        {
            if (playMetronome)
            {
                string audioFilePath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Audio", "_metronomeMediaPlayer.wav");
                _metronomeMediaPlayer.Open(new Uri(audioFilePath));
                _metronomeMediaPlayer.Play();
                _metronomeMediaPlayer.Play();
            }
            else
            {
                _metronomeMediaPlayer.Stop();
                _metronomeMediaPlayer.Close();
            }
        }

        private void Update(object sender, EventArgs e)
        {
            //Graphic changes on Note Visualizer

            #region NoteVisualizer_graphicChanges

            txtPitch.Text = Rack.UserSettings.NotePitch;
            txtNoteName.Text = Rack.UserSettings.NoteName;

            if (Rack.UserSettings.KirollControlMode == _KirollControlModes.Keyboard)
            {
                txtVelocityMouth.Text = Rack.UserSettings.NoteVelocity;
            }
            else
            {
                if (txtPitch.Text != "_")
                {
                    txtVelocityMouth.Text = Rack.UserSettings.NotePressure; // Intensity of user blow
                }
                else
                {
                    // If the user is not blowing "_" will be showned
                    txtVelocityMouth.Text = "_";
                }
            }

            #endregion NoteVisualizer_graphicChanges

            // When Scale, Code or Octave will change 'DrawOnCanvas' will be called.
            // This is necessary cause is not possible to access canvas when using blink behaviors.
            // Canvas is in fact managed by a different thread that avoid the access to.

            #region ComboScale-Octave-Code

            // oldScaleIndex, oldOctaveIndex and oldCodeIndex are used to track when scaleIndex change
            if (oldScaleIndex != scaleIndex)
            {
                oldScaleIndex = scaleIndex;
                txtScale.Text = comboScale[scaleIndex];
                Rack.UserSettings.ScaleName = txtScale.Text;
                Rack.KirollSurface.DrawOnCanvas();
            }

            if (oldOctaveIndex != octaveIndex)
            {
                oldOctaveIndex = octaveIndex;
                txtOctave.Text = comboOctave[octaveIndex];
                Rack.UserSettings.Octave = txtOctave.Text;
                Rack.KirollSurface.DrawOnCanvas();
            }

            if (oldCodeIndex != codeIndex)
            {
                oldCodeIndex = codeIndex;
                txtCode.Text = comboCode[codeIndex];
                Rack.UserSettings.ScaleCode = txtCode.Text;
                Rack.KirollSurface.DrawOnCanvas();
            }

            #endregion ComboScale-Octave-Code

            // Behaviors when EyeCtrl is On

            #region EyeCtrlON

            if (Rack.UserSettings.EyeCtrl == _EyeCtrl.On)
            {
                if (Rack.MappingModule.LastGazedButton != null)
                {
                    // If doubleClose eyes behave (TBactivateButton) or blow behave (TBactivateButton)
                    // happens click became True so a button will be clicked, the last gazed

                    if (Click)
                    {
                        Rack.MappingModule.LastGazedButton.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));

                        //Background changes of gazed buttons
                        if (Rack.MappingModule.LastGazedButton.Background == SelectionBrush)
                        {
                            oldBackGround = IdleButtonBrush;
                        }
                        else
                        {
                            oldBackGround = Rack.MappingModule.LastGazedButton.Background;
                        }

                        Click = false;
                    }
                }

                // BlinkBehaviors will work when EyeCtrl is ON
                if (btnBlinkOn)
                {
                    txtBlink.Foreground = new SolidColorBrush(Colors.White); ;
                }
                else
                {
                    txtBlink.Foreground = WarningBrush;
                }
            }
            else
            {
                btnCtrlEye.Background = IdleButtonBrush;
                txtBlink.Foreground = WarningBrush;
            }

            #endregion EyeCtrlON

            // When user plays a wrong keyboard, the right one will blink

            #region BlinkKeyboard_behave

            string lastKeyboardPlayed = Rack.KirollSurface.LastKeyboardPlayed;

            // Selecting the keyboard that has to blink
            if (lastKeyboardPlayed == "")
            {
                blinkKeyboard = KirollKeyboard.GetKeyboard("_0");
            }
            else
            {
                blinkKeyboard = KirollKeyboard.GetKeyboard("_" + ((Convert.ToInt32(lastKeyboardPlayed) + 1) % 16).ToString());
            }

            // If the user is on the right keyboard, that one should stop blinking, so Opacity will be restored
            if (letBlink)
            {
                if (blinkKeyboard.Opacity > 0.5 && !flag)
                {
                    blinkKeyboard.Opacity -= 0.02;
                }
                else if (blinkKeyboard.Opacity <= 0.5 && !flag)
                {
                    flag = true;
                }
                else if (flag && blinkKeyboard.Opacity < 1)
                {
                    blinkKeyboard.Opacity += 0.02;
                }
                else if (flag && blinkKeyboard.Opacity >= 1)
                {
                    flag = false;
                }
            }
            else
            {
                blinkKeyboard.Opacity = 1;
            }

            #endregion BlinkKeyboard_behave
        }

        #endregion Timers Behaviors

        // Each setting button (Start & Stop excluded) has this behave, if gazed, the button will be selected waiting to be clicked

        // used to select correct button background when it is gazed, selected or unselected
        public dynamic OldBackGround { get => oldBackGround; set => oldBackGround = value; }

        private void eyeGazeHandler(object sender, MouseEventArgs e)
        {
            if (Rack.UserSettings.EyeCtrl == _EyeCtrl.On)
            {
                // Giving to the last gazed button the old background that he had before being gazed
                if (Rack.MappingModule.LastGazedButton != null)
                {
                    Rack.MappingModule.LastGazedButton.Background = oldBackGround;
                }

                Rack.MappingModule.LastGazedButton = (Button)sender;

                // Memorizing the background of gazed button before changing it
                oldBackGround = Rack.MappingModule.LastGazedButton.Background;

                Rack.MappingModule.LastGazedButton.Background = SelectionBrush;

                // This avoid playing a key while clicking on button
                if (Rack.MappingModule.SelectedNote != NITHdmis.Music.MidiNotes.NaN)
                {
                    Rack.MappingModule.CheckedNote = null; //checkedNote != null is a condition to play a key
                }
            }
        }

        #region TopBar (Row0)

        #region Start, Exit and Setting buttons

        private KirollSetup kirollSetup;

        private void btnCtrlEye_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnEyeOn)
                {
                    btnEyeOn = true;
                    Rack.UserSettings.EyeCtrl = _EyeCtrl.On;
                    Rack.BehaviorGazeToMouse.Enabled = true;
                    Cursor = Cursors.None;

                    btnCtrlEye.Background = ActiveBrush;
                }
                else
                {
                    btnEyeOn = false;
                    Rack.UserSettings.EyeCtrl = _EyeCtrl.Off;
                    Rack.BehaviorGazeToMouse.Enabled = false;
                    Cursor = Cursors.Arrow;

                    btnCtrlEye.Background = DisableBrush;
                }
            }
        }

        private void btnCtrlKeyName_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnKeyNameOn)
                {
                    btnKeyNameOn = true;
                    Rack.UserSettings.KeyName = _KeyName.On;
                    btnCtrlKeyName.Background = ActiveBrush;
                    Rack.KirollSurface.DrawOnCanvas();
                }
                else
                {
                    btnKeyNameOn = false;
                    Rack.UserSettings.KeyName = _KeyName.Off;
                    btnCtrlKeyName.Background = IdleButtonBrush;
                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        private void btnExit_Click(object sender, RoutedEventArgs e)
        {
            kirollSetup.Dispose();
            Close();
        }

        private void btnInstrumentSettings_Click(object sender, RoutedEventArgs e)
        {
            if (!KirollSettingsOpened)
            {
                kirollSettingsOpened = true;

                // Graphic changes
                WindowInstrumentSettings_1.Visibility = Visibility.Visible;
                WindowInstrumentSettings_2.Visibility = Visibility.Visible;
                // btnInstrumentSettingImage.Source = closeSettingsIcon; // TODO fix
                btnInstrumentSettings.Background = ActiveBrush;
                btnInstrumentSettingLabel.Content = "Close Settings";

                // This changes the opacity of keybaords when settings are opened
                if (KirollStarted)
                {
                    KirollKeyboard.UpdateOpacity();
                }
            }
            else
            {
                kirollSettingsOpened = false;

                // Graphic changes
                WindowInstrumentSettings_1.Visibility = Visibility.Hidden;
                WindowInstrumentSettings_2.Visibility = Visibility.Hidden;
                // btnInstrumentSettingImage.Source = settingsIcon; // TODO fix
                btnInstrumentSettings.Background = DisableBrush;
                btnInstrumentSettingLabel.Content = "Instrument Settings";

                if (KirollStarted)
                {
                    KirollKeyboard.UpdateOpacity();
                }
            }
        }

        private void btnRotation_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                KirollSetup KirollSetup = new KirollSetup(this);
                if (Rack.UserSettings.Orientation == Orientation.Vertical)
                {
                    Rack.UserSettings.Orientation = Orientation.Horizontal;
                    btnRotation.Background = ActiveBrush;
                    Rack.AutoScroller.ScrollCenter = new Point(scrlKiroll.ActualWidth / 2, scrlKiroll.ActualHeight / 2); // scrollViewer.ActualWidth / 2
                    Rack.AutoScroller.ProportionalVertical = 125;

                    //Switching vertical and horizontal distance selector label names
                    LblVerticalDistance.Content = "Keys Horizontal Distance";
                    LblVerticalDistance.Margin = new Thickness(0, 0, 0, 0);
                    LblHorizontalDistance.Content = "Keys Vertical Distance";
                    LblHorizontalDistance.Margin = new Thickness(0, 0, 5, 0);

                    Rack.UserSettings.KeyVerticaDistance = 30;
                    txtVerticalDistance.Text = Rack.UserSettings.KeyVerticaDistance.ToString();
                    Rack.UserSettings.KeyHorizontalDistance = 300;
                    txtHorizontalDistance.Text = Rack.UserSettings.KeyHorizontalDistance.ToString();

                    Rack.KirollSurface.DrawOnCanvas();
                }
                else
                {
                    Rack.UserSettings.Orientation = Orientation.Vertical;
                    btnRotation.Background = IdleButtonBrush;
                    Rack.AutoScroller.ScrollCenter = new Point(200, scrlKiroll.ActualHeight / 2 + 100); // scrollViewer.ActualWidth / 2
                    Rack.AutoScroller.ProportionalVertical = Rack.AutoScroller.ProportionalHorizontal - 225;

                    //Switching vertical and horizontal distance selector label names
                    LblVerticalDistance.Content = "Keys Vertical Distance";
                    LblVerticalDistance.Margin = new Thickness(0, 0, 5, 0);
                    LblHorizontalDistance.Content = "Keys Horizontal Distance";
                    LblHorizontalDistance.Margin = new Thickness(0, 0, 0, 0);

                    Rack.UserSettings.KeyVerticaDistance = 20;
                    txtVerticalDistance.Text = Rack.UserSettings.KeyVerticaDistance.ToString();
                    Rack.UserSettings.KeyHorizontalDistance = 300;
                    txtHorizontalDistance.Text = Rack.UserSettings.KeyHorizontalDistance.ToString();

                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            if (!KirollStarted)
            {
                kirollSetup = new KirollSetup(this);
                kirollSetup.Setup();

                // Graphic changes
                // btnStartImage.Source = pauseIcon; // TODO
                btnStart.Background = ActiveBrush;
                btnStartLabel.Content = "Running...";

                if (Rack.UserSettings.KeyName == _KeyName.On)
                {
                    btnCtrlKeyName.Background = ActiveBrush;
                }

                if (Rack.UserSettings.Orientation == Orientation.Horizontal)
                {
                    btnRotation.Background = ActiveBrush;
                }

                // Enabling various settings
                txtScale.Text = Rack.UserSettings.ScaleName;
                txtCode.Text = Rack.UserSettings.ScaleCode;
                txtOctave.Text = Rack.UserSettings.Octave;
                txtBlink.Text = blinkBehaviors[blinkIndex];
                txtBSwitc.Text = blowBehaviors[blowIndex];
                txtVerticalDistance.Text = Rack.UserSettings.KeyVerticaDistance.ToString();
                txtHorizontalDistance.Text = Rack.UserSettings.KeyHorizontalDistance.ToString();

                // MIDI
                CheckMidiPort();

                // Breath Sensor
                CheckSensorPort();

                //Metronome
                CheckMetronome();

                updater.Start();

                KirollStarted = true;
            }
            else
            {
                KirollStarted = false; // disabling all settings

                // Graphic changes
                // btnStartImage.Source = startIcon; // TODO
                btnStart.Background = IdleButtonBrush;
                btnStartLabel.Content = "Start";
                txtMidiPort.Text = "";
                txtBreathPort.Text = "";
                txtMetronome.Text = "";
                // TODO fix
                btnMetronome.Background = IdleButtonBrush;
                btnCtrlKeyName.Background = IdleButtonBrush;
                btnRotation.Background = IdleButtonBrush;

                // Disabling various settings, _metronomeMediaPlayer and blinkKeyboards behave
                txtScale.Text = "";
                txtCode.Text = "";
                txtOctave.Text = "";
                txtVerticalDistance.Text = "";
                txtHorizontalDistance.Text = "";
                txtBlink.Text = "";
                txtBSwitc.Text = "";
                playMetronome = false;
                letBlink = false;

                // Resetting surface
                Rack.KirollSurface.ClearSurface();

                updater.Stop();
            }
        }

        #endregion Start, Exit and Setting buttons

        #endregion TopBar (Row0)

        #region Instrument (Row1)

        #region Instrument Settings 1

        public void btnCodeMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnSharpNotesOn)
                {
                    if (codeIndex > 0)
                        codeIndex--;
                }
            }
        }

        private void btnBreathPortMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                SensorPort--;
                //Graphic changes
                CheckSensorPort();
            }
        }

        private void btnBreathPortPlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                SensorPort++;
                //Graphic changes
                CheckSensorPort();
            }
        }

        private void btnCodePlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnSharpNotesOn)
                {
                    if (codeIndex < 3)
                        codeIndex++;
                }
            }
        }

        private void btnCtrlBreath_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnBreathOn)
                {
                    btnBreathOn = true;
                    btnKeyboardOn = false;
                    btnCtrlBreath.IsEnabled = false;
                    btnCtrlKeyboard.IsEnabled = true;
                    btnCtrlBreath.Background = ActiveBrush;
                    btnCtrlKeyboard.Background = IdleButtonBrush;
                    txtBSwitc.Foreground = new SolidColorBrush(Colors.White);

                    Rack.UserSettings.KirollControlMode = _KirollControlModes.Breath;
                    Rack.MappingModule.ResetModulationAndPressure();
                }
            }
        }

        private void btnCtrlKeyboard_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnKeyboardOn)
                {
                    btnKeyboardOn = true;
                    btnBreathOn = false;
                    btnCtrlKeyboard.IsEnabled = false;
                    btnCtrlBreath.IsEnabled = true;
                    btnCtrlKeyboard.Background = ActiveBrush;
                    btnCtrlBreath.Background = IdleButtonBrush;
                    txtBSwitc.Foreground = WarningBrush;

                    Rack.UserSettings.KirollControlMode = _KirollControlModes.Keyboard;
                    Rack.MappingModule.ResetModulationAndPressure();
                }
            }
        }

        private void btnMidiPortMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                Rack.UserSettings.MIDIPort--;
                Rack.MidiModule.OutDevice = Rack.UserSettings.MIDIPort;

                // Graphic changes
                CheckMidiPort();
            }
        }

        private void btnMidiPortPlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                Rack.UserSettings.MIDIPort++;
                Rack.MidiModule.OutDevice = Rack.UserSettings.MIDIPort;

                // Graphic changes
                CheckMidiPort();
            }
        }

        private void btnOctaveMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (octaveIndex > 0)
                    octaveIndex--;
            }
        }

        private void btnOctavePlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (octaveIndex < 4)
                    octaveIndex++;
            }
        }

        private void btnScaleMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (scaleIndex > 0)
                    scaleIndex--;
            }
        }

        private void btnScalePlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (scaleIndex < 11)
                    scaleIndex++;
            }
        }

        // this just changes MIDIport selector graphic
        private void CheckMidiPort()
        {
            txtMidiPort.Text = "MP" + Rack.MidiModule.OutDevice.ToString();
            if (Rack.MidiModule.IsMidiOk())
            {
                txtMidiPort.Foreground = ActiveBrush;
            }
            else
            {
                txtMidiPort.Foreground = WarningBrush;
            }
        }

        // this just changes SensorPort selector graphic
        private void CheckSensorPort()
        {
            txtBreathPort.Text = "COM" + SensorPort.ToString();

            if (Rack.USBreceiverSensor.Connect(SensorPort))
            {
                txtBreathPort.Foreground = ActiveBrush;
            }
            else
            {
                txtBreathPort.Foreground = WarningBrush;
            }
        }

        #endregion Instrument Settings 1

        #region Instrument Settings 2

        private void btnBlink_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnBlinkOn)
                {
                    btnBlinkOn = true;
                    btnBlink.Background = ActiveBrush;

                    switch (txtBlink.Text)
                    {
                        case "Key":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Scale;
                            break;

                        case "Octave":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Octave;
                            break;

                        case "Scale":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Code;
                            break;
                    }
                }
                else
                {
                    btnBlinkOn = false;
                    btnBlink.Background = IdleButtonBrush;
                    Rack.UserSettings.BlinkModes = _BlinkModes.Off;
                }
            }
        }

        private void btnBlinkMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (blinkIndex > 0)
                {
                    blinkIndex--;
                    txtBlink.Text = blinkBehaviors[blinkIndex];
                    switch (blinkBehaviors[blinkIndex])
                    {
                        case "Key":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Scale;
                            break;

                        case "Octave":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Octave;
                            break;

                        case "Scale":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Code;
                            break;
                    }
                }
            }
        }

        private void btnBlinkPlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (blinkIndex < 2)
                {
                    blinkIndex++;
                    txtBlink.Text = blinkBehaviors[blinkIndex];
                    switch (blinkBehaviors[blinkIndex])
                    {
                        case "Key":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Scale;
                            break;

                        case "Octave":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Octave;
                            break;

                        case "Scale":
                            Rack.UserSettings.BlinkModes = _BlinkModes.Code;
                            break;
                    }
                }
            }
        }

        private void btnBSwitchMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (blowIndex > 0)
                {
                    blowIndex--;
                    txtBSwitc.Text = blowBehaviors[blowIndex];
                    switch (blowBehaviors[blowIndex])
                    {
                        case "Dynamic":
                            Rack.UserSettings.BreathControlModes = _BreathControlModes.Dynamic;
                            break;

                        case "Static":
                            Rack.UserSettings.BreathControlModes = _BreathControlModes.Static;
                            break;
                    }
                }
            }
        }

        private void btnBSwitcPlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (blowIndex < 1)
                {
                    blowIndex++;
                    txtBSwitc.Text = blowBehaviors[blowIndex];
                    switch (blowBehaviors[blowIndex])
                    {
                        case "Dynamic":
                            Rack.UserSettings.BreathControlModes = _BreathControlModes.Dynamic;
                            break;

                        case "Static":
                            Rack.UserSettings.BreathControlModes = _BreathControlModes.Static;
                            break;
                    }
                }
            }
        }

        // Setting horizontal distance between keyboards
        private void btnHorizontalDistanceMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (Rack.UserSettings.KeyHorizontalDistance > 200)
                {
                    Rack.UserSettings.KeyHorizontalDistance -= 100;
                    txtHorizontalDistance.Text = Rack.UserSettings.KeyHorizontalDistance.ToString();
                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        private void btnHorizontalDistancePlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                int max;
                int value;
                if (Rack.UserSettings.Orientation == Orientation.Vertical)
                {
                    max = 600;
                    value = 100;
                }
                else
                {
                    max = 400;
                    value = 100;
                }

                if (Rack.UserSettings.KeyHorizontalDistance < max)
                {
                    Rack.UserSettings.KeyHorizontalDistance += value;
                    txtHorizontalDistance.Text = Rack.UserSettings.KeyHorizontalDistance.ToString();
                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        private void btnMetrnomeMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                Rack.UserSettings.BPMmetronome--;
                metronomeTimer.Interval = Convert.ToInt32(1000 * 60 / (Rack.UserSettings.BPMmetronome)); ;
                CheckMetronome();
            }
        }

        private void btnMetrnomePlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                Rack.UserSettings.BPMmetronome++;
                metronomeTimer.Interval = Convert.ToInt32(1000 * 60 / (Rack.UserSettings.BPMmetronome)); ;
                CheckMetronome();
            }
        }

        private void btnMetronome_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!playMetronome)
                {
                    playMetronome = true;
                    btnMetronome.Background = ActiveBrush;
                }
                else
                {
                    playMetronome = false;
                    btnMetronome.Background = IdleButtonBrush;
                }

                CheckMetronome();
            }
        }

        private void btnSharpNotes_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnSharpNotesOn)
                {
                    btnSharpNotesOn = true;

                    btnSharpNotes.Background = ActiveBrush;
                    Rack.UserSettings.SharpNotesMode = _SharpNotesModes.On;

                    // Avoiding that scale exits the canvas
                    if (Rack.UserSettings.KeyVerticaDistance > 30)
                    {
                        Rack.UserSettings.KeyVerticaDistance = 30;
                        txtVerticalDistance.Text = Rack.UserSettings.KeyVerticaDistance.ToString();
                    }

                    Rack.KirollSurface.DrawOnCanvas();
                }
                else
                {
                    btnSharpNotesOn = false;

                    btnSharpNotes.Background = IdleButtonBrush;
                    Rack.UserSettings.SharpNotesMode = _SharpNotesModes.Off;
                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        private void btnSlidePlay_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                if (!btnSlidePlayOn)
                {
                    btnSlidePlayOn = true;

                    btnSlidePlay.Background = ActiveBrush;
                    Rack.UserSettings.SlidePlayMode = _SlidePlayModes.On;
                    //Resetting the oldNote because at start there is no an old note.
                    //This is true until the first note is played.
                    Rack.MappingModule.OldMidiNote = NITHdmis.Music.MidiNotes.NaN;
                }
                else
                {
                    btnSlidePlayOn = false;

                    btnSlidePlay.Background = IdleButtonBrush;
                    Rack.UserSettings.SlidePlayMode = _SlidePlayModes.Off;
                }
            }
        }

        // Setting vertical distance between keys in keyboards
        private void btnVerticalDistanceMinus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                int min;
                int value;
                if (Rack.UserSettings.Orientation == Orientation.Vertical)
                {
                    min = 5;
                    value = 5;
                }
                else
                {
                    min = 10;
                    value = 10;
                }

                if (Rack.UserSettings.KeyVerticaDistance >= min)
                {
                    Rack.UserSettings.KeyVerticaDistance -= value;
                    txtVerticalDistance.Text = Rack.UserSettings.KeyVerticaDistance.ToString();
                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        private void btnVerticalDistancePlus_Click(object sender, RoutedEventArgs e)
        {
            if (KirollStarted)
            {
                int max;
                int value;
                if (Rack.UserSettings.Orientation == Orientation.Vertical)
                {
                    max = 25;
                    value = 5;
                }
                else
                {
                    if (Rack.UserSettings.SharpNotesMode == _SharpNotesModes.On)
                    {
                        max = 20;
                    }
                    else
                    {
                        max = 50;
                    }
                    value = 10;
                }

                if (Rack.UserSettings.KeyVerticaDistance <= max)
                {
                    Rack.UserSettings.KeyVerticaDistance += value;
                    txtVerticalDistance.Text = Rack.UserSettings.KeyVerticaDistance.ToString();
                    Rack.KirollSurface.DrawOnCanvas();
                }
            }
        }

        // this just changes _metronomeMediaPlayer button's graphic
        private void CheckMetronome()
        {
            txtMetronome.Text = Rack.UserSettings.BPMmetronome.ToString();

            if (playMetronome)
            {
                txtMetronome.Foreground = ActiveBrush;
            }
            else
            {
                txtMetronome.Foreground = WarningBrush;
            }
        }

        #endregion Instrument Settings 2

        #endregion Instrument (Row1)



        private void Window_Unloaded(object sender, RoutedEventArgs e)
        {
            kirollSetup.Dispose();
        }

        private void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
        {
            WindowInstrumentSettings_1.Visibility = Visibility.Hidden;
            WindowInstrumentSettings_2.Visibility = Visibility.Hidden;

        }
    }
}