Beispiel #1
0
        /// <summary>
        /// Validates and handles break drag changes.
        /// </summary>
        /// <param name="dragBreakEnd">Determines whether breakEnd or breakStart is being dragged.</param>
        /// <param name="newTime">The new time to apply to the current break end (or start)</param>
        /// <returns>Whether break has been changed or removed.</returns>
        internal bool UpdateBreakDrag(EventBreak b, bool dragBreakEnd, int newTime)
        {
            if (!BreakDirty || b == null)
            {
                return(false);
            }

            int actualStart, actualEnd;

            BreakDirty = false;
            if (dragBreakEnd)
            {
                int newEnd = newTime;
                int oldEnd = b.EndTime;

                if (newEnd == oldEnd)
                {
                    return(false);
                }

                if (newEnd < oldEnd) //Break is being dragged to the left
                {
                    if (FindActualEnds(b, out actualStart, out actualEnd))
                    {
                        int preEmptStart = actualStart + EventBreak.PREEMPT_START;

                        newEnd = Math.Max(newEnd, preEmptStart + EventBreak.PREFERRED_BREAK_LENGTH);

                        //Value exceeds allowed custom break distance.
                        if (newEnd < MaxBreakDragDistance)
                        {
                            return(false);
                        }

                        b.SetEndTime(newEnd);
                    }
                    else //This should never happen
                    {
                        RemoveBreak(b);
                        return(true);
                    }
                }
                else
                {
                    //We cannot drag past the preempt point
                    if (!b.CustomEnd)
                    {
                        return(false);
                    }

                    if (FindActualEnds(b, out actualStart, out actualEnd))
                    {
                        int preEmptEnd = actualEnd - hitObjectManager.PreEmpt;

                        newEnd = Math.Min(newEnd, preEmptEnd);
                        b.SetEndTime(newEnd);
                    }
                    else //This should never happen
                    {
                        RemoveBreak(b);
                        return(true);
                    }
                }
            }
            else
            {
                int oldStart = b.StartTime;
                int newStart = newTime;

                if (newStart == oldStart)
                {
                    return(false);
                }

                if (newStart < oldStart)
                {
                    //We cannot drag past the preempt point
                    if (!b.CustomStart)
                    {
                        return(false);
                    }

                    if (FindActualEnds(b, out actualStart, out actualEnd))
                    {
                        int preEmptStart = actualStart + EventBreak.PREEMPT_START;

                        newStart = Math.Max(newStart, preEmptStart);
                        b.SetStartTime(newStart);
                    }
                    else //This should never happen
                    {
                        RemoveBreak(b);
                        return(true);
                    }
                }
                else
                {
                    if (FindActualEnds(b, out actualStart, out actualEnd))
                    {
                        int preEmptEnd = actualEnd - hitObjectManager.PreEmpt;

                        newStart = Math.Min(newStart, preEmptEnd - EventBreak.PREFERRED_BREAK_LENGTH);

                        //Value exceeds allowed custom break distance.
                        if (newStart > MaxBreakDragDistance)
                        {
                            return(false);
                        }

                        b.SetStartTime(newStart);
                    }
                    else //This should never happen
                    {
                        RemoveBreak(b);
                        return(true);
                    }
                }
            }

            b.Update(!dragBreakEnd, true, true, false);
            return(true);
        }