public TrackInclusionRec(TrackObjectRec Track, Source source) : base(source, Source.IncludedTracks_PropertyName) { this.Track = Track; this._Included = Track.IncludeThisTrackInFinalPlayback; this.Track.PropertyChanged += Track_PropertyChanged; }
public TrackWindow(Registration registration, TrackObjectRec trackObject, IMainWindowServices mainWindow) { this.registration = registration; this.trackObject = trackObject; this.mainWindow = mainWindow; InitializeComponent(); this.Icon = OutOfPhase.Properties.Resources.Icon2; // By default make new tracks take up most of the horizontal screen width. SetDesktopBounds(DesktopBounds.X, DesktopBounds.Y, Screen.PrimaryScreen.Bounds.Width - DesktopBounds.X - 100, DesktopBounds.Height); menuStripManager.SetGlobalHandler(mainWindow); GlobalNameChanged(); registration.Register(trackObject, this); backgroundToolStripMenuItem = new ToolStripMenuItem("Background", null, new EventHandler(backgroundMenuItem_Click)); menuStripManager.ContainedMenuStrip.Items.Add(backgroundToolStripMenuItem); inlineEditToolStripMenuItem = new ToolStripMenuItem("Inline", null, new EventHandler(inlineEditMenuItem_Click)); menuStripManager.ContainedMenuStrip.Items.Add(inlineEditToolStripMenuItem); trackEditControl.Init(trackObject, mainWindow, menuStripManager, backgroundToolStripMenuItem, inlineEditToolStripMenuItem); trackObject.PropertyChanged += TrackObject_PropertyChanged; // Change font if preferences have scale factor. Use 'force' to ensure note view and parma strip always compute the // correct height even if font hasn't changed to prevent layout glitch. DpiChangeHelper.ScaleFont(this, Program.Config.AdditionalUIZoom, true /*force*/); }
private void buttonEditSection_Click(object sender, EventArgs e) { { SectionObjectRec selectedSection = myListBoxSections.SelectedItem as SectionObjectRec; if (selectedSection != null) { if (!registration.Activate(selectedSection)) { new SectionWindow(registration, selectedSection, mainWindow).Show(); } return; } } { TrackObjectRec selectedTrack = myListBoxSections.SelectedItem as TrackObjectRec; if (selectedTrack != null) { if (selectedTrack.Section != null) { if (!registration.Activate(selectedTrack.Section)) { new SectionWindow(registration, selectedTrack.Section, mainWindow).Show(); } } return; } } }
public TrackAttributeDialog(TrackObjectRec track) { this.track = track; InitializeComponent(); this.Icon = OutOfPhase.Properties.Resources.Icon2; DpiChangeHelper.ScaleFont(this, Program.Config.AdditionalUIZoom); foreach (string item in EnumUtility.GetDescriptions(TrackObjectRec.DefaultReleasePoint1ModeFlagAllowedValues, TrackObjectRec.DefaultReleasePoint1ModeFlag_EnumCategoryName)) { comboBoxDefaultReleasePoint1Flags.Items.Add(item); } foreach (string item in EnumUtility.GetDescriptions(TrackObjectRec.DefaultReleasePoint2ModeFlagAllowedValues, TrackObjectRec.DefaultReleasePoint2ModeFlag_EnumCategoryName)) { comboBoxDefaultReleasePoint2Flags.Items.Add(item); } foreach (string item in EnumUtility.GetDescriptions(TrackObjectRec.DefaultPitchDisplacementStartPointModeFlagAllowedValues, TrackObjectRec.DefaultPitchDisplacementStartPointModeFlag_EnumCategoryName)) { comboBoxDefaultPitchDisplacementStartFlags.Items.Add(item); } foreach (string item in EnumUtility.GetDescriptions(TrackObjectRec.DefaultDurationModeFlagAllowedValues, TrackObjectRec.DefaultDurationModeFlag_EnumCategoryName)) { comboBoxDefaultDurationAdjustModeFlags.Items.Add(item); } foreach (string item in EnumUtility.GetDescriptions(TrackObjectRec.DefaultDetuneModeFlagAllowedValues, TrackObjectRec.DefaultDetuneModeFlag_EnumCategoryName)) { comboBoxDefaultDetuningModeFlags.Items.Add(item); } trackObjectRecBindingSource.Add(track); }
private void EditTrackProperties() { TrackObjectRec copy = TrackObjectRec.CloneProperties(trackObject, new Document()); using (TrackAttributeDialog trackAttributeDialog = new TrackAttributeDialog(copy)) { DialogResult result = trackAttributeDialog.ShowDialog(); if (result == DialogResult.OK) { trackObject.CopyPropertiesFrom(copy); } } }
private void buttonChangeSection_Click(object sender, EventArgs e) { TrackObjectRec track = myListBoxSections.SelectedItem as TrackObjectRec; if (track != null) { using (SectionChooseDialog dialog = new SectionChooseDialog(document.SectionList, track.Section)) { if (dialog.ShowDialog() == DialogResult.OK) { SectionObjectRec section = dialog.SelectedSection; track.Section = section; RebuildScrollingList(); } } } }
public SynthesizerGeneratorParams( IMainWindowServices mainWindow, Document document, List <TrackObjectRec> listOfTracks, TrackObjectRec keyTrack, int frameToStartAt, int samplingRate, int envelopeRate, NumChannelsType channels, LargeBCDType defaultBeatsPerMinute, double overallVolumeScalingReciprocal, LargeBCDType scanningGap, NumBitsType bits, bool clipWarn, int oversamplingFactor, bool showSummary, bool deterministic,// now ignored - control by setting randomSeed to null or int int?randomSeed, Synthesizer.AutomationSettings automationSettings) { this.mainWindow = mainWindow; this.document = document; this.listOfTracks = listOfTracks; this.keyTrack = keyTrack; this.frameToStartAt = frameToStartAt; this.samplingRate = samplingRate; this.envelopeRate = envelopeRate; this.channels = channels; this.defaultBeatsPerMinute = defaultBeatsPerMinute; this.overallVolumeScalingReciprocal = overallVolumeScalingReciprocal; this.scanningGap = scanningGap; this.bits = bits; this.clipWarn = clipWarn; this.oversamplingFactor = oversamplingFactor; this.showSummary = showSummary; this.deterministic = deterministic; this.randomSeed = randomSeed; this.automationSettings = automationSettings; }
/* insert rests */ private static void InsertRests( FractionRec Now, FractionRec Target, TrackObjectRec NoteTrack, OpDurRec[] OpcodeDurationTable, int OpcodeDurationTableLength) { while (FractionRec.FracGreaterThan(Target, Now)) { FractionRec Difference; NoteFlags Opcode; FractionRec OpcodesDuration; NoteNoteObjectRec Note; FrameObjectRec Frame; /* how much time left */ FractionRec.SubFractions(Target, Now, out Difference); /* search for appropriate opcode */ Opcode = GetMaxDurationOpcode(Difference, out OpcodesDuration, OpcodeDurationTable, OpcodeDurationTableLength); /* add duration to Now */ FractionRec.AddFractions(Now, OpcodesDuration, out Now); /* create the note */ Note = new NoteNoteObjectRec(NoteTrack); Note.PutNoteDuration(Opcode & NoteFlags.eDurationMask); Note.PutNoteDurationDivision(Opcode & NoteFlags.eDivisionMask); Note.PutNoteDotStatus((Opcode & NoteFlags.eDotModifier) != 0); Note.PutNotePitch(Constants.CENTERNOTE); Note.PutNoteIsItARest(true); /* create the frame */ Frame = new FrameObjectRec(); Frame.Add(Note); NoteTrack.FrameArray.Add(Frame); } }
/* import midi file from existing file pointer */ public static void ImportMIDIFileSpecified(string Where) { RawMIDIScoreRec Score = NewRawMIDIScore(); using (Stream stream = new FileStream(Where, FileMode.Open, FileAccess.Read, FileShare.Read, Constants.BufferSize)) { using (BinaryReader BufferedFile = new BinaryReader(stream)) { MIDIParseErrorType result = MIDIParseErrorType.eMIDIParseFileReadError; try { result = ParseMIDIFile(BufferedFile, Score); } catch (InvalidDataException) { // generally - unexpected eof Debug.Assert(result == MIDIParseErrorType.eMIDIParseFileReadError); } switch (result) { default: Debug.Assert(false); throw new ArgumentException(); case MIDIParseErrorType.eMIDIParseNoError: break; case MIDIParseErrorType.eMIDIParseFileReadError: MessageBox.Show( "An error occurred while reading the file. Attempting to import as much of the file as possible.", "Import Error", MessageBoxButtons.OK, MessageBoxIcon.Error); break; case MIDIParseErrorType.eMIDIParseBadFormat: MessageBox.Show( "The file is not a valid MIDI file. Attempting to import as much of the file as possible.", "Import Error", MessageBoxButtons.OK, MessageBoxIcon.Error); break; } } } if (GetRawMIDIScoreNumTracks(Score) > 0) { /* create the new document to put the tracks into */ bool TrackWasCreated = false; Document Document = new Document(); /* iterate over MIDI tracks */ int TrackLimit = GetRawMIDIScoreNumTracks(Score); for (int TrackScan = 0; TrackScan < TrackLimit; TrackScan++) { /* get track */ RawMIDITrackRec Track = GetRawMIDIScoreIndexedTrack(Score, TrackScan); /* process channels */ for (short ChannelScan = 1; ChannelScan <= 16; ChannelScan++) { bool KeepFlag; IntervalTrackRec IntervalTrack = NewIntervalTrack(); ConvertRawToInterval(Track, IntervalTrack, ChannelScan, out KeepFlag); /* process cooked track into one of our track objects */ if (KeepFlag) { QuantizedTrackRec QuantizedTrack; TrackObjectRec DocumentTrack; /* make sure we can handle this track */ if (MIDITimingType.eMIDIMeteredTime != RawMIDIScoreGetTimingMode(Score)) { MessageBox.Show( "Can't import real-time MIDI files.", "Import Error", MessageBoxButtons.OK, MessageBoxIcon.Stop); return; } QuantizedTrack = NewQuantizedTrack(); ConvertIntervalToQuantized(IntervalTrack, QuantizedTrack, RawMIDIScoreGetPartsPerQuarterNote(Score)); DocumentTrack = new TrackObjectRec(Document); Document.TrackList.Add(DocumentTrack); TrackWasCreated = true; ConvertQuantToNote(QuantizedTrack, DocumentTrack); /* set track release point 1 to be from end */ DocumentTrack.DefaultReleasePoint1ModeFlag = NoteFlags.eRelease1FromEnd; } } } /* clear the dirty flag, since nothing was actually modified */ Document.Modified = false; /* remove track if we didn't actually find anything in the file */ if (!TrackWasCreated) { MessageBox.Show( "No tracks were found in the MIDI file.", "Import Error", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } MainWindow MainWindow = new MainWindow(Document, null); MainWindow.Show(); } }
/* convert quantized track into native track */ public static void ConvertQuantToNote( QuantizedTrackRec QuantizedTrack, TrackObjectRec NoteTrack) { FractionRec CurrentTime; int Index; int Limit; List <QuantEventRec> FrameArray; TieMappingRec TieMapping; int OpcodeDurationTableLength; OpDurRec[] OpcodeDurationTable = new OpDurRec[4 /*divisions*/ * 2 /*dot*/ * 9 /*notetypes*/]; /* initialize variables */ InitializeOpcodeDurationTable(OpcodeDurationTable, out OpcodeDurationTableLength); CurrentTime.Integer = 0; CurrentTime.Fraction = 0; CurrentTime.Denominator = 1; FrameArray = new List <QuantEventRec>(); TieMapping = NewTieMapping(); Limit = GetQuantizedTrackLength(QuantizedTrack); Index = 0; /* iterate over variables */ while (Index < Limit) { FractionRec NextTime; QuantEventRec QuantEvent; bool Continue; int InspectScan; /* reset frame array */ FrameArray.Clear(); /* get the start time of the next available event */ QuantEvent = GetQuantizedTrackIndexedEvent(QuantizedTrack, Index); NextTime = GetQuantizedEventTime(QuantEvent); Debug.Assert(FractionIntMultOf64thDiv3(NextTime)); // non-64div3 start time quantization? /* sanity check */ Debug.Assert(!FractionRec.FracGreaterThan(CurrentTime, NextTime)); // next time inconsistency /* get all events starting at this time into FrameArray */ Continue = true; while (Continue && (Index < Limit)) { FractionRec EventTime; /* get the event */ QuantEvent = GetQuantizedTrackIndexedEvent(QuantizedTrack, Index); EventTime = GetQuantizedEventTime(QuantEvent); Debug.Assert(FractionIntMultOf64thDiv3(EventTime)); // non-64div3 start time quantization? if (FractionRec.FractionsEqual(EventTime, NextTime)) { /* add event to the list */ FrameArray.Add(QuantEvent); /* go past this event */ Index += 1; } else { /* end hit so stop */ Continue = false; } } /* insert rests to bring current time up to next time */ InsertRests(CurrentTime, NextTime, NoteTrack, OpcodeDurationTable, OpcodeDurationTableLength); /* remove command events from list */ InspectScan = 0; while (InspectScan < FrameArray.Count) { /* get the event */ QuantEvent = FrameArray[InspectScan]; /* determine if event is a command */ if (QuantizedEventGetType(QuantEvent) == QuantEventType.eQuantizedNoteEvent) { /* note events should be skipped */ InspectScan += 1; } else { /* command events should be handled */ switch (QuantizedEventGetType(QuantEvent)) { default: Debug.Assert(false); throw new InvalidOperationException(); case QuantEventType.eQuantizedCommentEvent: { string CommentString; CommandNoteObjectRec Note; FrameObjectRec Frame; FractionRec unusedf; double unusedd; GetQuantizedCommentEventInfo(QuantEvent, out unusedf, out unusedd, out CommentString); Note = new CommandNoteObjectRec(NoteTrack); Note.PutCommandStringArg1(CommentString); Note.PutCommandOpcode(NoteCommands.eCmdMarker); Frame = new FrameObjectRec(); Frame.Add(Note); NoteTrack.FrameArray.Add(Frame); } break; } /* delete event from array */ FrameArray.RemoveAt(InspectScan); /* don't increment InspectScan */ } } /* process remaining notes in FrameArray, computing minimum duration */ /* and updating CurrentTime with minimum duration. */ if (FrameArray.Count != 0) { NoteFlags DurationOpcode; FrameObjectRec Frame; int Scan; int FrameLimit; FractionRec MinimumDuration; FractionRec unusedf; double unusedd; short unuseds; /* initialize minimum duration */ QuantEvent = FrameArray[0]; GetQuantizedNoteEventInfo(QuantEvent, out unusedf, out unusedd, out DurationOpcode, out unusedd, out unuseds, out unuseds, out unuseds); NoteNoteObjectRec.ConvertDurationFrac(DurationOpcode, out MinimumDuration); Debug.Assert(FractionIntMultOf64thDiv3(MinimumDuration)); // non-64div3 duration quantization? /* allocate frame */ Frame = new FrameObjectRec(); /* process notes in frame */ FrameLimit = FrameArray.Count; for (Scan = 0; Scan < FrameLimit; Scan += 1) { FractionRec StartTime; double StartTimeAdjust; NoteFlags Duration; double DurationAdjust; short MIDIPitch; short MIDIAttackVelocity; short MIDIReleaseVelocity; NoteNoteObjectRec Note; FractionRec FracDuration; /* get the note */ QuantEvent = FrameArray[Scan]; Debug.Assert(QuantizedEventGetType(QuantEvent) == QuantEventType.eQuantizedNoteEvent); // non-note in frame array /* get attributes */ GetQuantizedNoteEventInfo(QuantEvent, out StartTime, out StartTimeAdjust, out Duration, out DurationAdjust, out MIDIPitch, out MIDIAttackVelocity, out MIDIReleaseVelocity); Debug.Assert(IntMultOf64thDiv3(Duration)); // non-64div3 duration quantization? Debug.Assert(FractionRec.FractionsEqual(StartTime, CurrentTime)); // start time inconsistency /* create note */ Note = new NoteNoteObjectRec(NoteTrack); Frame.Add(Note); TieMappingAddPair(TieMapping, QuantEvent, Note); /* set note attributes */ Note.PutNoteDuration(Duration & NoteFlags.eDurationMask); Note.PutNoteDurationDivision(Duration & NoteFlags.eDivisionMask); Note.PutNoteDotStatus((Duration & NoteFlags.eDotModifier) != 0); Note.EarlyLateAdjust = StartTimeAdjust; Note.DurationAdjust = DurationAdjust; Note.DurationAdjustMode = NoteFlags.eDurationAdjustMultiplicative; Note.PutNotePitch((short)(MIDIPitch - MIDIC + Constants.CENTERNOTE)); Note.Accent1 = (MIDIAttackVelocity > 0) ? -Math.Log(MIDIAttackVelocity) / Constants.LOG2 + LN127OVERLN2 : 7; Note.Accent2 = (MIDIReleaseVelocity > 0) ? -Math.Log(MIDIReleaseVelocity) / Constants.LOG2 + LN127OVERLN2 : 7; switch ((MIDIPitch - MIDIC + ((MIDIC / 12 + 1) * 12)) % 12) { default: // midi sharp/flat problem Debug.Assert(false); throw new InvalidOperationException(); case 0: /* C */ case 2: /* D */ case 4: /* E */ case 5: /* F */ case 7: /* G */ case 9: /* A */ case 11: /* B */ break; case 1: /* C# */ case 3: /* D# */ case 6: /* F# */ case 8: /* G# */ case 10: /* A# */ Note.PutNoteFlatOrSharpStatus(NoteFlags.eSharpModifier); break; } /* do the minimum duration thing */ NoteNoteObjectRec.ConvertDurationFrac(Duration, out FracDuration); Debug.Assert(FractionIntMultOf64thDiv3(FracDuration)); // non-64div3 duration quantization? if (FractionRec.FracGreaterThan(MinimumDuration, FracDuration)) { MinimumDuration = FracDuration; } } /* add frame to track */ NoteTrack.FrameArray.Add(Frame); /* if minimum duration is greater than time to next event, then */ /* add rests (one to this frame) to fill in the gap */ if (Index < Limit) { FractionRec NextEventTime; FractionRec Difference; /* get the start time of the next available event */ QuantEvent = GetQuantizedTrackIndexedEvent(QuantizedTrack, Index); NextEventTime = GetQuantizedEventTime(QuantEvent); Debug.Assert(FractionIntMultOf64thDiv3(NextEventTime)); // non-64div3 start time quantization? FractionRec.SubFractions(NextEventTime, CurrentTime, out Difference); if (FractionRec.FracGreaterThan(MinimumDuration, Difference)) { NoteNoteObjectRec Note; NoteFlags RestOpcode; FractionRec OpcodesDuration; /* insert first rest into frame */ RestOpcode = GetMaxDurationOpcode(Difference, out OpcodesDuration, OpcodeDurationTable, OpcodeDurationTableLength); Debug.Assert(IntMultOf64thDiv3(RestOpcode)); // non-64div3 duration quantization Note = new NoteNoteObjectRec(NoteTrack); Note.PutNoteDuration(RestOpcode & NoteFlags.eDurationMask); Note.PutNoteDurationDivision(RestOpcode & NoteFlags.eDivisionMask); Note.PutNoteDotStatus((RestOpcode & NoteFlags.eDotModifier) != 0); Note.PutNotePitch(Constants.CENTERNOTE); Note.PutNoteIsItARest(true); Frame.Add(Note); /* put new minimum duration in to reflect new rest we added */ NoteNoteObjectRec.ConvertDurationFrac(RestOpcode, out MinimumDuration); } } /* advance thing by minimum duration */ FractionRec.AddFractions(MinimumDuration, CurrentTime, out CurrentTime); Debug.Assert(FractionIntMultOf64thDiv3(CurrentTime)); // non-64div3 start time quantization? } } /* patch up ties */ for (Index = 0; Index < Limit; Index += 1) { QuantEventRec QuantEvent; /* get potential event */ QuantEvent = GetQuantizedTrackIndexedEvent(QuantizedTrack, Index); /* see if it ties somewhere */ if ((QuantEventType.eQuantizedNoteEvent == QuantizedEventGetType(QuantEvent)) && (GetQuantizedEventTieTarget(QuantEvent) != null)) { QuantEventRec TieTarget; NoteNoteObjectRec Source; NoteNoteObjectRec Target; /* get tie target */ TieTarget = GetQuantizedEventTieTarget(QuantEvent); /* look up source and target note events */ Source = TieMappingLookup(TieMapping, QuantEvent); Target = TieMappingLookup(TieMapping, TieTarget); /* establish tie */ Source.PutNoteTieTarget(Target); } } /* look for track name comment */ for (Index = 0; Index < Limit; Index += 1) { QuantEventRec QuantEvent; /* get potential event */ QuantEvent = GetQuantizedTrackIndexedEvent(QuantizedTrack, Index); /* see if it ties somewhere */ if (QuantEventType.eQuantizedCommentEvent == QuantizedEventGetType(QuantEvent)) { string CommentString; FractionRec unusedf; double unusedd; GetQuantizedCommentEventInfo(QuantEvent, out unusedf, out unusedd, out CommentString); /* check for track name */ if ((CommentString.Length > 11 /*Prefix*/ + Environment.NewLine.Length) && CommentString.StartsWith("Track Name" + Environment.NewLine)) { string NameString = CommentString.Substring(11, CommentString.Length - (11 + 1)); NoteTrack.Name = NameString; goto FinishedSettingTrackName; } } } /* if no track name was found, then use the first comment string */ for (Index = 0; Index < Limit; Index += 1) { QuantEventRec QuantEvent; /* get potential event */ QuantEvent = GetQuantizedTrackIndexedEvent(QuantizedTrack, Index); /* see if it ties somewhere */ if (QuantEventType.eQuantizedCommentEvent == QuantizedEventGetType(QuantEvent)) { string CommentString; FractionRec unusedf; double unusedd; GetQuantizedCommentEventInfo(QuantEvent, out unusedf, out unusedd, out CommentString); /* check for track name */ if ((CommentString.Length > 8 /*Prefix*/ + Environment.NewLine.Length) && CommentString.StartsWith("Comment" + Environment.NewLine)) { string NameString; NameString = CommentString.Substring(8, CommentString.Length - (8 + 1)); NoteTrack.Name = NameString; goto FinishedSettingTrackName; } } } FinishedSettingTrackName: ; }
private void RebuildScrollingList() { object selection = myListBoxSections.SelectedItem; displayList.Clear(); TrackObjectRec[] tracks = new List <TrackObjectRec>(document.TrackList).ToArray(); /* set stable sort subkey */ for (int i = 0; i < tracks.Length; i++) { tracks[i].AuxVal = i; } Array.Sort( tracks, delegate(TrackObjectRec left, TrackObjectRec right) { return(Synthesizer.SynthStateRec.CompareTracksOnSection(left, right, document.SectionList)); }); SectionObjectRec section = null; bool firstTry = true; for (int i = 0; i < tracks.Length; i++) { TrackObjectRec track = tracks[i]; /* create the section name header */ if (firstTry || (section != track.Section)) { firstTry = false; section = track.Section; if (section == null) { displayList.Add((string)"(Default)"); } else { displayList.Add(section); } } /* add the track item */ displayList.Add(track); } /* add any sections we missed */ for (int j = 0; j < document.SectionList.Count; j++) { section = document.SectionList[j]; bool referenced = false; for (int i = 0; !referenced && (i < tracks.Length); i++) { TrackObjectRec track = document.TrackList[i]; if (track.Section == section) { referenced = true; } } if (!referenced) { displayList.Add(section); } } for (int i = 0; i < displayList.Count; i++) { if (selection == displayList[i]) { myListBoxSections.SelectItem(i, true /*clearOtherSelections*/); } } }
protected override object Load(BinaryReader reader, Document document) { track = new TrackObjectRec(reader, new LoadContext(Document.CurrentFormatVersionNumber, document, LoadContextState.Paste)); return(track); }
public TrackClipboard(TrackObjectRec track, Document document) : base(document) { this.track = track; }
public void Init( TrackObjectRec trackObject, IMainWindowServices mainWindow, MenuStripManager menuStripManager, ToolStripMenuItem backgroundToolStripMenuItem, ToolStripMenuItem inlineEditToolStripMenuItem) { this.trackObject = trackObject; this.mainWindow = mainWindow; this.menuStripManager = menuStripManager; this.backgroundToolStripMenuItem = backgroundToolStripMenuItem; this.inlineEditToolStripMenuItem = inlineEditToolStripMenuItem; noteViewControl.UndoHelper = trackViewControl.UndoHelper; noteParamStrip.UndoHelper = trackViewControl.UndoHelper; trackViewControl.NoteView = noteViewControl; trackViewControl.NoteParamStrip = noteParamStrip; trackViewControl.ContextUI = this; //documentBindingSource.Add(document); trackObjectRecBindingSource.Add(trackObject); trackViewControl.SetTrackObject(trackObject); trackViewControl.RestoreSavedScrollPosition(trackObject.SavedHScrollPos, trackObject.SavedVScrollPos); trackViewControl.Scroll += new ScrollEventHandler(trackViewControl_Scroll); ToolStripButton[] group; // group = new ToolStripButton[] { toolStripButtonArrow, toolStripButtonCommand, toolStripButtonSixtyFourth, toolStripButtonThirtySecond, toolStripButtonSixteenth, toolStripButtonEighth, toolStripButtonQuarter, toolStripButtonHalf, toolStripButtonWhole, toolStripButtonDouble, toolStripButtonQuad }; SetButton(toolStripButtonArrow, Bitmaps1Class.gdiArrowButtonBits, Bitmaps1Class.gdiArrowButtonSelectedBits, group, new ToolStripButton[] { toolStripButtonQuarter, toolStripButtonDiv1, toolStripButtonNatural, toolStripButtonNoDot, toolStripButtonNoteVsRest }); toolStripButtonArrow.Checked = true; // SetButton(toolStripButtonCommand, Bitmaps1Class.gdiCommandButtonBits, Bitmaps1Class.gdiCommandButtonSelectedBits, group, null); // SetButton(toolStripButtonSixtyFourth, Bitmaps1Class.gdiSixtyFourthButtonBits, Bitmaps1Class.gdiSixtyFourthButtonSelectedBits, group, null); SetButton(toolStripButtonThirtySecond, Bitmaps1Class.gdiThirtySecondButtonBits, Bitmaps1Class.gdiThirtySecondButtonSelectedBits, group, null); SetButton(toolStripButtonSixteenth, Bitmaps1Class.gdiSixteenthButtonBits, Bitmaps1Class.gdiSixteenthButtonSelectedBits, group, null); SetButton(toolStripButtonEighth, Bitmaps1Class.gdiEighthButtonBits, Bitmaps1Class.gdiEighthButtonSelectedBits, group, null); SetButton(toolStripButtonQuarter, Bitmaps1Class.gdiQuarterButtonBits, Bitmaps1Class.gdiQuarterButtonSelectedBits, group, null); SetButton(toolStripButtonHalf, Bitmaps1Class.gdiHalfButtonBits, Bitmaps1Class.gdiHalfButtonSelectedBits, group, null); SetButton(toolStripButtonWhole, Bitmaps1Class.gdiWholeButtonBits, Bitmaps1Class.gdiWholeButtonSelectedBits, group, null); SetButton(toolStripButtonDouble, Bitmaps1Class.gdiDoubleButtonBits, Bitmaps1Class.gdiDoubleButtonSelectedBits, group, null); SetButton(toolStripButtonQuad, Bitmaps1Class.gdiQuadButtonBits, Bitmaps1Class.gdiQuadButtonSelectedBits, group, null); // group = new ToolStripButton[] { toolStripButtonSharp, toolStripButtonFlat, toolStripButtonNatural }; SetButton(toolStripButtonSharp, Bitmaps1Class.gdiSharpButtonBits, Bitmaps1Class.gdiSharpButtonSelectedBits, group, null); SetButton(toolStripButtonFlat, Bitmaps1Class.gdiFlatButtonBits, Bitmaps1Class.gdiFlatButtonSelectedBits, group, null); SetButton(toolStripButtonNatural, Bitmaps1Class.gdiNaturalButtonBits, Bitmaps1Class.gdiNaturalButtonSelectedBits, group, null); toolStripButtonNatural.Checked = true; // group = new ToolStripButton[] { toolStripButtonNoteVsRest, toolStripButtonNoteVsRest2 }; SetButton(toolStripButtonNoteVsRest, Bitmaps1Class.gdiNoteVsRestButtonBits, Bitmaps1Class.gdiNoteVsRestButtonSelectedBits, group, null); SetButton(toolStripButtonNoteVsRest2, Bitmaps1Class.gdiRestVsNoteButtonBits, Bitmaps1Class.gdiRestVsNoteButtonSelectedBits, group, null); toolStripButtonNoteVsRest.Checked = true; // group = new ToolStripButton[] { toolStripButtonNoDot, toolStripButtonYesDot }; SetButton(toolStripButtonNoDot, Bitmaps1Class.gdiNoDotButtonBits, Bitmaps1Class.gdiNoDotButtonSelectedBits, group, null); SetButton(toolStripButtonYesDot, Bitmaps1Class.gdiYesDotButtonBits, Bitmaps1Class.gdiYesDotButtonSelectedBits, group, null); toolStripButtonNoDot.Checked = true; // group = new ToolStripButton[] { toolStripButtonDiv1, toolStripButtonDiv3, toolStripButtonDiv5, toolStripButtonDiv7 }; SetButton(toolStripButtonDiv1, Bitmaps1Class.gdiDiv1ButtonBits, Bitmaps1Class.gdiDiv1ButtonSelectedBits, group, null); SetButton(toolStripButtonDiv3, Bitmaps1Class.gdiDiv3ButtonBits, Bitmaps1Class.gdiDiv3ButtonSelectedBits, group, null); SetButton(toolStripButtonDiv5, Bitmaps1Class.gdiDiv5ButtonBits, Bitmaps1Class.gdiDiv5ButtonSelectedBits, group, null); SetButton(toolStripButtonDiv7, Bitmaps1Class.gdiDiv7ButtonBits, Bitmaps1Class.gdiDiv7ButtonSelectedBits, group, null); toolStripButtonDiv1.Checked = true; PrepareInlineEditingMenu(); trackViewControl.Focus(); }