Пример #1
0
 private void PianoWindow_TrackMouseDown(object sender, VocalUtau.DirectUI.PianoMouseEventArgs e)
 {
     if (!_HandleEvents)
     {
         PitchDragingStatus = PitchDragingType.None;
         PitchStP1          = null;
         PitchTmpP0         = null;
         return;
     }
     if (_PitchToolsStatus == PitchDragingType.None)
     {
         return;
     }
     if (PitchDragingStatus != PitchDragingType.None)
     {
         return;
     }
     if (e.MouseEventArgs.Button != MouseButtons.Left)
     {
         return;
     }
     PitchStP1          = new PitchObject(e.Tick, e.PitchValue.PitchValue);
     PitchDragingStatus = _PitchToolsStatus;
     if (PitchActionBegin != null)
     {
         PitchActionBegin(PitchDragingStatus);
     }
 }
Пример #2
0
        private void PianoWindow_TrackMouseDown(object sender, VocalUtau.DirectUI.PianoMouseEventArgs e)
        {
            if (!_HandleEvents)
            {
                return;
            }
            if (e.MouseEventArgs.Button != MouseButtons.Left)
            {
                return;
            }

            if (CurrentNoteIndex != -1)
            {
                if (e.Tick > NoteList[CurrentNoteIndex].Tick + NoteList[CurrentNoteIndex].Length - 20)
                {
                    NoteDragingWork = NoteDragingType.NoteLength;
                }
                else
                {
                    NoteDragingWork = NoteDragingType.NoteMove;
                    NoteTempTick    = e.Tick - NoteList[CurrentNoteIndex].Tick;
                }
            }
            else
            {
                if (NoteToolsStatus == NoteToolsType.Add)
                {
                    NoteDragingWork = NoteDragingType.NoteAdd;
                    NoteDias.Clear();
                    BlockDia NoteDia = new BlockDia();
                    NoteDia.setStartPoint(e.Tick, e.PitchValue.NoteNumber);
                    NoteDia.setEndPoint(e.Tick, e.PitchValue.NoteNumber);
                    NoteDias.Add(NoteDia);
                }
                else if (NoteToolsStatus == NoteToolsType.Select)
                {
                    NoteDragingWork = NoteDragingType.AreaSelect;
                    BlockDia NoteDia = new BlockDia();
                    NoteDia.setStartPoint(e.Tick, e.PitchValue.NoteNumber);
                    NoteDia.setEndPoint(e.Tick, e.PitchValue.NoteNumber);
                    NoteDias.Add(NoteDia);
                }
            }
            if (NoteDragingWork != NoteDragingType.AreaSelect)
            {
                if (NoteActionBegin != null)
                {
                    if (NoteDragingWork == NoteDragingType.NoteMove)
                    {
                        NoteActionBegin(NoteDragingWork, true);
                    }
                    else
                    {
                        NoteActionBegin(NoteDragingWork);
                    }
                }
            }
        }
 private void d2DPainterBox1_MouseDoubleClick(object sender, MouseEventArgs e)
 {
     // if (DisableMouse) return;
     pme_cache = RiseMouseHandle(sender, e,
                                 RollMouseDoubleClick,
                                 TitleMouseDoubleClick,
                                 TrackMouseDoubleClick);
     this.OnMouseDoubleClick(e);
 }
 internal void CalcAxis(PianoProperties pprops, RollConfigures rconf, PianoMouseEventArgs cache)
 {
     if (cache != null && cache.MouseEventArgs.X == _me.X && cache.MouseEventArgs.Y == _me.Y)
     {
         _tick    = cache.Tick;
         _pitchvp = cache.PitchValue;
         _area    = cache.Area;
     }
     else
     {
         CalcAxis(pprops, rconf);
     }
 }
 private void d2DPainterBox1_MouseUp(object sender, MouseEventArgs e)
 {
     if (DisableMouse)
     {
         return;
     }
     if (isMUp)
     {
         return;
     }
     isMUp     = true;
     pme_cache = RiseMouseHandle(sender, e,
                                 RollMouseUp,
                                 TitleMouseUp,
                                 TrackMouseUp);
     this.OnMouseUp(e);
     isMUp = false;
 }
Пример #6
0
        private void PianoWindow_TrackMouseUp(object sender, VocalUtau.DirectUI.PianoMouseEventArgs e)
        {
            if (!_HandleEvents)
            {
                return;
            }
            if (PitchDragingStatus == PitchDragingType.None)
            {
                return;
            }
            PitchObject PitchEdP2 = new PitchObject(e.Tick, e.PitchValue.PitchValue);

            switch (PitchDragingStatus)
            {
            case PitchDragingType.DrawLine: PartsObject.PitchCompiler.ReplaceRealPitchLine(PitchMathUtils.CalcLineSilk(PitchStP1, PitchEdP2)); break;

            case PitchDragingType.DrawGraphJ: PartsObject.PitchCompiler.ReplaceRealPitchLine(PitchMathUtils.CalcGraphJ(PitchStP1, PitchEdP2)); break;

            case PitchDragingType.DrawGraphR: PartsObject.PitchCompiler.ReplaceRealPitchLine(PitchMathUtils.CalcGraphR(PitchStP1, PitchEdP2)); break;

            case PitchDragingType.DrawGraphS: PartsObject.PitchCompiler.ReplaceRealPitchLine(PitchMathUtils.CalcGraphS(PitchStP1, PitchEdP2)); break;

            case PitchDragingType.EarseArea:
                if (PitchStP1 != null && PitchTmpP0 != null)
                {
                    PitchView.BlockDia PitchDia = new PitchView.BlockDia();
                    PitchDia.setStartPoint(PitchStP1.Tick, PitchStP1.PitchValue.NoteNumber);
                    PitchDia.setEndPoint(PitchTmpP0.Tick, PitchTmpP0.PitchValue.NoteNumber);
                    earsePitchLine(PitchDia, _EarseModeV2);
                }
                break;
            }
            PitchDragingType EDStatus = PitchDragingStatus;

            PitchDragingStatus = PitchDragingType.None;
            PitchStP1          = null;
            PitchTmpP0         = null;
            if (PitchActionEnd != null)
            {
                PitchActionEnd(EDStatus);
            }
        }
        private PianoMouseEventArgs RiseMouseHandle(object sender, MouseEventArgs e, OnMouseEventHandler Roll, OnMouseEventHandler Title, OnMouseEventHandler Track)
        {
            PianoMouseEventArgs pme = new PianoMouseEventArgs(e);

            pme.CalcAxis(pprops, rconf, pme_cache);
            OnMouseEventHandler Handle = null;

            switch (pme.Area)
            {
            case PianoMouseEventArgs.AreaType.Roll: Handle = Roll; break;

            case PianoMouseEventArgs.AreaType.Title: Handle = Title; break;

            case PianoMouseEventArgs.AreaType.Track: Handle = Track; break;
            }
            if (Handle != null)
            {
                Handle(sender, pme);
            }
            return(pme);
        }
Пример #8
0
 private void PianoWindow_TrackMouseMove(object sender, VocalUtau.DirectUI.PianoMouseEventArgs e)
 {
     if (!_HandleEvents)
     {
         return;
     }
     if (PitchDragingStatus == PitchDragingType.None)
     {
         return;
     }
     if (e.Tick == PitchStP1.Tick)
     {
         return;
     }
     PitchTmpP0 = new PitchObject(e.Tick, e.PitchValue.PitchValue);
     if (_PitchToolsStatus == PitchDragingType.None)
     {
         PianoWindow.ParentForm.Cursor = Cursors.Arrow;
     }
     else
     {
         PianoWindow.ParentForm.Cursor = Cursors.Cross;
     }
 }
Пример #9
0
        private void PianoWindow_TrackMouseMove(object sender, VocalUtau.DirectUI.PianoMouseEventArgs e)
        {
            if (!_HandleEvents)
            {
                NoteDragingWork = NoteDragingType.None;
                NoteDias.Clear();
                return;
            }
            if (NoteDragingWork == NoteDragingType.AreaSelect)
            {
                NoteDias[0].setEndPoint(e.Tick, e.PitchValue.NoteNumber);
            }
            else if (NoteDragingWork == NoteDragingType.NoteAdd)
            {
                NoteDias[0].setEndPoint(e.Tick, e.PitchValue.NoteNumber);
                NoteDias[0].setStartPoint(NoteDias[0].TickStart == e.Tick ? NoteDias[0].TickEnd : NoteDias[0].TickStart, e.PitchValue.NoteNumber);
            }
            else if (NoteDragingWork == NoteDragingType.NoteMove)
            {
                long minTickChange = (long)PianoWindow.PianoProps.dertPixel2dertTick(AntiShakePixel);
                if (NoteSelectIndexs.IndexOf(CurrentNoteIndex) == -1)
                {
                    long NewTick = e.Tick - NoteTempTick;
                    NewTick = (long)(NewTick / _TickStepTick) * _TickStepTick;
                    long TickDert = NoteList[CurrentNoteIndex].Tick - NewTick;
                    if (NoteDias.Count == 0)
                    {
                        NoteDias.Add(new BlockDia());
                    }

                    if (Math.Abs(TickDert) <= minTickChange)
                    {
                        TickDert = 0;
                    }
                    long CurNewTick = NoteList[CurrentNoteIndex].Tick - TickDert;
                    NoteDias[0].setStartPoint(CurNewTick, e.PitchValue.NoteNumber);
                    NoteDias[0].setEndPoint(CurNewTick + NoteList[CurrentNoteIndex].Length, e.PitchValue.NoteNumber);
                }
                else
                {
                    long NewTick = e.Tick - NoteTempTick;
                    NewTick = (long)(NewTick / _TickStepTick) * _TickStepTick;
                    long TickDert = NoteList[CurrentNoteIndex].Tick - NewTick;
                    if (Math.Abs(TickDert) <= minTickChange)
                    {
                        TickDert = 0;
                    }
                    long NoteDert = NoteList[CurrentNoteIndex].PitchValue.NoteNumber - e.PitchValue.NoteNumber;
                    for (int i = 0; i < NoteSelectIndexs.Count; i++)
                    {
                        uint NewNoteNumber = (uint)(NoteList[NoteSelectIndexs[i]].PitchValue.NoteNumber - NoteDert);

                        if (NoteDias.Count < NoteSelectIndexs.Count)
                        {
                            NoteDias.Add(new BlockDia());
                        }

                        long CurNewTick = NoteList[NoteSelectIndexs[i]].Tick - TickDert;
                        NoteDias[i].setStartPoint(CurNewTick, NewNoteNumber);
                        NoteDias[i].setEndPoint(CurNewTick + NoteList[NoteSelectIndexs[i]].Length, NewNoteNumber);
                    }
                }
            }
            else if (NoteDragingWork == NoteDragingType.NoteLength)
            {
                long NewSize = e.Tick - NoteList[CurrentNoteIndex].Tick;
                NewSize = (long)(NewSize / _TickStepTick) * _TickStepTick;
                if (NewSize >= 32)
                {
                    if (NoteDias.Count == 0)
                    {
                        NoteDias.Add(new BlockDia());
                    }
                    NoteDias[0].setStartPoint(NoteList[CurrentNoteIndex].Tick, e.PitchValue.NoteNumber);
                    NoteDias[0].setEndPoint(NoteList[CurrentNoteIndex].Tick + NewSize, e.PitchValue.NoteNumber);
                }
            }
            else if (NoteDragingWork == NoteDragingType.None)
            {
                int  cnn = -1;
                long mt  = PianoWindow.MaxShownTick;
                long nt  = PianoWindow.MinShownTick;
                if (e.Tick >= nt && e.Tick <= mt)
                {
                    int Sfx = PartsObject.NoteCompiler.FindTickIndex(nt, 0, NoteList.Count);
                    for (int i = Sfx; i < NoteList.Count; i++)
                    {
                        PianoWindow.ParentForm.Cursor = Cursors.Arrow;
                        NoteObject PN = NoteList[i];
                        if (PN.Tick >= mt)
                        {
                            break;
                        }
                        if (PN.Tick + PN.Length < nt)
                        {
                            continue;
                        }
                        if (e.PitchValue.NoteNumber == PN.PitchValue.NoteNumber)
                        {
                            if (e.Tick >= PN.Tick && e.Tick <= PN.Tick + PN.Length)
                            {
                                Console.WriteLine("Mouse in Note " + PN.Lyric);
                                cnn = i;
                                if (e.Tick > PN.Tick + PN.Length - 20)
                                {
                                    PianoWindow.ParentForm.Cursor = Cursors.SizeWE;
                                }
                                else
                                {
                                    /*  bool isVBL = false;
                                     * if (PN.VerbPrecent > 0 && PN.VerbPrecent<1)
                                     * {
                                     *    long VBP = (long)(PN.Length * (1 - PN.VerbPrecent));
                                     *    if (e.Tick > PN.Tick + VBP - 5 && e.Tick < PN.Tick + VBP + 5)
                                     *    {
                                     *        isVBL = true;
                                     *    }
                                     * }
                                     * if (isVBL)
                                     * {
                                     *    PianoWindow.ParentForm.Cursor = Cursors.SizeWE;
                                     * }
                                     * else*/
                                    {
                                        PianoWindow.ParentForm.Cursor = Cursors.SizeAll;
                                    }
                                }
                                break;
                            }
                        }
                    }
                }
                CurrentNoteIndex = cnn;
            }
        }
Пример #10
0
        private void PianoWindow_TrackMouseUp(object sender, VocalUtau.DirectUI.PianoMouseEventArgs e)
        {
            if (!_HandleEvents)
            {
                return;
            }
            bool NotMove = false;

            if (NoteDragingWork != NoteDragingType.None)
            {
                if (NoteDragingWork == NoteDragingType.NoteLength)
                {
                    long NewSize = e.Tick - NoteList[CurrentNoteIndex].Tick;
                    NewSize = (long)(NewSize / _TickStepTick) * _TickStepTick;
                    if (NewSize >= 32)
                    {
                        NoteList[CurrentNoteIndex].Length = NewSize;
                        int StartPX = Math.Max(0, CurrentNoteIndex);
                        int EndPX   = Math.Min(NoteList.Count - 1, CurrentNoteIndex + 1);
                        PartsObject.PitchCompiler.SetupBasePitch_Aysnc(new Formats.Model.VocalObject.ParamTranslater.PitchCompiler.AsyncWorkCallbackHandler((F, L) =>
                        {
                            this.PianoWindow.Invoke(new Action(() => { this.PianoWindow.RedrawPiano(); }));
                        }), StartPX, EndPX);
                        if (this.SingerDataFinder != null)
                        {
                            PartsObject po = PartsObject;
                            this.SingerDataFinder.GetPhonemesDictionary(PartsObject).UpdateLyrics_Aysnc(new Formats.Model.Database.VocalDatabase.SplitDictionary.AsyncWorkCallbackHandler((P, F, L) =>
                            {
                            }), ref po, CurrentNoteIndex, CurrentNoteIndex);;
                        }
                    }
                    NoteDias.Clear();
                }
                else if (NoteDragingWork == NoteDragingType.NoteMove)
                {
                    long minTickChange = (long)PianoWindow.PianoProps.dertPixel2dertTick(AntiShakePixel);
                    List <NoteObject> SelectingNoteCache = new List <NoteObject>();
                    for (int i = 0; i < NoteSelectIndexs.Count; i++)
                    {
                        SelectingNoteCache.Add(PartsObject.NoteList[NoteSelectIndexs[i]]);
                    }
                    bool TickChanged = false;

                    if (NoteSelectIndexs.IndexOf(CurrentNoteIndex) == -1)
                    {
                        long NewTick = e.Tick - NoteTempTick;
                        NewTick = (long)(NewTick / _TickStepTick) * _TickStepTick;
                        long TickDert = NoteList[CurrentNoteIndex].Tick - NewTick;
                        long NoteDert = NoteList[CurrentNoteIndex].PitchValue.NoteNumber - e.PitchValue.NoteNumber;

                        if (NoteList[CurrentNoteIndex].PitchValue.NoteNumber != e.PitchValue.NoteNumber)
                        {
                            NoteList[CurrentNoteIndex].PitchValue = new PitchAtomObject(e.PitchValue.NoteNumber, NoteList[CurrentNoteIndex].PitchValue.PitchWheel);
                        }
                        TickChanged = Math.Abs(TickDert) >= minTickChange;
                        NotMove     = (NoteDert == 0 && Math.Abs(TickDert) < minTickChange);

                        NoteObject OldNoteSt    = NoteList[CurrentNoteIndex];
                        long       oldStartTick = OldNoteSt.Tick;
                        long       oldEndTick   = OldNoteSt.Tick + OldNoteSt.Length;
                        if (Math.Abs(TickDert) > minTickChange)
                        {
                            NoteList[CurrentNoteIndex].Tick = NoteList[CurrentNoteIndex].Tick - TickDert;
                            NoteList.Sort();
                        }
                        long AStartTick = Math.Min(oldStartTick, OldNoteSt.Tick);
                        long AEndTick   = Math.Max(oldEndTick, OldNoteSt.Tick + OldNoteSt.Length);

                        int ONI = NoteList.IndexOf(OldNoteSt);
                        if (!NotMove)
                        {
                            int StartPX = ONI;
                            int EndPX   = ONI;

                            List <NoteObject> PO = PartsObject.NoteList;

                            int FSIdx = PartsObject.NoteCompiler.FindTickIndex(AStartTick, 0, PO.Count);
                            int FEIdx = PartsObject.NoteCompiler.FindTickIndex(AEndTick, FSIdx, PO.Count);
                            StartPX = Math.Min(StartPX, FSIdx);
                            EndPX   = Math.Max(EndPX, FEIdx);
                            StartPX = Math.Max(0, StartPX);
                            EndPX   = Math.Min(NoteList.Count - 1, EndPX);

                            PartsObject.PitchCompiler.SetupBasePitch_Aysnc(new Formats.Model.VocalObject.ParamTranslater.PitchCompiler.AsyncWorkCallbackHandler((F, L) =>
                            {
                                this.PianoWindow.Invoke(new Action(() => { this.PianoWindow.RedrawPiano(); }));
                            }), StartPX, EndPX);

                            if (this.SingerDataFinder != null)
                            {
                                PartsObject po = PartsObject;
                                this.SingerDataFinder.GetPhonemesDictionary(PartsObject).UpdateLyrics_Aysnc(new Formats.Model.Database.VocalDatabase.SplitDictionary.AsyncWorkCallbackHandler((P, F, L) =>
                                {
                                }), ref po, ONI, ONI);;
                            }
                        }
                    }
                    else
                    {
                        long NewTick = e.Tick - NoteTempTick;
                        NewTick = (long)(NewTick / _TickStepTick) * _TickStepTick;
                        long TickDert = NoteList[CurrentNoteIndex].Tick - NewTick;
                        long NoteDert = NoteList[CurrentNoteIndex].PitchValue.NoteNumber - e.PitchValue.NoteNumber;
                        NotMove     = (NoteDert == 0 && Math.Abs(TickDert) < minTickChange);
                        TickChanged = Math.Abs(TickDert) >= minTickChange;

                        NoteObject OldNoteSt  = NoteList[NoteSelectIndexs[0]];
                        NoteObject LastNoteEd = NoteList[NoteSelectIndexs[NoteSelectIndexs.Count - 1]];

                        long oldStartTick = OldNoteSt.Tick;
                        long oldEndTick   = LastNoteEd.Tick + LastNoteEd.Length;


                        for (int i = 0; i < SelectingNoteCache.Count; i++)
                        {
                            uint NewNoteNumber = (uint)(SelectingNoteCache[i].PitchValue.NoteNumber - NoteDert);
                            if (SelectingNoteCache[i].PitchValue.NoteNumber != NewNoteNumber)
                            {
                                SelectingNoteCache[i].PitchValue = new PitchAtomObject(NewNoteNumber, SelectingNoteCache[i].PitchValue.PitchWheel);
                            }
                            if (Math.Abs(TickDert) > minTickChange)
                            {
                                SelectingNoteCache[i].Tick = SelectingNoteCache[i].Tick - TickDert;
                            }
                        }
                        if (Math.Abs(TickDert) > minTickChange)
                        {
                            NoteList.Sort();
                        }
                        long AStartTick = Math.Min(oldStartTick, OldNoteSt.Tick);
                        long AEndTick   = Math.Max(oldEndTick, LastNoteEd.Tick + LastNoteEd.Length);

                        int First = Math.Min(NoteList.IndexOf(SelectingNoteCache[0]), NoteList.IndexOf(OldNoteSt));
                        int Last  = Math.Max(NoteList.IndexOf(SelectingNoteCache[SelectingNoteCache.Count - 1]), NoteList.IndexOf(LastNoteEd));
                        if (First <= Last)
                        {
                            if (!NotMove)
                            {
                                int StartPX = First;
                                int EndPX   = Last;

                                int FSIdx = PartsObject.NoteCompiler.FindTickIndex(AStartTick, 0, PartsObject.NoteList.Count);
                                int FEIdx = PartsObject.NoteCompiler.FindTickIndex(AEndTick, FSIdx, PartsObject.NoteList.Count) + 1;
                                StartPX = Math.Min(StartPX, FSIdx);
                                EndPX   = Math.Max(EndPX, FEIdx);
                                StartPX = Math.Max(0, StartPX);
                                EndPX   = Math.Min(NoteList.Count - 1, EndPX);

                                PartsObject.PitchCompiler.SetupBasePitch_Aysnc(new Formats.Model.VocalObject.ParamTranslater.PitchCompiler.AsyncWorkCallbackHandler((F, L) =>
                                {
                                    this.PianoWindow.Invoke(new Action(() => { this.PianoWindow.RedrawPiano(); }));
                                }), StartPX, EndPX);

                                if (this.SingerDataFinder != null)
                                {
                                    PartsObject po = PartsObject;
                                    this.SingerDataFinder.GetPhonemesDictionary(PartsObject).UpdateOutboundsLyric_Aysnc(new Formats.Model.Database.VocalDatabase.SplitDictionary.AsyncWorkCallbackHandler((P, F, L) =>
                                    {
                                    }), ref po, StartPX, EndPX);;
                                }
                            }
                        }
                    }
                    if (TickChanged)
                    {
                        NoteSelectIndexs.Clear();
                        for (int i = 0; i < SelectingNoteCache.Count; i++)
                        {
                            NoteSelectIndexs.Add(PartsObject.NoteList.IndexOf(SelectingNoteCache[i]));
                        }
                    }
                    NoteDias.Clear();
                }
                else if (NoteDragingWork == NoteDragingType.NoteAdd)
                {
                    NoteObject nPN = new NoteObject(NoteDias[0].TickStart, NoteDias[0].TickEnd - NoteDias[0].TickStart, NoteDias[0].TopNoteNum);
                    if (nPN.Length >= 32)
                    {
                        nPN.InitNote();
                        NoteList.Add(nPN);
                        NoteList.Sort();
                        NoteDias.Clear();
                        int NIndex = NoteList.IndexOf(nPN);
                        PartsObject.PitchCompiler.SetupBasePitch_Aysnc(new Formats.Model.VocalObject.ParamTranslater.PitchCompiler.AsyncWorkCallbackHandler((F, L) =>
                        {
                            this.PianoWindow.Invoke(new Action(() => { this.PianoWindow.RedrawPiano(); }));
                        }), NIndex, NIndex);
                        if (this.SingerDataFinder != null)
                        {
                            PartsObject po = PartsObject;
                            this.SingerDataFinder.GetPhonemesDictionary(PartsObject).UpdateLyrics_Aysnc(new Formats.Model.Database.VocalDatabase.SplitDictionary.AsyncWorkCallbackHandler((P, F, L) =>
                            {
                            }), ref po, NIndex, NIndex);;
                        }
                    }
                    else
                    {
                        NoteDragingWork = NoteDragingType.AreaSelect;
                    }
                }
                else if (NoteDragingWork == NoteDragingType.AreaSelect)
                {
                    ClearSelect();
                    long mt = NoteDias[0].TickEnd;
                    long nt = NoteDias[0].TickStart;
                    if (e.Tick >= nt && e.Tick <= mt)
                    {
                        int Sfx = PartsObject.NoteCompiler.FindTickIndex(nt, 0, NoteList.Count);
                        for (int i = Sfx; i < NoteList.Count; i++)
                        {
                            NoteObject PN = NoteList[i];
                            if (PN.Tick >= mt)
                            {
                                break;
                            }
                            if (PN.Tick + PN.Length < nt)
                            {
                                continue;
                            }
                            if (PN.PitchValue.NoteNumber >= NoteDias[0].BottomNoteNum && PN.PitchValue.NoteNumber <= NoteDias[0].TopNoteNum)
                            {
                                NoteSelectIndexs.Add(i);
                            }
                        }
                    }
                    if (NoteSelectListChange != null)
                    {
                        NoteSelectListChange(NoteSelectIndexs);
                    }
                    NoteDias.Clear();
                }
                if (NoteDragingWork != NoteDragingType.AreaSelect && NoteActionEnd != null)
                {
                    if (NotMove)
                    {
                        NoteActionEnd(NoteDragingWork, true);
                    }
                    else
                    {
                        NoteActionEnd(NoteDragingWork);
                    }
                }
            }
            NoteDragingWork = NoteDragingType.None;
        }
        private void d2DPainterBox1_MouseMove(object sender, MouseEventArgs e)
        {
            if (DisableMouse)
            {
                return;
            }
            if (isMMoving)
            {
                return;
            }
            isMMoving = true;
            d2DPainterBox1.Refresh();

            PianoMouseEventArgs pme = new PianoMouseEventArgs(e);

            pme.CalcAxis(pprops, rconf, pme_cache);
            OnMouseEventHandler Handle      = null; //Move事件
            EventHandler        HandleEnter = null; //Enter事件
            EventHandler        HandleLeave = null; //Leave事件

            switch (pme.Area)
            {
            case PianoMouseEventArgs.AreaType.Roll: Handle = RollMouseMove; HandleEnter = RollMouseEnter; break;

            case PianoMouseEventArgs.AreaType.Title: Handle = TitleMouseMove; HandleEnter = TitleMouseEnter; break;

            case PianoMouseEventArgs.AreaType.Track: Handle = TrackMouseMove; HandleEnter = TrackMouseEnter; break;
            }
            if (pme_sendEnterEvent)
            {
                if (HandleEnter != null)
                {
                    HandleEnter(sender, e);
                }
            }
            else if (pme_cache.Area != pme.Area)
            {
                switch (pme_cache.Area)
                {
                case PianoMouseEventArgs.AreaType.Roll: HandleLeave = RollMouseLeave; break;

                case PianoMouseEventArgs.AreaType.Title: HandleLeave = TitleMouseLeave; break;

                case PianoMouseEventArgs.AreaType.Track: HandleLeave = TrackMouseLeave; break;
                }
                if (HandleEnter != null)
                {
                    HandleEnter(sender, e);
                }
                if (HandleLeave != null)
                {
                    HandleLeave(sender, e);
                }
            }
            if (Handle != null)
            {
                Handle(sender, pme);                //发送Move
            }
            pme_cache          = pme;
            pme_sendEnterEvent = false;
            this.OnMouseMove(e);
            isMMoving = false;
        }