Пример #1
0
 protected void LoadBook(ScoreBook book)
 {
     ScoreBook = book;
     NoteView.LoadScore(book.Score);
     NoteViewScrollBar.Value   = NoteViewScrollBar.GetMaximumValue();
     NoteViewScrollBar.Minimum = -Math.Max(NoteView.UnitBeatTick * 4 * 20, NoteView.Notes.GetLastTick());
     UpdateThumbHeight();
     SetText(book.Path);
     LastExportData = null;
     if (!string.IsNullOrEmpty(book.Path))
     {
         SoundConfiguration.Default.ScoreSound.TryGetValue(book.Path, out CurrentMusicSource);
     }
     else
     {
         CurrentMusicSource = null;
     }
 }
Пример #2
0
 protected void LoadBook(ScoreBook book)
 {
     ScoreBook = book;
     OperationManager.Clear();
     NoteView.Initialize(book.Score);
     NoteViewScrollBar.Value       = NoteViewScrollBar.GetMaximumValue();
     NoteViewScrollBar.Minimum     = -Math.Max(NoteView.UnitBeatTick * 4 * 20, NoteView.Notes.GetLastTick());
     NoteViewScrollBar.SmallChange = NoteView.UnitBeatTick;
     UpdateThumbHeight();
     SetText(book.Path);
     LastExportData = null;
     if (!string.IsNullOrEmpty(book.Path))
     {
         SoundSettings.Default.ScoreSound.TryGetValue(book.Path, out CurrentMusicSource);
     }
     else
     {
         CurrentMusicSource = null;
     }
 }
Пример #3
0
        public BookPropertiesForm(ScoreBook book, SoundSource musicSource)
        {
            InitializeComponent();
            AcceptButton              = buttonOK;
            CancelButton              = buttonCancel;
            buttonOK.DialogResult     = DialogResult.OK;
            buttonCancel.DialogResult = DialogResult.Cancel;

            titleBox.Text         = book.Title;
            artistBox.Text        = book.ArtistName;
            notesDesignerBox.Text = book.NotesDesignerName;
            if (musicSource != null)
            {
                musicSourceSelector.Value = musicSource;
            }

            buttonOK.Click += (s, e) =>
            {
                book.Title             = titleBox.Text;
                book.ArtistName        = artistBox.Text;
                book.NotesDesignerName = notesDesignerBox.Text;
                Close();
            };
        }
Пример #4
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)
            }));
        }
Пример #5
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)
            }));
        }
Пример #6
0
        public bool Start(SoundSource music, int startTick)
        {
            if (Playing)
            {
                throw new InvalidOperationException();
            }
            if (music == null)
            {
                throw new ArgumentNullException("music");
            }
            SoundManager.Register(ClapSource.FilePath);
            SoundManager.Register(music.FilePath);
            EndTick = IsStopAtLastNote ? NoteView.Notes.GetLastTick() : GetTickFromTime(SoundManager.GetDuration(music.FilePath), NoteView.ScoreEvents.BPMChangeEvents);
            if (EndTick < startTick)
            {
                return(false);
            }

            var tickSet        = new HashSet <int>();
            var notes          = NoteView.Notes;
            var shortNotesTick = notes.Taps.Cast <TappableBase>().Concat(notes.ExTaps).Concat(notes.Flicks).Concat(notes.Damages).Select(p => p.Tick);
            var holdsTick      = notes.Holds.SelectMany(p => new int[] { p.StartTick, p.StartTick + p.Duration });
            var slidesTick     = notes.Slides.SelectMany(p => new int[] { p.StartTick }.Concat(p.StepNotes.Where(q => q.IsVisible).Select(q => q.Tick)));
            var airActionsTick = notes.AirActions.SelectMany(p => p.ActionNotes.Select(q => p.StartTick + q.Offset));

            foreach (int tick in shortNotesTick.Concat(holdsTick).Concat(slidesTick).Concat(airActionsTick))
            {
                tickSet.Add(tick);
            }
            TickElement = new LinkedList <int?>(tickSet.Where(p => p >= startTick).OrderBy(p => p).Select(p => new int?(p))).First;

            BPMElement = new LinkedList <BPMChangeEvent>(NoteView.ScoreEvents.BPMChangeEvents.OrderBy(p => p.Tick)).First;

            // スタート時まで進める
            while (TickElement != null && TickElement.Value < startTick)
            {
                TickElement = TickElement.Next;
            }
            while (BPMElement.Next != null && BPMElement.Next.Value.Tick <= startTick)
            {
                BPMElement = BPMElement.Next;
            }

            int clapLatencyTick = GetLatencyTick(ClapSource.Latency, (double)BPMElement.Value.BPM);

            InitialTick = startTick - clapLatencyTick;
            CurrentTick = InitialTick;
            StartTick   = startTick;

            TimeSpan startTime = GetTimeFromTick(startTick, NoteView.ScoreEvents.BPMChangeEvents);
            TimeSpan headGap   = TimeSpan.FromSeconds(-music.Latency) - startTime;

            elapsedTick = 0;
            Task.Run(() =>
            {
                LastSystemTick = Environment.TickCount;
                NoteView.Invoke((MethodInvoker)(() => Timer.Start()));

                System.Threading.Thread.Sleep(TimeSpan.FromSeconds(Math.Max(ClapSource.Latency, 0)));
                if (headGap.TotalSeconds > 0)
                {
                    System.Threading.Thread.Sleep(headGap);
                }
                if (!Playing)
                {
                    return;
                }
                SoundManager.Play(music.FilePath, startTime + TimeSpan.FromSeconds(music.Latency));
            })
            .ContinueWith(p =>
            {
                if (p.Exception != null)
                {
                    Program.DumpExceptionTo(p.Exception, "sound_exception.json");
                    ExceptionThrown?.Invoke(this, EventArgs.Empty);
                }
            });

            Playing = true;
            return(true);
        }
Пример #7
0
 public bool Start(SoundSource music)
 {
     return(Start(music, 0)); // 再生位置計算めんどいので最初から
 }
Пример #8
0
 public SoundPreviewManager(NoteView noteView)
 {
     ClapSource  = new SoundSource("guide.mp3", 0.036);
     NoteView    = noteView;
     Timer.Tick += Tick;
 }
Пример #9
0
 public SoundPreviewContext(Core.Score score, SoundSource musicSource)
 {
     this.score  = score;
     MusicSource = musicSource;
 }