Exemple #1
0
        private MainMenu CreateMainMenu(NoteView noteView)
        {
            var importPluginItems = PluginManager.ScoreBookImportPlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                if (!ConfirmDiscardChanges())
                {
                    return;
                }
                if (!TrySelectOpeningFile(p.FileFilter, out string path))
                {
                    return;
                }

                using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read))
                {
                    var args = new ScoreBookImportPluginArgs(stream);
                    HandleImport(p, args);
                }
            })).ToArray();

            var exportPluginItems = PluginManager.ScoreBookExportPlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                ExportAs(p);
            })).ToArray();

            var bookPropertiesMenuItem = new MenuItem(MainFormStrings.BookProperty, (s, e) =>
            {
                var vm     = new BookPropertiesWindowViewModel(ScoreBook, CurrentMusicSource);
                var window = new BookPropertiesWindow()
                {
                    DataContext = vm
                };
                window.ShowDialog(this);
            });

            var fileMenuItems = new MenuItem[]
            {
                new MenuItem(MainFormStrings.NewFile + "(&N)", (s, e) => ClearFile())
                {
                    Shortcut = Shortcut.CtrlN
                },
                new MenuItem(MainFormStrings.OpenFile + "(&O)", (s, e) => OpenFile())
                {
                    Shortcut = Shortcut.CtrlO
                },
                new MenuItem(MainFormStrings.SaveFile + "(&S)", (s, e) => SaveFile())
                {
                    Shortcut = Shortcut.CtrlS
                },
                new MenuItem(MainFormStrings.SaveAs + "(&A)", (s, e) => SaveAs())
                {
                    Shortcut = Shortcut.CtrlShiftS
                },
                new MenuItem("-"),
                new MenuItem(MainFormStrings.Import, importPluginItems)
                {
                    Enabled = importPluginItems.Length > 0
                },
                new MenuItem(MainFormStrings.Export, exportPluginItems)
                {
                    Enabled = exportPluginItems.Length > 0
                },
                new MenuItem("-"),
                bookPropertiesMenuItem,
                new MenuItem("-"),
                new MenuItem(MainFormStrings.Exit + "(&X)", (s, e) => this.Close())
            };

            var undoItem = new MenuItem(MainFormStrings.Undo, (s, e) => OperationManager.Undo())
            {
                Shortcut = Shortcut.CtrlZ,
                Enabled  = false
            };
            var redoItem = new MenuItem(MainFormStrings.Redo, (s, e) => OperationManager.Redo())
            {
                Shortcut = Shortcut.CtrlY,
                Enabled  = false
            };

            var cutItem          = new MenuItem(MainFormStrings.Cut, (s, e) => noteView.CutSelectedNotes(), Shortcut.CtrlX);
            var copyItem         = new MenuItem(MainFormStrings.Copy, (s, e) => noteView.CopySelectedNotes(), Shortcut.CtrlC);
            var pasteItem        = new MenuItem(MainFormStrings.Paste, (s, e) => noteView.PasteNotes(), Shortcut.CtrlV);
            var pasteFlippedItem = new MenuItem(MainFormStrings.PasteFlipped, (s, e) => noteView.PasteFlippedNotes(), Shortcut.CtrlShiftV);

            var selectAllItem          = new MenuItem(MainFormStrings.SelectAll, (s, e) => noteView.SelectAll(), Shortcut.CtrlA);
            var selectToEndItem        = new MenuItem(MainFormStrings.SelectToEnd, (s, e) => noteView.SelectToEnd());
            var selectoToBeginningItem = new MenuItem(MainFormStrings.SelectToBeginning, (s, e) => noteView.SelectToBeginning());

            var flipSelectedNotesItem   = new MenuItem(MainFormStrings.FlipSelectedNotes, (s, e) => noteView.FlipSelectedNotes());
            var removeSelectedNotesItem = new MenuItem(MainFormStrings.RemoveSelectedNotes, (s, e) => noteView.RemoveSelectedNotes(), Shortcut.Del);

            var removeEventsItem = new MenuItem(MainFormStrings.RemoveEvents, (s, e) =>
            {
                int minTick = noteView.SelectedRange.StartTick + (noteView.SelectedRange.Duration < 0 ? noteView.SelectedRange.Duration : 0);
                int maxTick = noteView.SelectedRange.StartTick + (noteView.SelectedRange.Duration < 0 ? 0 : noteView.SelectedRange.Duration);
                bool isContained(EventBase p) => p.Tick != 0 && minTick <= p.Tick && maxTick >= p.Tick;
                var events = ScoreBook.Score.Events;

                var bpmOp = events.BpmChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.BpmChangeEvents.Remove(p);
                    return(new RemoveEventOperation <BpmChangeEvent>(events.BpmChangeEvents, p));
                }).ToList();

                var speedOp = events.HighSpeedChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.HighSpeedChangeEvents.Remove(p);
                    return(new RemoveEventOperation <HighSpeedChangeEvent>(events.HighSpeedChangeEvents, p));
                }).ToList();

                var signatureOp = events.TimeSignatureChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.TimeSignatureChangeEvents.Remove(p);
                    return(new RemoveEventOperation <TimeSignatureChangeEvent>(events.TimeSignatureChangeEvents, p));
                }).ToList();

                OperationManager.Push(new CompositeOperation("イベント削除", bpmOp.Cast <IOperation>().Concat(speedOp).Concat(signatureOp)));
                noteView.Invalidate();
            });

            var insertAirWithAirActionItem = new MenuItem(MainFormStrings.InsertAirWithAirAction, (s, e) =>
            {
                var item     = s as MenuItem;
                item.Checked = !item.Checked;
                NoteView.InsertAirWithAirAction = item.Checked;
                ApplicationSettings.Default.InsertAirWithAirAction = item.Checked;
            })
            {
                Checked = ApplicationSettings.Default.InsertAirWithAirAction
            };

            var pluginItems = PluginManager.ScorePlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                CommitChanges();
                void updateScore(Score newScore)
                {
                    var op = new UpdateScoreOperation(ScoreBook.Score, newScore, score =>
                    {
                        ScoreBook.Score = score;
                        noteView.UpdateScore(score);
                    });
                    OperationManager.InvokeAndPush(op);
                }

                try
                {
                    p.Run(new ScorePluginArgs(() => ScoreBook.Score.Clone(), noteView.SelectedRange, updateScore));
                }
                catch (Exception ex)
                {
                    Program.DumpExceptionTo(ex, "plugin_exception.json");
                    MessageBox.Show(this, ErrorStrings.PluginException, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            })).ToArray();
            var pluginItem = new MenuItem(MainFormStrings.Plugin, pluginItems)
            {
                Enabled = pluginItems.Length > 0
            };

            var editMenuItems = new MenuItem[]
            {
                undoItem, redoItem, new MenuItem("-"),
                cutItem, copyItem, pasteItem, pasteFlippedItem, new MenuItem("-"),
                selectAllItem, selectToEndItem, selectoToBeginningItem, new MenuItem("-"),
                flipSelectedNotesItem, removeSelectedNotesItem, removeEventsItem, new MenuItem("-"),
                insertAirWithAirActionItem, new MenuItem("-"),
                pluginItem
            };

            var viewModeItem = new MenuItem(MainFormStrings.ScorePreview, (s, e) =>
            {
                IsPreviewMode         = !IsPreviewMode;
                ((MenuItem)s).Checked = IsPreviewMode;
            }, Shortcut.CtrlP);

            WidenLaneWidthMenuItem  = new MenuItem(MainFormStrings.WidenLaneWidth);
            NarrowLaneWidthMenuItem = new MenuItem(MainFormStrings.NarrowLaneWidth);

            WidenLaneWidthMenuItem.Click += (s, e) =>
            {
                noteView.UnitLaneWidth += 4;
                ApplicationSettings.Default.UnitLaneWidth = noteView.UnitLaneWidth;
                WidenLaneWidthMenuItem.Enabled            = CanWidenLaneWidth;
                NarrowLaneWidthMenuItem.Enabled           = CanNarrowLaneWidth;
            };
            NarrowLaneWidthMenuItem.Click += (s, e) =>
            {
                noteView.UnitLaneWidth -= 4;
                ApplicationSettings.Default.UnitLaneWidth = noteView.UnitLaneWidth;
                WidenLaneWidthMenuItem.Enabled            = CanWidenLaneWidth;
                NarrowLaneWidthMenuItem.Enabled           = CanNarrowLaneWidth;
            };

            var viewMenuItems = new MenuItem[] {
                viewModeItem,
                new MenuItem("-"),
                WidenLaneWidthMenuItem, NarrowLaneWidthMenuItem
            };

            void UpdateEvent <T>(List <T> list, T item) where T : EventBase
            {
                var prev = list.SingleOrDefault(p => p.Tick == item.Tick);

                var insertOp = new InsertEventOperation <T>(list, item);

                if (prev == null)
                {
                    OperationManager.InvokeAndPush(insertOp);
                }
                else
                {
                    var removeOp = new RemoveEventOperation <T>(list, prev);
                    OperationManager.InvokeAndPush(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }
                noteView.Invalidate();
            }

            var insertBpmItem = new MenuItem("BPM", (s, e) =>
            {
                var form = new BpmSelectionForm()
                {
                    Bpm = noteView.ScoreEvents.BpmChangeEvents.OrderBy(p => p.Tick).LastOrDefault(p => p.Tick <= noteView.CurrentTick)?.Bpm ?? 120
                };
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var item = new BpmChangeEvent()
                {
                    Tick = noteView.CurrentTick,
                    Bpm  = form.Bpm
                };
                UpdateEvent(noteView.ScoreEvents.BpmChangeEvents, item);
            });

            var insertHighSpeedItem = new MenuItem(MainFormStrings.HighSpeed, (s, e) =>
            {
                var form = new HighSpeedSelectionForm()
                {
                    SpeedRatio = noteView.ScoreEvents.HighSpeedChangeEvents.OrderBy(p => p.Tick).LastOrDefault(p => p.Tick <= noteView.CurrentTick)?.SpeedRatio ?? 1.0m
                };
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var item = new HighSpeedChangeEvent()
                {
                    Tick       = noteView.CurrentTick,
                    SpeedRatio = form.SpeedRatio
                };
                UpdateEvent(noteView.ScoreEvents.HighSpeedChangeEvents, item);
            });

            var insertTimeSignatureItem = new MenuItem(MainFormStrings.TimeSignature, (s, e) =>
            {
                var form = new TimeSignatureSelectionForm();
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var item = new TimeSignatureChangeEvent()
                {
                    Tick                = noteView.CurrentTick,
                    Numerator           = form.Numerator,
                    DenominatorExponent = form.DenominatorExponent
                };
                UpdateEvent(noteView.ScoreEvents.TimeSignatureChangeEvents, item);
            });

            var insertMenuItems = new MenuItem[] { insertBpmItem, insertHighSpeedItem, insertTimeSignatureItem };

            var isAbortAtLastNoteItem = new MenuItem(MainFormStrings.AbortAtLastNote, (s, e) =>
            {
                var item     = s as MenuItem;
                item.Checked = !item.Checked;
                PreviewManager.IsStopAtLastNote = item.Checked;
                ApplicationSettings.Default.IsPreviewAbortAtLastNote = item.Checked;
            })
            {
                Checked = ApplicationSettings.Default.IsPreviewAbortAtLastNote
            };

            var playItem = new MenuItem(MainFormStrings.Play, (s, e) =>
            {
                if (string.IsNullOrEmpty(CurrentMusicSource?.FilePath))
                {
                    MessageBox.Show(this, ErrorStrings.MusicSourceNull, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                if (!File.Exists(CurrentMusicSource.FilePath))
                {
                    MessageBox.Show(this, ErrorStrings.SourceFileNotFound, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                if (PreviewManager.Playing)
                {
                    PreviewManager.Stop();
                    return;
                }

                int startTick = noteView.CurrentTick;
                void lambda(object p, EventArgs q)
                {
                    isAbortAtLastNoteItem.Enabled = true;
                    PreviewManager.Finished      -= lambda;
                    noteView.CurrentTick          = startTick;
                    noteView.Editable             = CanEdit;
                }

                try
                {
                    CommitChanges();
                    var context = new SoundPreviewContext(ScoreBook.Score, CurrentMusicSource);
                    if (!PreviewManager.Start(context, startTick))
                    {
                        return;
                    }
                    isAbortAtLastNoteItem.Enabled = false;
                    PreviewManager.Finished      += lambda;
                    noteView.Editable             = CanEdit;
                }
                catch (Exception ex)
                {
                    Program.DumpExceptionTo(ex, "sound_exception.json");
                }
            }, (Shortcut)Keys.Space);

            var stopItem = new MenuItem(MainFormStrings.Stop, (s, e) =>
            {
                PreviewManager.Stop();
            });

            var playMenuItems = new MenuItem[]
            {
                playItem, stopItem, new MenuItem("-"),
                isAbortAtLastNoteItem
            };

            var helpMenuItems = new MenuItem[]
            {
                new MenuItem(MainFormStrings.Help, (s, e) => System.Diagnostics.Process.Start("https://github.com/paralleltree/Ched/wiki"), Shortcut.F1),
                new MenuItem(MainFormStrings.VersionInfo, (s, e) => new VersionInfoForm().ShowDialog(this))
            };

            OperationManager.OperationHistoryChanged += (s, e) =>
            {
                redoItem.Enabled = OperationManager.CanRedo;
                undoItem.Enabled = OperationManager.CanUndo;
            };

            return(new MainMenu(new MenuItem[]
            {
                new MenuItem(MainFormStrings.FileMenu, fileMenuItems),
                new MenuItem(MainFormStrings.EditMenu, editMenuItems),
                new MenuItem(MainFormStrings.ViewMenu, viewMenuItems),
                new MenuItem(MainFormStrings.InsertMenu, insertMenuItems),
                // PreviewManager初期化後じゃないといけないのダメ設計でしょ
                new MenuItem(MainFormStrings.PlayMenu, playMenuItems)
                {
                    Enabled = PreviewManager.IsSupported
                },
                new MenuItem(MainFormStrings.HelpMenu, helpMenuItems)
            }));
        }
Exemple #2
0
        private MainMenu CreateMainMenu(NoteView noteView)
        {
            var bookPropertiesMenuItem = new MenuItem("譜面プロパティ", (s, e) =>
            {
                var form = new BookPropertiesForm(ScoreBook, CurrentMusicSource);
                if (form.ShowDialog(this) == DialogResult.OK)
                {
                    CurrentMusicSource = form.MusicSource;
                    if (string.IsNullOrEmpty(ScoreBook.Path))
                    {
                        return;
                    }
                    SoundConfiguration.Default.ScoreSound[ScoreBook.Path] = CurrentMusicSource;
                    SoundConfiguration.Default.Save();
                }
            });

            var fileMenuItems = new MenuItem[]
            {
                new MenuItem("新規作成(&N)", (s, e) => ClearFile())
                {
                    Shortcut = Shortcut.CtrlN
                },
                new MenuItem("開く(&O)", (s, e) => OpenFile())
                {
                    Shortcut = Shortcut.CtrlO
                },
                new MenuItem("上書き保存(&S)", (s, e) => SaveFile())
                {
                    Shortcut = Shortcut.CtrlS
                },
                new MenuItem("名前を付けて保存(&A)", (s, e) => SaveAs())
                {
                    Shortcut = Shortcut.CtrlShiftS
                },
                new MenuItem("エクスポート", (s, e) => ExportFile()),
                new MenuItem("-"),
                bookPropertiesMenuItem,
                new MenuItem("-"),
                new MenuItem("終了(&X)", (s, e) => this.Close())
            };

            var undoItem = new MenuItem("元に戻す", (s, e) => noteView.Undo())
            {
                Shortcut = Shortcut.CtrlZ,
                Enabled  = false
            };
            var redoItem = new MenuItem("やり直し", (s, e) => noteView.Redo())
            {
                Shortcut = Shortcut.CtrlY,
                Enabled  = false
            };

            var cutItem          = new MenuItem("切り取り", (s, e) => noteView.CutSelectedNotes(), Shortcut.CtrlX);
            var copyItem         = new MenuItem("コピー", (s, e) => noteView.CopySelectedNotes(), Shortcut.CtrlC);
            var pasteItem        = new MenuItem("貼り付け", (s, e) => noteView.PasteNotes(), Shortcut.CtrlV);
            var pasteFlippedItem = new MenuItem("反転貼り付け", (s, e) => noteView.PasteFlippedNotes(), Shortcut.CtrlShiftV);

            var flipSelectedNotesItem   = new MenuItem("選択範囲内ノーツを反転", (s, e) => noteView.FlipSelectedNotes());
            var removeSelectedNotesItem = new MenuItem("選択範囲内ノーツを削除", (s, e) => noteView.RemoveSelectedNotes(), Shortcut.Del);

            var removeEventsItem = new MenuItem("選択範囲内イベントを削除", (s, e) =>
            {
                int minTick = noteView.SelectedRange.StartTick + (noteView.SelectedRange.Duration < 0 ? noteView.SelectedRange.Duration : 0);
                int maxTick = noteView.SelectedRange.StartTick + (noteView.SelectedRange.Duration < 0 ? 0 : noteView.SelectedRange.Duration);
                Func <EventBase, bool> isContained = p => p.Tick != 0 && minTick <= p.Tick && maxTick >= p.Tick;
                var events = ScoreBook.Score.Events;

                var bpmOp = events.BPMChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.BPMChangeEvents.Remove(p);
                    return(new RemoveEventOperation <BPMChangeEvent>(events.BPMChangeEvents, p));
                }).ToList();

                var speedOp = events.HighSpeedChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.HighSpeedChangeEvents.Remove(p);
                    return(new RemoveEventOperation <HighSpeedChangeEvent>(events.HighSpeedChangeEvents, p));
                }).ToList();

                var signatureOp = events.TimeSignatureChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.TimeSignatureChangeEvents.Remove(p);
                    return(new RemoveEventOperation <TimeSignatureChangeEvent>(events.TimeSignatureChangeEvents, p));
                }).ToList();

                OperationManager.Push(new CompositeOperation("イベント削除", bpmOp.Cast <IOperation>().Concat(speedOp).Concat(signatureOp)));
                noteView.Invalidate();
            });

            var pluginItems = PluginManager.ScorePlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                CommitChanges();

                try
                {
                    p.Run(ScoreBook.Score);
                }
                catch (Exception ex)
                {
                    Program.DumpExceptionTo(ex, "plugin_exception.json");
                    MessageBox.Show(this, "プラグインの実行中にエラーが発生しました。", Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            })).ToArray();
            var pluginItem = new MenuItem("プラグイン", pluginItems);

            var editMenuItems = new MenuItem[]
            {
                undoItem, redoItem, new MenuItem("-"),
                cutItem, copyItem, pasteItem, pasteFlippedItem, new MenuItem("-"),
                flipSelectedNotesItem, removeSelectedNotesItem, removeEventsItem, new MenuItem("-"),
                pluginItem
            };

            var viewModeItem = new MenuItem("譜面プレビュー", (s, e) =>
            {
                IsPreviewMode         = !IsPreviewMode;
                ((MenuItem)s).Checked = IsPreviewMode;
            }, Shortcut.CtrlP);

            var viewMenuItems = new MenuItem[] { viewModeItem };

            var insertBPMItem = new MenuItem("BPM", (s, e) =>
            {
                var form = new BPMSelectionForm();
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var prev = noteView.ScoreEvents.BPMChangeEvents.SingleOrDefault(p => p.Tick == noteView.SelectedRange.StartTick);
                var item = new Components.Events.BPMChangeEvent()
                {
                    Tick = noteView.SelectedRange.StartTick,
                    BPM  = form.BPM
                };

                var insertOp = new InsertEventOperation <Components.Events.BPMChangeEvent>(noteView.ScoreEvents.BPMChangeEvents, item);
                if (prev == null)
                {
                    OperationManager.Push(insertOp);
                }
                else
                {
                    var removeOp = new RemoveEventOperation <Components.Events.BPMChangeEvent>(noteView.ScoreEvents.BPMChangeEvents, prev);
                    noteView.ScoreEvents.BPMChangeEvents.Remove(prev);
                    OperationManager.Push(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }

                noteView.ScoreEvents.BPMChangeEvents.Add(item);
                noteView.Invalidate();
            });

            var insertHighSpeedItem = new MenuItem("ハイスピード", (s, e) =>
            {
                var form = new HighSpeedSelectionForm();
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var prev = noteView.ScoreEvents.HighSpeedChangeEvents.SingleOrDefault(p => p.Tick == noteView.SelectedRange.StartTick);
                var item = new Components.Events.HighSpeedChangeEvent()
                {
                    Tick       = noteView.SelectedRange.StartTick,
                    SpeedRatio = form.SpeedRatio
                };

                var insertOp = new InsertEventOperation <Components.Events.HighSpeedChangeEvent>(noteView.ScoreEvents.HighSpeedChangeEvents, item);
                if (prev == null)
                {
                    OperationManager.Push(insertOp);
                }
                else
                {
                    var removeOp = new RemoveEventOperation <Components.Events.HighSpeedChangeEvent>(noteView.ScoreEvents.HighSpeedChangeEvents, prev);
                    noteView.ScoreEvents.HighSpeedChangeEvents.Remove(prev);
                    OperationManager.Push(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }

                noteView.ScoreEvents.HighSpeedChangeEvents.Add(item);
                noteView.Invalidate();
            });

            var insertTimeSignatureItem = new MenuItem("拍子", (s, e) =>
            {
                var form = new TimeSignatureSelectionForm();
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var prev = noteView.ScoreEvents.TimeSignatureChangeEvents.SingleOrDefault(p => p.Tick == noteView.SelectedRange.StartTick);
                var item = new Components.Events.TimeSignatureChangeEvent()
                {
                    Tick                = noteView.SelectedRange.StartTick,
                    Numerator           = form.Numerator,
                    DenominatorExponent = form.DenominatorExponent
                };

                var insertOp = new InsertEventOperation <Components.Events.TimeSignatureChangeEvent>(noteView.ScoreEvents.TimeSignatureChangeEvents, item);
                if (prev != null)
                {
                    noteView.ScoreEvents.TimeSignatureChangeEvents.Remove(prev);
                    var removeOp = new RemoveEventOperation <Components.Events.TimeSignatureChangeEvent>(noteView.ScoreEvents.TimeSignatureChangeEvents, prev);
                    OperationManager.Push(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }
                else
                {
                    OperationManager.Push(insertOp);
                }

                noteView.ScoreEvents.TimeSignatureChangeEvents.Add(item);
                noteView.Invalidate();
            });

            var insertMenuItems = new MenuItem[] { insertBPMItem, insertHighSpeedItem, insertTimeSignatureItem };

            var isAbortAtLastNoteItem = new MenuItem("最終ノートで停止", (s, e) =>
            {
                var item     = s as MenuItem;
                item.Checked = !item.Checked;
                PreviewManager.IsStopAtLastNote           = item.Checked;
                Settings.Default.IsPreviewAbortAtLastNote = item.Checked;
            })
            {
                Checked = Settings.Default.IsPreviewAbortAtLastNote
            };

            var playItem = new MenuItem("再生/停止", (s, e) =>
            {
                if (CurrentMusicSource == null)
                {
                    MessageBox.Show(this, "譜面プロパティから音源ファイルを指定してください。", Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                if (!File.Exists(CurrentMusicSource.FilePath))
                {
                    MessageBox.Show(this, "音源ファイルが見つかりません。", Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                if (PreviewManager.Playing)
                {
                    PreviewManager.Stop();
                    return;
                }

                int startTick       = noteView.CurrentTick;
                EventHandler lambda = null;
                lambda = (p, q) =>
                {
                    isAbortAtLastNoteItem.Enabled = true;
                    PreviewManager.Finished      -= lambda;
                    noteView.CurrentTick          = startTick;
                };

                if (PreviewManager.Start(CurrentMusicSource, startTick))
                {
                    isAbortAtLastNoteItem.Enabled = false;
                    PreviewManager.Finished      += lambda;
                    noteView.Editable             = CanEdit;
                }
            }, (Shortcut)Keys.Space);

            var stopItem = new MenuItem("停止", (s, e) =>
            {
                PreviewManager.Stop();
            });

            var playMenuItems = new MenuItem[]
            {
                playItem, stopItem, new MenuItem("-"),
                isAbortAtLastNoteItem
            };

            var helpMenuItems = new MenuItem[]
            {
                new MenuItem("ヘルプを開く", (s, e) => System.Diagnostics.Process.Start("https://github.com/paralleltree/Ched/wiki"), Shortcut.F1),
                new MenuItem("バージョン情報", (s, e) => new VersionInfoForm().ShowDialog(this))
            };

            OperationManager.OperationHistoryChanged += (s, e) =>
            {
                redoItem.Enabled = noteView.CanRedo;
                undoItem.Enabled = noteView.CanUndo;
            };

            return(new MainMenu(new MenuItem[]
            {
                new MenuItem("ファイル(&F)", fileMenuItems),
                new MenuItem("編集(&E)", editMenuItems),
                new MenuItem("表示(&V)", viewMenuItems),
                new MenuItem("挿入(&I)", insertMenuItems),
                // PreviewManager初期化後じゃないといけないのダメ設計でしょ
                new MenuItem("再生(&P)", playMenuItems)
                {
                    Enabled = PreviewManager.IsSupported
                },
                new MenuItem("ヘルプ(&H)", helpMenuItems)
            }));
        }
Exemple #3
0
        private MainMenu CreateMainMenu(NoteView noteView)
        {
            var importPluginItems = PluginManager.ScoreBookImportPlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                OpenFile(p.FileFilter, q =>
                {
                    try
                    {
                        using (var reader = new StreamReader(q))
                            LoadBook(p.Import(reader));
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(this, ErrorStrings.ImportFailed, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        Program.DumpExceptionTo(ex, "import_exception.json");
                        LoadEmptyBook();
                    }
                });
            })).ToArray();

            var bookPropertiesMenuItem = new MenuItem(MainFormStrings.bookProperty, (s, e) =>
            {
                var form = new BookPropertiesForm(ScoreBook, CurrentMusicSource);
                if (form.ShowDialog(this) == DialogResult.OK)
                {
                    CurrentMusicSource = form.MusicSource;
                    if (string.IsNullOrEmpty(ScoreBook.Path))
                    {
                        return;
                    }
                    SoundSettings.Default.ScoreSound[ScoreBook.Path] = CurrentMusicSource;
                    SoundSettings.Default.Save();
                }
            });

            var fileMenuItems = new MenuItem[]
            {
                new MenuItem(MainFormStrings.NewFile + "(&N)", (s, e) => ClearFile())
                {
                    Shortcut = Shortcut.CtrlN
                },
                new MenuItem(MainFormStrings.OpenFile + "(&O)", (s, e) => OpenFile())
                {
                    Shortcut = Shortcut.CtrlO
                },
                new MenuItem(MainFormStrings.SaveFile + "(&S)", (s, e) => SaveFile())
                {
                    Shortcut = Shortcut.CtrlS
                },
                new MenuItem(MainFormStrings.SaveAs + "(&A)", (s, e) => SaveAs())
                {
                    Shortcut = Shortcut.CtrlShiftS
                },
                new MenuItem("-"),
                new MenuItem(MainFormStrings.Import, importPluginItems),
                new MenuItem(MainFormStrings.Export, (s, e) => ExportFile()),
                new MenuItem("-"),
                bookPropertiesMenuItem,
                new MenuItem("-"),
                new MenuItem(MainFormStrings.Exit + "(&X)", (s, e) => this.Close())
            };

            var undoItem = new MenuItem(MainFormStrings.Undo, (s, e) => noteView.Undo())
            {
                Shortcut = Shortcut.CtrlZ,
                Enabled  = false
            };
            var redoItem = new MenuItem(MainFormStrings.Redo, (s, e) => noteView.Redo())
            {
                Shortcut = Shortcut.CtrlY,
                Enabled  = false
            };

            var cutItem          = new MenuItem(MainFormStrings.Cut, (s, e) => noteView.CutSelectedNotes(), Shortcut.CtrlX);
            var copyItem         = new MenuItem(MainFormStrings.Copy, (s, e) => noteView.CopySelectedNotes(), Shortcut.CtrlC);
            var pasteItem        = new MenuItem(MainFormStrings.Paste, (s, e) => noteView.PasteNotes(), Shortcut.CtrlV);
            var pasteFlippedItem = new MenuItem(MainFormStrings.PasteFlipped, (s, e) => noteView.PasteFlippedNotes(), Shortcut.CtrlShiftV);

            var flipSelectedNotesItem   = new MenuItem(MainFormStrings.FlipSelectedNotes, (s, e) => noteView.FlipSelectedNotes());
            var removeSelectedNotesItem = new MenuItem(MainFormStrings.RemoveSelectedNotes, (s, e) => noteView.RemoveSelectedNotes(), Shortcut.Del);

            var removeEventsItem = new MenuItem(MainFormStrings.RemoveEvents, (s, e) =>
            {
                int minTick = noteView.SelectedRange.StartTick + (noteView.SelectedRange.Duration < 0 ? noteView.SelectedRange.Duration : 0);
                int maxTick = noteView.SelectedRange.StartTick + (noteView.SelectedRange.Duration < 0 ? 0 : noteView.SelectedRange.Duration);
                Func <EventBase, bool> isContained = p => p.Tick != 0 && minTick <= p.Tick && maxTick >= p.Tick;
                var events = ScoreBook.Score.Events;

                var bpmOp = events.BPMChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.BPMChangeEvents.Remove(p);
                    return(new RemoveEventOperation <BPMChangeEvent>(events.BPMChangeEvents, p));
                }).ToList();

                var speedOp = events.HighSpeedChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.HighSpeedChangeEvents.Remove(p);
                    return(new RemoveEventOperation <HighSpeedChangeEvent>(events.HighSpeedChangeEvents, p));
                }).ToList();

                var signatureOp = events.TimeSignatureChangeEvents.Where(p => isContained(p)).ToList().Select(p =>
                {
                    ScoreBook.Score.Events.TimeSignatureChangeEvents.Remove(p);
                    return(new RemoveEventOperation <TimeSignatureChangeEvent>(events.TimeSignatureChangeEvents, p));
                }).ToList();

                OperationManager.Push(new CompositeOperation("イベント削除", bpmOp.Cast <IOperation>().Concat(speedOp).Concat(signatureOp)));
                noteView.Invalidate();
            });

            var insertAirWithAirActionItem = new MenuItem(MainFormStrings.InsertAirWithAirAction, (s, e) =>
            {
                var item     = s as MenuItem;
                item.Checked = !item.Checked;
                NoteView.InsertAirWithAirAction = item.Checked;
                ApplicationSettings.Default.InsertAirWithAirAction = item.Checked;
            })
            {
                Checked = ApplicationSettings.Default.InsertAirWithAirAction
            };

            var pluginItems = PluginManager.ScorePlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                CommitChanges();
                Action <Score> updateScore = newScore =>
                {
                    var op = new UpdateScoreOperation(ScoreBook.Score, newScore, score =>
                    {
                        ScoreBook.Score = score;
                        noteView.UpdateScore(score);
                    });
                    OperationManager.Push(op);
                    op.Redo();
                };

                try
                {
                    p.Run(new ScorePluginArgs(() => ScoreBook.Score.Clone(), noteView.SelectedRange, updateScore));
                }
                catch (Exception ex)
                {
                    Program.DumpExceptionTo(ex, "plugin_exception.json");
                    MessageBox.Show(this, ErrorStrings.PluginException, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            })).ToArray();
            var pluginItem = new MenuItem(MainFormStrings.Plugin, pluginItems);

            var editMenuItems = new MenuItem[]
            {
                undoItem, redoItem, new MenuItem("-"),
                cutItem, copyItem, pasteItem, pasteFlippedItem, new MenuItem("-"),
                flipSelectedNotesItem, removeSelectedNotesItem, removeEventsItem, new MenuItem("-"),
                insertAirWithAirActionItem, new MenuItem("-"),
                pluginItem
            };

            var viewModeItem = new MenuItem(MainFormStrings.ScorePreview, (s, e) =>
            {
                IsPreviewMode         = !IsPreviewMode;
                ((MenuItem)s).Checked = IsPreviewMode;
            }, Shortcut.CtrlP);

            WidenLaneWidthMenuItem  = new MenuItem(MainFormStrings.WidenLaneWidth);
            NarrowLaneWidthMenuItem = new MenuItem(MainFormStrings.NarrowLaneWidth);

            WidenLaneWidthMenuItem.Click += (s, e) =>
            {
                noteView.UnitLaneWidth += 4;
                ApplicationSettings.Default.UnitLaneWidth = noteView.UnitLaneWidth;
                WidenLaneWidthMenuItem.Enabled            = CanWidenLaneWidth;
                NarrowLaneWidthMenuItem.Enabled           = CanNarrowLaneWidth;
            };
            NarrowLaneWidthMenuItem.Click += (s, e) =>
            {
                noteView.UnitLaneWidth -= 4;
                ApplicationSettings.Default.UnitLaneWidth = noteView.UnitLaneWidth;
                WidenLaneWidthMenuItem.Enabled            = CanWidenLaneWidth;
                NarrowLaneWidthMenuItem.Enabled           = CanNarrowLaneWidth;
            };

            var viewMenuItems = new MenuItem[] {
                viewModeItem,
                new MenuItem("-"),
                WidenLaneWidthMenuItem, NarrowLaneWidthMenuItem
            };

            var insertBPMItem = new MenuItem("BPM", (s, e) =>
            {
                var form = new BPMSelectionForm()
                {
                    BPM = noteView.ScoreEvents.BPMChangeEvents.OrderBy(p => p.Tick).LastOrDefault(p => p.Tick <= noteView.CurrentTick)?.BPM ?? 120m
                };
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var prev = noteView.ScoreEvents.BPMChangeEvents.SingleOrDefault(p => p.Tick == noteView.SelectedRange.StartTick);
                var item = new BPMChangeEvent()
                {
                    Tick = noteView.SelectedRange.StartTick,
                    BPM  = form.BPM
                };

                var insertOp = new InsertEventOperation <BPMChangeEvent>(noteView.ScoreEvents.BPMChangeEvents, item);
                if (prev == null)
                {
                    OperationManager.Push(insertOp);
                }
                else
                {
                    var removeOp = new RemoveEventOperation <BPMChangeEvent>(noteView.ScoreEvents.BPMChangeEvents, prev);
                    noteView.ScoreEvents.BPMChangeEvents.Remove(prev);
                    OperationManager.Push(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }

                noteView.ScoreEvents.BPMChangeEvents.Add(item);
                noteView.Invalidate();
            });

            var insertHighSpeedItem = new MenuItem(MainFormStrings.HighSpeed, (s, e) =>
            {
                var form = new HighSpeedSelectionForm()
                {
                    SpeedRatio = noteView.ScoreEvents.HighSpeedChangeEvents.OrderBy(p => p.Tick).LastOrDefault(p => p.Tick <= noteView.CurrentTick)?.SpeedRatio ?? 1.0m
                };
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var prev = noteView.ScoreEvents.HighSpeedChangeEvents.SingleOrDefault(p => p.Tick == noteView.SelectedRange.StartTick);
                var item = new HighSpeedChangeEvent()
                {
                    Tick       = noteView.SelectedRange.StartTick,
                    SpeedRatio = form.SpeedRatio
                };

                var insertOp = new InsertEventOperation <HighSpeedChangeEvent>(noteView.ScoreEvents.HighSpeedChangeEvents, item);
                if (prev == null)
                {
                    OperationManager.Push(insertOp);
                }
                else
                {
                    var removeOp = new RemoveEventOperation <HighSpeedChangeEvent>(noteView.ScoreEvents.HighSpeedChangeEvents, prev);
                    noteView.ScoreEvents.HighSpeedChangeEvents.Remove(prev);
                    OperationManager.Push(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }

                noteView.ScoreEvents.HighSpeedChangeEvents.Add(item);
                noteView.Invalidate();
            });

            var insertTimeSignatureItem = new MenuItem(MainFormStrings.TimeSignature, (s, e) =>
            {
                var form = new TimeSignatureSelectionForm();
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var prev = noteView.ScoreEvents.TimeSignatureChangeEvents.SingleOrDefault(p => p.Tick == noteView.SelectedRange.StartTick);
                var item = new TimeSignatureChangeEvent()
                {
                    Tick                = noteView.SelectedRange.StartTick,
                    Numerator           = form.Numerator,
                    DenominatorExponent = form.DenominatorExponent
                };

                var insertOp = new InsertEventOperation <TimeSignatureChangeEvent>(noteView.ScoreEvents.TimeSignatureChangeEvents, item);
                if (prev != null)
                {
                    noteView.ScoreEvents.TimeSignatureChangeEvents.Remove(prev);
                    var removeOp = new RemoveEventOperation <TimeSignatureChangeEvent>(noteView.ScoreEvents.TimeSignatureChangeEvents, prev);
                    OperationManager.Push(new CompositeOperation(insertOp.Description, new IOperation[] { removeOp, insertOp }));
                }
                else
                {
                    OperationManager.Push(insertOp);
                }

                noteView.ScoreEvents.TimeSignatureChangeEvents.Add(item);
                noteView.Invalidate();
            });

            var insertMenuItems = new MenuItem[] { insertBPMItem, insertHighSpeedItem, insertTimeSignatureItem };

            var isAbortAtLastNoteItem = new MenuItem(MainFormStrings.AbortAtLastNote, (s, e) =>
            {
                var item     = s as MenuItem;
                item.Checked = !item.Checked;
                PreviewManager.IsStopAtLastNote = item.Checked;
                ApplicationSettings.Default.IsPreviewAbortAtLastNote = item.Checked;
            })
            {
                Checked = ApplicationSettings.Default.IsPreviewAbortAtLastNote
            };

            var playItem = new MenuItem(MainFormStrings.Play, (s, e) =>
            {
                if (CurrentMusicSource == null)
                {
                    MessageBox.Show(this, ErrorStrings.MusicSourceNull, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                if (!File.Exists(CurrentMusicSource.FilePath))
                {
                    MessageBox.Show(this, ErrorStrings.SourceFileNotFound, Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                if (PreviewManager.Playing)
                {
                    PreviewManager.Stop();
                    return;
                }

                int startTick       = noteView.CurrentTick;
                EventHandler lambda = null;
                lambda = (p, q) =>
                {
                    isAbortAtLastNoteItem.Enabled = true;
                    PreviewManager.Finished      -= lambda;
                    noteView.CurrentTick          = startTick;
                };

                try
                {
                    if (!PreviewManager.Start(CurrentMusicSource, startTick))
                    {
                        return;
                    }
                    isAbortAtLastNoteItem.Enabled = false;
                    PreviewManager.Finished      += lambda;
                    noteView.Editable             = CanEdit;
                }
                catch (Exception ex)
                {
                    Program.DumpExceptionTo(ex, "sound_exception.json");
                }
            }, (Shortcut)Keys.Space);

            var stopItem = new MenuItem(MainFormStrings.Stop, (s, e) =>
            {
                PreviewManager.Stop();
            });

            var playMenuItems = new MenuItem[]
            {
                playItem, stopItem, new MenuItem("-"),
                isAbortAtLastNoteItem
            };

            var helpMenuItems = new MenuItem[]
            {
                new MenuItem(MainFormStrings.Help, (s, e) => System.Diagnostics.Process.Start("https://github.com/paralleltree/Ched/wiki"), Shortcut.F1),
                new MenuItem(MainFormStrings.VersionInfo, (s, e) => new VersionInfoForm().ShowDialog(this))
            };

            OperationManager.OperationHistoryChanged += (s, e) =>
            {
                redoItem.Enabled = noteView.CanRedo;
                undoItem.Enabled = noteView.CanUndo;
            };

            return(new MainMenu(new MenuItem[]
            {
                new MenuItem(MainFormStrings.FileMenu, fileMenuItems),
                new MenuItem(MainFormStrings.EditMenu, editMenuItems),
                new MenuItem(MainFormStrings.ViewMenu, viewMenuItems),
                new MenuItem(MainFormStrings.InsertMenu, insertMenuItems),
                // PreviewManager初期化後じゃないといけないのダメ設計でしょ
                new MenuItem(MainFormStrings.PlayMenu, playMenuItems)
                {
                    Enabled = PreviewManager.IsSupported
                },
                new MenuItem(MainFormStrings.HelpMenu, helpMenuItems)
            }));
        }
Exemple #4
0
        private MainMenu CreateMainMenu()
        {
            var bookPropertiesItem = new MenuItem("譜面プロパティ(&P)", (s, e) =>
            {
                var form = new BookPropertiesForm(ScoreBook, CurrentSoundSource);
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                ScoreBook.Title             = form.Title;
                ScoreBook.ArtistName        = form.ArtistName;
                ScoreBook.NotesDesignerName = form.NotesDesignerName;
                CurrentSoundSource          = form.SoundSource;
            });

            var exportPluginItems = PluginManager.ScoreBookExportPlugins.Select(p => new MenuItem(p.DisplayName, (s, e) =>
            {
                var dialog = new SaveFileDialog()
                {
                    Filter = p.Filter, Title = "エクスポート先選択"
                };
                if (dialog.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }
                var args = new ScoreBookExportPluginArgs(() => ScoreBook.Clone())
                {
                    OutputPath = dialog.FileName
                };
                ExportFile(new Exporter(p, args));
            }));

            var fileMenuItems = new MenuItem[]
            {
                new MenuItem("新規作成(&N)", (s, e) => Clear())
                {
                    Shortcut = Shortcut.CtrlN
                },
                new MenuItem("開く(&O)", (s, e) => OpenFile())
                {
                    Shortcut = Shortcut.CtrlO
                },
                new MenuItem("保存(&S)", (s, e) => SaveFile())
                {
                    Shortcut = Shortcut.CtrlS
                },
                new MenuItem("名前をつけて保存(&A)", (s, e) => SaveAs())
                {
                    Shortcut = Shortcut.CtrlShiftS
                },
                new MenuItem("-"),
                new MenuItem("エクスポート(&E)", exportPluginItems.ToArray()),
                new MenuItem("-"),
                bookPropertiesItem,
                new MenuItem("-"),
                new MenuItem("終了(&X)", (s, e) => Close())
            };

            var undoItem = new MenuItem("元に戻す", (s, e) => OperationManager.Undo())
            {
                Shortcut = Shortcut.CtrlZ,
                Enabled  = false
            };
            var redoItem = new MenuItem("やり直す", (s, e) => OperationManager.Redo())
            {
                Shortcut = Shortcut.CtrlY,
                Enabled  = false
            };

            var removeEventsItem = new MenuItem("選択範囲内イベントを削除", (s, e) =>
            {
                int head = NoteView.SelectedRange.StartTick + (NoteView.SelectedRange.Duration < 0 ? NoteView.SelectedRange.Duration : 0);
                int tail = NoteView.SelectedRange.StartTick + (NoteView.SelectedRange.Duration < 0 ? 0 : NoteView.SelectedRange.Duration);
                IEnumerable <IOperation> RemoveFilter <T>(List <T> list) where T: EventBase
                {
                    return(list.Where(p => p.Tick != 0 && p.Tick >= head && p.Tick <= tail).Select(p => new RemoveEventOperation <T>(p, list)));
                }

                var events = NoteView.Score.Events;
                var ops    = new[]
                {
                    RemoveFilter(events.BPMChangeEvents),
                    RemoveFilter(events.TimeSignatureChangeEvents),
                    RemoveFilter(events.HighSpeedChangeEvents)
                }.SelectMany(p => p);

                OperationManager.ExecuteAndPush(new CompositeOperation("イベント削除", ops.ToArray()));
            });

            var editMenuItems = new MenuItem[]
            {
                undoItem, redoItem,
                new MenuItem("-"),
                removeEventsItem
            };

            var previewItem = new MenuItem("譜面プレビュー", (s, e) =>
            {
                IsPreviewMode         = !IsPreviewMode;
                ((MenuItem)s).Checked = IsPreviewMode;
            }, Shortcut.CtrlP);

            var viewMenuItems = new MenuItem[]
            {
                previewItem
            };

            var addBpmItem = new MenuItem("BPM", (s, e) =>
            {
                var form = new BPMSelectionForm()
                {
                    BPM = NoteView.Score.Events.BPMChangeEvents.OrderBy(p => p.Tick).LastOrDefault(p => p.Tick <= NoteView.CurrentTick)?.BPM ?? 120m
                };
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var item = new BPMChangeEvent()
                {
                    Tick = NoteView.CurrentTick,
                    BPM  = form.BPM
                };

                IOperation op = ProcessAddEvent(item, NoteView.Score.Events.BPMChangeEvents);
                OperationManager.ExecuteAndPush(op);
                NoteView.Invalidate();
            });

            var addTimeSignatureItem = new MenuItem("拍子", (s, e) =>
            {
                var form = new TimesignatureSelectionForm();
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var item = new TimeSignatureChangeEvent()
                {
                    Tick                = NoteView.CurrentTick,
                    Numerator           = form.Numerator,
                    DenominatorExponent = form.DenominatorExponent
                };

                IOperation op = ProcessAddEvent(item, NoteView.Score.Events.TimeSignatureChangeEvents);
                OperationManager.ExecuteAndPush(op);
                NoteView.Invalidate();
            });

            var addHighSpeedItem = new MenuItem("ハイスピード", (s, e) =>
            {
                var form = new HighSpeedSelectionForm()
                {
                    SpeedRatio = NoteView.Score.Events.HighSpeedChangeEvents.OrderBy(p => p.Tick).LastOrDefault(p => p.Tick <= NoteView.CurrentTick)?.SpeedRatio ?? 1.0m
                };
                if (form.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                var item = new HighSpeedChangeEvent()
                {
                    Tick       = NoteView.CurrentTick,
                    SpeedRatio = form.SpeedRatio
                };

                IOperation op = ProcessAddEvent(item, NoteView.Score.Events.HighSpeedChangeEvents);
                OperationManager.ExecuteAndPush(op);
                NoteView.Invalidate();
            });

            IOperation ProcessAddEvent <T>(T item, List <T> list) where T : EventBase
            {
                var prev  = list.SingleOrDefault(p => p.Tick == item.Tick);
                var addOp = new AddEventOperation <T>(item, list);

                if (prev == null)
                {
                    return(addOp);
                }
                var removeOp = new RemoveEventOperation <T>(prev, list);

                return(new CompositeOperation(addOp.Description, new IOperation[] { removeOp, addOp }));
            }

            var insertMenuItems = new MenuItem[]
            {
                addBpmItem, addTimeSignatureItem, addHighSpeedItem
            };

            var previewOnlyNotesItem = new MenuItem("ベル/敵弾でガイド音を鳴らさない", (s, e) =>
            {
                var item     = s as MenuItem;
                item.Checked = !item.Checked;
                ApplicationSettings.Default.PreviewOnlyNotes = item.Checked;
            })
            {
                Checked = ApplicationSettings.Default.PreviewOnlyNotes
            };

            var playItem = new MenuItem("再生/停止", (s, e) =>
            {
                if (PreviewManager.Playing)
                {
                    PreviewManager.Stop();
                    return;
                }
                if (CurrentSoundSource == null)
                {
                    MessageBox.Show(this, "プレビュー用音源ファイルが設定されていません。", Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
                if (!File.Exists(CurrentSoundSource.FilePath))
                {
                    MessageBox.Show(this, "プレビュー用音源ファイルが見つかりません。", Program.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                int startTick       = NoteView.CurrentTick;
                EventHandler lambda = null;
                lambda = (p, q) =>
                {
                    previewOnlyNotesItem.Enabled = true;
                    PreviewManager.Finished     -= lambda;
                    NoteView.CurrentTick         = startTick;
                    NoteView.Editable            = CanEdit;
                };

                try
                {
                    var score = NoteView.Restore();
                    PreviewManager.TicksPerBeat = score.TicksPerBeat;
                    if (!PreviewManager.Start(score, CurrentSoundSource, startTick, ApplicationSettings.Default.PreviewOnlyNotes))
                    {
                        return;
                    }
                    previewOnlyNotesItem.Enabled = false;
                    PreviewManager.Finished     += lambda;
                    NoteView.Editable            = CanEdit;
                }
                catch (Exception ex)
                {
                    Program.DumpExceptionTo(ex, "sound_exception.json");
                    PreviewManager.Stop();
                }
            }, (Shortcut)Keys.Space);

            var playMenuItems = new MenuItem[]
            {
                playItem, new MenuItem("-"),
                previewOnlyNotesItem
            };

            var helpMenuItems = new MenuItem[]
            {
                new MenuItem("Wikiを開く", (s, e) => System.Diagnostics.Process.Start("https://github.com/paralleltree/Yuzu/wiki"), Shortcut.F1),
                new MenuItem("バージョン情報", (s, e) => new VersionInfoForm().ShowDialog(this))
            };

            OperationManager.OperationHistoryChanged += (s, e) =>
            {
                undoItem.Enabled = OperationManager.CanUndo;
                redoItem.Enabled = OperationManager.CanRedo;
            };

            return(new MainMenu(new MenuItem[]
            {
                new MenuItem("ファイル(&F)", fileMenuItems),
                new MenuItem("編集(&E)", editMenuItems),
                new MenuItem("表示(&V)", viewMenuItems),
                new MenuItem("挿入(&I)", insertMenuItems),
                new MenuItem("再生(&P)", playMenuItems),
                new MenuItem("ヘルプ(&H)", helpMenuItems)
            }));
        }