Esempio n. 1
0
        /// Spacing manipulation
        ///
        private void EventPosSpaceChange(EventPositionModifyMethod Method)
        {
            List <TrackEvent> TargetEvents = myVegas.Project.GetSelectedEvents(true);

            if (TargetEvents.Count <= 1)
            {
                TargetEvents = GetEventsByTimeSelection();
                if (TargetEvents.Count <= 1)
                {
                    return;
                }
            }
            TrackEvent FirstEvent = TargetEvents[0];
            TrackEvent LastEvent  = TargetEvents[TargetEvents.Count - 1];

            // Auto
            if (Method == EventPositionModifyMethod.Auto)
            {
                int _NumEvents  = TargetEvents.Count;
                var MediaLength = new Timecode();

                MediaLength = TargetEvents.Aggregate(MediaLength, (current, CurrentEvent) => current + CurrentEvent.Length);

                Timecode TotalTime      = LastEvent.End - FirstEvent.Start;
                Timecode Space          = TotalTime - MediaLength;
                Timecode MediumInterval = Timecode.FromNanos((Space.Nanos / (_NumEvents - 1)));

                using (var undo = new UndoBlock("Spacing: auto"))
                {
                    TrackEvent prevEvent = null;

                    for (int eventCounter = 1; eventCounter < TargetEvents.Count; eventCounter++)
                    {
                        TrackEvent curEvent = TargetEvents[eventCounter];
                        if (curEvent != null)
                        {
                            if (prevEvent != null)
                            {
                                curEvent.Start = prevEvent.End + MediumInterval;
                            }
                        }

                        prevEvent = curEvent;
                    }
                }
                return;
            }

            // User
            if (Method == EventPositionModifyMethod.User)
            {
                Timecode userInterval = FormTimeEntry.GetUserTime();
                if (userInterval == null)
                {
                    return;
                }

                using (var undo = new UndoBlock("Spacing: user"))
                {
                    TrackEvent prevEvent = null;

                    for (int eventCounter = 0; eventCounter < TargetEvents.Count; eventCounter++)
                    {
                        TrackEvent curEvent = TargetEvents[eventCounter];

                        if (curEvent != null)
                        {
                            if (prevEvent != null)
                            {
                                curEvent.Start = prevEvent.End + userInterval;
                            }
                        }

                        prevEvent = curEvent;
                    }
                }
            }
        }
Esempio n. 2
0
 private void EventPosInterChange(EventPositionModifyMethod Method)
 {
     EventPosInterChange(Method, Timecode.FromMilliseconds(0));
 }
Esempio n. 3
0
        /// Position manipulation
        ///
        private void EventPosInterChange(EventPositionModifyMethod Method, Timecode Interval)
        {
            List <TrackEvent> selectedEvents = myVegas.Project.GetSelectedEvents(true);

            if (selectedEvents.Count <= 1)
            {
                selectedEvents = GetEventsByTimeSelection();
                if (selectedEvents.Count <= 1)
                {
                    return;
                }
            }

            TrackEvent FirstEvent = selectedEvents[0];
            TrackEvent LastEvent  = selectedEvents[selectedEvents.Count - 1];

            if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
            {
                Interval = (Timecode.FromNanos(Interval.Nanos * 10));
            }

            // Adjust
            if ((Method == EventPositionModifyMethod.Adjust))
            {
                using (var undo = new UndoBlock("Position: adjust"))
                {
                    for (int EventCounter = 1; EventCounter < selectedEvents.Count; EventCounter++)
                    {
                        TrackEvent CurEvent = selectedEvents[EventCounter];

                        if (CurEvent != null)
                        {
                            CurEvent.Start = CurEvent.Start + Timecode.FromNanos(Interval.Nanos * EventCounter);
                        }
                    }
                }
                return;
            }

            // Auto
            if (Method == EventPositionModifyMethod.Auto)
            {
                // get some stats.
                Timecode MediumInterval =
                    Timecode.FromNanos((LastEvent.Start.Nanos - FirstEvent.Start.Nanos) / (selectedEvents.Count - 1));

                using (var undo = new UndoBlock("Position: auto"))
                {
                    for (int EventCounter = 1; EventCounter < selectedEvents.Count - 1; EventCounter++)
                    {
                        TrackEvent CurEvent = selectedEvents[EventCounter];

                        if (CurEvent != null)
                        {
                            CurEvent.Start = FirstEvent.Start + Timecode.FromNanos(MediumInterval.Nanos * EventCounter);
                        }
                    }
                }
                return;
            }

            // User
            if (Method == EventPositionModifyMethod.User)
            {
                Timecode UserInterval = FormTimeEntry.GetUserTime();
                if (UserInterval == null)
                {
                    return;
                }

                using (var undo = new UndoBlock("Position: adjust"))
                {
                    for (int EventCounter = 1; EventCounter < selectedEvents.Count; EventCounter++)
                    {
                        TrackEvent CurEvent = selectedEvents[EventCounter];

                        if (CurEvent != null)
                        {
                            CurEvent.Start = FirstEvent.Start + Timecode.FromNanos(UserInterval.Nanos * EventCounter);
                        }
                    }
                }
            }
        }
Esempio n. 4
0
		/// Spacing manipulation
		///
		private void EventPosSpaceChange(EventPositionModifyMethod Method)
		{
			List<TrackEvent> TargetEvents = myVegas.Project.GetSelectedEvents(true);

			if (TargetEvents.Count <= 1)
			{
				TargetEvents = GetEventsByTimeSelection();
				if (TargetEvents.Count <= 1)
					return;
			}
			TrackEvent FirstEvent = TargetEvents[0];
			TrackEvent LastEvent = TargetEvents[TargetEvents.Count - 1];

			// Auto
			if (Method == EventPositionModifyMethod.Auto)
			{
				int _NumEvents = TargetEvents.Count;
				var MediaLength = new Timecode();

				MediaLength = TargetEvents.Aggregate(MediaLength, (current, CurrentEvent) => current + CurrentEvent.Length);

				Timecode TotalTime = LastEvent.End - FirstEvent.Start;
				Timecode Space = TotalTime - MediaLength;
				Timecode MediumInterval = Timecode.FromNanos((Space.Nanos / (_NumEvents - 1)));

				using (var undo = new UndoBlock("Spacing: auto"))
				{
					TrackEvent prevEvent = null;

					for (int eventCounter = 1; eventCounter < TargetEvents.Count; eventCounter++)
					{
						TrackEvent curEvent = TargetEvents[eventCounter];
						if (curEvent != null)
						{
							if (prevEvent != null) curEvent.Start = prevEvent.End + MediumInterval;
						}

						prevEvent = curEvent;
					}
				}
				return;
			}

			// User
			if (Method == EventPositionModifyMethod.User)
			{
				Timecode userInterval = FormTimeEntry.GetUserTime();
				if (userInterval == null)
					return;

				using (var undo = new UndoBlock("Spacing: user"))
				{
					TrackEvent prevEvent = null;

					for (int eventCounter = 0; eventCounter < TargetEvents.Count; eventCounter++)
					{
						TrackEvent curEvent = TargetEvents[eventCounter];

						if (curEvent != null)
						{
							if (prevEvent != null) curEvent.Start = prevEvent.End + userInterval;
						}

						prevEvent = curEvent;
					}
				}
			}
		}
Esempio n. 5
0
		private void EventPosInterChange(EventPositionModifyMethod Method)
		{
			EventPosInterChange(Method, Timecode.FromMilliseconds(0));
		}
Esempio n. 6
0
		/// Position manipulation
		///
		private void EventPosInterChange(EventPositionModifyMethod Method, Timecode Interval)
		{
			List<TrackEvent> selectedEvents = myVegas.Project.GetSelectedEvents(true);
			if (selectedEvents.Count <= 1)
			{
				selectedEvents = GetEventsByTimeSelection();
				if (selectedEvents.Count <= 1)
					return;
			}

			TrackEvent FirstEvent = selectedEvents[0];
			TrackEvent LastEvent = selectedEvents[selectedEvents.Count - 1];

			if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
				Interval = (Timecode.FromNanos(Interval.Nanos * 10));

			// Adjust
			if ((Method == EventPositionModifyMethod.Adjust))
			{
				using (var undo = new UndoBlock("Position: adjust"))
				{
					for (int EventCounter = 1; EventCounter < selectedEvents.Count; EventCounter++)
					{
						TrackEvent CurEvent = selectedEvents[EventCounter];

						if (CurEvent != null)
						{
							CurEvent.Start = CurEvent.Start + Timecode.FromNanos(Interval.Nanos * EventCounter);
						}
					}
				}
				return;
			}

			// Auto
			if (Method == EventPositionModifyMethod.Auto)
			{
				// get some stats.
				Timecode MediumInterval =
					Timecode.FromNanos((LastEvent.Start.Nanos - FirstEvent.Start.Nanos) / (selectedEvents.Count - 1));

				using (var undo = new UndoBlock("Position: auto"))
				{
					for (int EventCounter = 1; EventCounter < selectedEvents.Count - 1; EventCounter++)
					{
						TrackEvent CurEvent = selectedEvents[EventCounter];

						if (CurEvent != null)
						{
							CurEvent.Start = FirstEvent.Start + Timecode.FromNanos(MediumInterval.Nanos * EventCounter);
						}
					}
				}
				return;
			}

			// User
			if (Method == EventPositionModifyMethod.User)
			{
				Timecode UserInterval = FormTimeEntry.GetUserTime();
				if (UserInterval == null)
					return;

				using (var undo = new UndoBlock("Position: adjust"))
				{
					for (int EventCounter = 1; EventCounter < selectedEvents.Count; EventCounter++)
					{
						TrackEvent CurEvent = selectedEvents[EventCounter];

						if (CurEvent != null)
						{
							CurEvent.Start = FirstEvent.Start + Timecode.FromNanos(UserInterval.Nanos * EventCounter);
						}
					}
				}
			}
		}