示例#1
0
            }             //StoreChordPresets

            void RestoreChordPresets(ListBox listBox, BinaryReader reader)
            {
                ChordPresetCollection collection = listBox.ItemsSource as ChordPresetCollection;

                collection.Clear();
                var selectedIndex   = reader.ReadInt32();
                var collectionCount = reader.ReadInt32();

                for (int index = 0; index < collectionCount; ++index)
                {
                    var name        = reader.ReadString();
                    var stateLength = reader.ReadInt32();
                    var states      = new ChordNoteState[stateLength];
                    for (int stateIndex = 0; stateIndex < stateLength; ++stateIndex)
                    {
                        states[stateIndex] = (ChordNoteState)reader.ReadByte();
                    }
                    collection.Add(new ChordPresetItem(name, states));
                }                 //loop
                if (selectedIndex >= 0 && selectedIndex < collectionCount - 1)
                {
                    listBox.SelectedIndex = selectedIndex;
                }
            } //RestoreChordPresets
示例#2
0
        Action SetupChordPresets(Controls.ChordNoteRadioButton[] chordButtons)           // return is reset
        {
            listBoxChordPresets.Items.Clear();
            var presetCollection = new ChordPresetCollection();

            listBoxChordPresets.ItemsSource = presetCollection;
            // saveChord:
            Func <ChordNoteState[]> saveChord = new Func <ChordNoteState[]>(() => {
                ChordNoteState[] result = new ChordNoteState[chordButtons.Length];
                for (int index = 0; index < chordButtons.Length; ++index)
                {
                    var button    = chordButtons[index];
                    result[index] = button.IsChecked == true ?
                                    ChordNoteState.On : ChordNoteState.Off;
                    if (button.BigChanger != null && button.BigChanger.IsChecked == true)
                    {
                        result[index] |= ChordNoteState.DoubleDouble;
                    }
                    if (button.Changer != null && button.Changer.IsChecked == true)
                    {
                        result[index] |= ChordNoteState.Double;
                    }
                }           //loop
                return(result);
            });             //makeChordName
            // restoreChord:
            Action <ChordNoteState[]> restoreChord = new Action <ChordNoteState[]>((savedState) => {
                for (int index = 0; index < chordButtons.Length; ++index)
                {
                    var button = chordButtons[index];
                    if (button.BigChanger != null)
                    {
                        button.BigChanger.IsChecked =
                            (savedState[index] & ChordNoteState.DoubleDouble) == ChordNoteState.DoubleDouble;
                    }
                    if (button.Changer != null)
                    {
                        button.Changer.IsChecked =
                            (savedState[index] & ChordNoteState.Double) == ChordNoteState.Double;
                    }
                    button.IsChecked = (savedState[index] & ChordNoteState.On) == ChordNoteState.On;
                }           //loop
            });             //restoreChord
            // makeChordName:
            Func <string> makeChordName = new Func <string>(() => {
                var missingName = (string)chordButtons[0].Content;
                var result      = new StringBuilder();
                for (int index = chordButtons.Length - 1; index >= 0; --index)
                {
                    var button = chordButtons[index];
                    if (button.IsChecked != true)
                    {
                        continue;
                    }
                    string noteName = (string)button.Content;
                    if (noteName == "5" || noteName == "3")
                    {
                        continue;
                    }
                    if (noteName == missingName)
                    {
                        continue;
                    }
                    if (result.Length > 0 && noteName.Length > 0 &&
                        !char.IsLetter(noteName[0]) &&
                        !char.IsLetter(result[result.Length - 1]))
                    {
                        result.Append("/");
                    }
                    result.Append(noteName);
                }                 //loop
                string proposed = result.ToString();
                if (proposed.Length < 1)
                {
                    return("major");
                }
                if (proposed == "m")
                {
                    return("minor");
                }
                if (proposed.Length == 4 && proposed.Substring(0, 2) == "m5" && proposed[3] == '6')
                {
                    return("dim");
                }
                if (proposed.StartsWith("2") || proposed.StartsWith("4"))
                {
                    return("sus" + proposed);
                }
                return(result.ToString());
            });             //makeChordName
            // setup handlers:
            var adjustEnable = new Action <bool>((resetChords) => {
                buttonRemoveChordPreset.IsEnabled = listBoxChordPresets.SelectedIndex >= 0;
                if (resetChords && !buttonRemoveChordPreset.IsEnabled)
                {
                    ResetChords();
                }
            });             //adjustEnable

            adjustEnable(false);
            //
            presetCollection.CollectionChanged += (sender, eventArgs) => { adjustEnable(false); };
            buttonRemoveChordPreset.Click      += (sender, eventArgs) => {
                var selected = listBoxChordPresets.SelectedIndex;
                if (selected < 0)
                {
                    return;
                }
                presetCollection.RemoveAt(selected);
                if (selected < presetCollection.Count)
                {
                    listBoxChordPresets.SelectedIndex = selected;
                }
                else if (presetCollection.Count > 0)
                {
                    listBoxChordPresets.SelectedIndex = presetCollection.Count - 1;
                }
            };             //buttonRemoveChordPreset.Click
            buttonAddChordPreset.Click += (sender, eventArgs) => {
                var item = new ChordPresetItem(makeChordName(), saveChord());
                presetCollection.Add(item);
                listBoxChordPresets.SelectedIndex = presetCollection.Count - 1;
            };             //buttonAddChordPreset.Click
            buttonInsertChordPreset.Click += (sender, eventArgs) => {
                var item  = new ChordPresetItem(makeChordName(), saveChord());
                int index = this.listBoxChordPresets.SelectedIndex;
                if (index < 0)
                {
                    index = 0;
                }
                presetCollection.Insert(index, item);
                listBoxChordPresets.SelectedIndex = index;
            };             //buttonInsertChordPreset.Click
            listBoxChordPresets.SelectionChanged += (sender, eventArgs) => {
                bool needsReset = eventArgs.RemovedItems.Count > 0 && eventArgs.AddedItems.Count < 1;
                adjustEnable(needsReset);
                ListBox listBoxSender = (ListBox)sender;
                int     index         = this.listBoxChordPresets.SelectedIndex;
                if (index < 0)
                {
                    return;
                }
                restoreChord(presetCollection[index].State);
            };             //listBoxChordPresets.SelectionChanged
            //
            Action <string, ChordNoteState[]> resetOne = new Action <string, ChordNoteState[]>((name, chord) => {
                presetCollection.Add(new ChordPresetItem(name, chord));
            });             //resetOne
            Func <int, int, int, ChordNoteState[]> makeTriad = new Func <int, int, int, ChordNoteState[]>((mediant, dominant, leading) => {
                ChordNoteState[] chord = new ChordNoteState[chordButtons.Length];
                foreach (int index in new int[] { 0, 3, 6, 10 })
                {
                    chord[index] = ChordNoteState.On;                     // 'x'
                }
                chord[mediant]  = ChordNoteState.On;
                chord[dominant] = ChordNoteState.On;
                if (leading > 0)
                {
                    chord[leading] = ChordNoteState.On;
                }
                return(chord);
            });             //makeTriad
            //makeTriad
            Action reset = new Action(() => {
                const int fifth = 15; const int none = 0;
                presetCollection.Clear();
                resetOne("7", makeTriad(19, fifth, 12));
                resetOne("minor", makeTriad(18, fifth, none));
                resetOne("major", makeTriad(19, fifth, none));
                resetOne("7+", makeTriad(19, fifth, 13));
                resetOne("dim", makeTriad(18, fifth - 1, 11));
                resetOne("6", makeTriad(19, fifth, 11));
                resetOne("sus2", makeTriad(17, fifth, none));
                resetOne("sus4", makeTriad(20, fifth, none));
                resetOne("m5\u2212/7", makeTriad(18, fifth - 1, 12));
            });             //reset

            //
            this.buttonResetChordPreset.Click += (sender, eventArgs) => { reset(); };
            reset();
            return(reset);
        } //SetupChordPresets