private void owner_Paint(object sender, PaintEventArgs e) { // Test if anything is visible. m_visibleManipulator = TimelineControl.CalculateRange(Owner.EditableSelection, out m_worldMin, out m_worldMax); if (!m_visibleManipulator) { return; } Graphics g = e.Graphics; Matrix worldToView = Owner.Transform; // Make the TimelineRenderer draw the ghosts, if necessary. Must happen before // the manipulator is drawn so that snap-to info is created. if (IsScaling) { TimelineLayout layout = Owner.GetLayout(); GhostInfo[] ghosts = m_resizer.CreateGhostInfo( layout, Owner.GetDragOffset().X, worldToView); Owner.Renderer.DrawGhosts( ghosts, DraggedSide, worldToView, Owner.ClientRectangle, g); } // Tighten clipping region. Has to occur after DrawGhosts because the TimelineRenderer // assumes that it has to shrink the current Graphics.Clip region by the header width. Region originalClip = g.Clip; Rectangle clipRectangle = Owner.VisibleClientRectangle; g.Clip = new Region(clipRectangle); // Draw the manipulator, giving client code a customization point. DrawManipulator(g, out m_leftHandle, out m_rightHandle); // Restore clipping region. g.Clip = originalClip; }
// get track that contains y value private TimelinePath GetTargetTrack( float y, TimelineLayout layout, IList <ITrack> tracks) { TimelinePath testPath = new TimelinePath((ITimelineObject)null); foreach (ITrack track in tracks) { testPath.Last = track; RectangleF targetBounds = layout[testPath]; if (targetBounds.Top <= y && targetBounds.Bottom >= y) { return(testPath); } } return(null); }
// gets objects of appropriate type that are underneath the moving selected objects private TimelinePath[] GetMoveTargets(TimelineLayout layout) { // get groups and visible tracks List <IGroup> groups = new List <IGroup>(); List <ITrack> visibleTracks = new List <ITrack>(); foreach (IGroup group in m_owner.TimelineDocument.Timeline.Groups) { groups.Add(group); IList <ITrack> tracks = group.Tracks; bool expanded = group.Expanded; bool collapsible = tracks.Count > 1; bool collapsed = collapsible && !expanded; if (!collapsed) { foreach (ITrack track in tracks) { visibleTracks.Add(track); } } } TimelinePath[] targets = new TimelinePath[m_owner.Selection.SelectionCount]; RectangleF bounds; TimelinePath testPath = new TimelinePath((ITimelineObject)null); int i = -1; foreach (TimelinePath path in m_owner.Selection.Selection) { i++; IGroup group = path.Last as IGroup; if (group != null) { foreach (IGroup targetGroup in groups) { Point p = m_owner.DragPoint; testPath.Last = targetGroup; RectangleF targetBounds = layout[testPath]; if (targetBounds.Top <= p.Y && targetBounds.Bottom >= p.Y) { targets[i] = new TimelinePath(testPath); break; } } continue; } ITrack track = path.Last as ITrack; if (track != null) { foreach (ITrack targetTrack in visibleTracks) { Point p = m_owner.DragPoint; testPath.Last = targetTrack; RectangleF targetBounds = layout[testPath]; if (targetBounds.Top <= p.Y && targetBounds.Bottom >= p.Y) { targets[i] = new TimelinePath(testPath); break; } } continue; } IInterval interval = path.Last as IInterval; if (interval != null) { track = interval.Track; if (track != null) { testPath.Last = track; bounds = layout[testPath]; float y = bounds.Top + bounds.Height * 0.5f + m_owner.DragDelta.Y; targets[i] = GetTargetTrack(y, layout, visibleTracks); continue; } } IKey key = path.Last as IKey; if (key != null) { track = key.Track; if (track != null) { testPath.Last = track; bounds = layout[testPath]; float y = bounds.Top + bounds.Height * 0.5f + m_owner.DragDelta.Y; targets[i] = GetTargetTrack(y, layout, visibleTracks); continue; } } // ignore Markers, as they don't hit targets } return(targets); }
// gets move information, for drawing ghosts and for performing actual move operation private GhostInfo[] GetMoveGhostInfo(Matrix worldToView, TimelineLayout layout) { // get start and y offsets in timeline space PointF dragOffset = m_owner.GetDragOffset(); // Get snapping points along the timeline (in world coordinates). List <float> movingPoints = new List <float>(2); TimelinePath snapperPath; if (m_mouseMoveHitRecord != null) { snapperPath = m_mouseMoveHitRecord.HitPath;//use the last clicked event (interval, key or marker) } else { snapperPath = m_owner.Selection.LastSelected as TimelinePath;//moving a group or track, for example } IEvent snapperEvent = snapperPath != null ? snapperPath.Last as IEvent : null; if (snapperEvent != null) { Matrix localToWorld = TimelineControl.CalculateLocalToWorld(snapperPath); float worldStart = GdiUtil.Transform(localToWorld, snapperEvent.Start + dragOffset.X); movingPoints.Add(worldStart); if (snapperEvent.Length > 0.0f) { movingPoints.Add(GdiUtil.Transform(localToWorld, snapperEvent.Start + dragOffset.X + snapperEvent.Length)); } } // Get the offset from one of the world snap points to the closest non-selected object. float snapOffset; try { s_snapOptions.FilterContext = snapperEvent; s_snapOptions.Filter = new TimelineControl.SnapFilter(MoveSnapFilter); snapOffset = m_owner.GetSnapOffset(movingPoints, s_snapOptions); } finally { s_snapOptions.FilterContext = null; s_snapOptions.Filter = null; } // adjust dragOffset to "snap-to" nearest event dragOffset.X += snapOffset; // get offsets in client space float xOffset = dragOffset.X * worldToView.Elements[0]; float yOffset = dragOffset.Y * worldToView.Elements[3]; TimelinePath[] targets = GetMoveTargets(layout); GhostInfo[] ghosts = new GhostInfo[targets.Length]; int i = -1; foreach (TimelinePath path in m_owner.Selection.Selection) { i++; ITimelineObject timelineObject = path.Last; RectangleF bounds = layout[path]; TimelinePath targetPath = targets[i]; ITimelineObject target = targetPath != null ? targetPath.Last : null; float start = 0; float length = 0; bool valid = true; IInterval interval = timelineObject as IInterval; IKey key = timelineObject as IKey; IMarker marker = timelineObject as IMarker; ITrack track = timelineObject as ITrack; IGroup group = timelineObject as IGroup; ITimelineReference reference = timelineObject as ITimelineReference; if (interval != null) { ITrack targetTrack = target as ITrack; start = interval.Start + dragOffset.X; length = interval.Length; valid = targetTrack != null && m_owner.Constraints.IsStartValid(interval, ref start) && m_owner.Constraints.IsLengthValid(interval, ref length); if (valid) { yOffset = layout[target].Y - layout[interval.Track].Y; TimelinePath testPath = new TimelinePath(targetPath); foreach (IInterval other in targetTrack.Intervals) { // skip selected intervals, since they are moving too testPath.Last = other; if (m_owner.Selection.SelectionContains(testPath)) { continue; } if (!m_owner.Constraints.IsIntervalValid(interval, ref start, ref length, other)) { valid = false; break; } } } } else if (reference != null) { // don't allow for vertical repositioning yet start = reference.Start + dragOffset.X; valid = true; } else if (key != null) { start = key.Start + dragOffset.X; ITrack targetTrack = target as ITrack; valid = targetTrack != null && m_owner.Constraints.IsStartValid(key, ref start); if (valid) { yOffset = layout[targetTrack].Y - layout[key.Track].Y; } } else if (marker != null) { start = marker.Start + dragOffset.X; yOffset = 0; valid = m_owner.Constraints.IsStartValid(marker, ref start); } else if (track != null) { xOffset = 0; if (target == null) { target = (m_owner.DragDelta.Y < 0) ? GetLastTrack() : GetFirstTrack(); } } else if (group != null) { xOffset = 0; if (target == null) { IList <IGroup> groups = m_owner.TimelineDocument.Timeline.Groups; target = (m_owner.DragDelta.Y < 0) ? groups[0] : groups[groups.Count - 1]; } } bounds.Offset(xOffset, yOffset); ghosts[i] = new GhostInfo(timelineObject, target, start, length, bounds, valid); } return(ghosts); }
/// <summary> /// Creates and caches resize information, for drawing ghosts and for performing /// actual resize operations</summary> /// <param name="layout">TimelineLayout</param> /// <param name="worldDrag">Drag offset</param> /// <param name="worldToView">World to view transformation matrix</param> /// <returns>Array of GhostInfo</returns> internal GhostInfo[] CreateGhostInfo(TimelineLayout layout, float worldDrag, Matrix worldToView) { // Get snap-from point in world coordinates. float[] movingPoints = new[] { worldDrag + m_originalBoundary }; float snapOffset = m_owner.GetSnapOffset(movingPoints, null); // adjust dragOffset to snap-to nearest event worldDrag += snapOffset; DragOffsetWithSnap = worldDrag; GhostInfo[] ghosts = new GhostInfo[m_selection.Count]; IEnumerator <TimelinePath> events = m_selection.GetEnumerator(); m_worldGhostMin = float.MaxValue; m_worldGhostMax = float.MinValue; for (int i = 0; i < ghosts.Length; i++) { events.MoveNext(); IEvent curr = (IEvent)events.Current.Last; RectangleF bounds = layout[events.Current]; float viewStart = bounds.Left; float viewEnd = viewStart + bounds.Width; float worldStart = curr.Start; float worldEnd = worldStart + curr.Length; Resize( worldDrag, worldToView, ref viewStart, ref viewEnd, ref worldStart, ref worldEnd); float worldLength = worldEnd - worldStart; bounds = new RectangleF(viewStart, bounds.Y, viewEnd - viewStart, bounds.Height); if (m_worldGhostMin > worldStart) { m_worldGhostMin = worldStart; } if (m_worldGhostMax < worldEnd) { m_worldGhostMax = worldEnd; } bool valid = true; IInterval interval = curr as IInterval; if (interval != null) { TimelinePath testPath = new TimelinePath(events.Current); foreach (IInterval other in interval.Track.Intervals) { // Skip this interval if it's part of the selection because we have to assume // that the track began in a valid state and that all of the selected objects // will still be valid relative to each other. We only need to check that the // scaled objects are valid relative to the stationary objects. testPath.Last = other; if (Mode == ScaleMode.TimePeriod && m_selection.Contains(testPath)) { continue; } else if (other == interval) { continue; } if (!m_owner.Constraints.IsIntervalValid(interval, ref worldStart, ref worldLength, other)) { valid = false; break; } } } ghosts[i] = new GhostInfo(curr, null, worldStart, worldLength, bounds, valid); } m_ghosts = ghosts; return(ghosts); }