[pitivi] timeline: Don't use time as variable name



commit aa913138c3c8905af29549aa356ee2b8a260936d
Author: Edward Hervey <bilboed bilboed com>
Date:   Thu May 28 14:39:18 2009 +0200

    timeline: Don't use time as variable name
---
 pitivi/timeline/timeline.py |   52 +++++++++++++++---------------
 pitivi/timeline/track.py    |   74 +++++++++++++++++++++---------------------
 2 files changed, 63 insertions(+), 63 deletions(-)

diff --git a/pitivi/timeline/timeline.py b/pitivi/timeline/timeline.py
index 30833b6..f21c6a5 100644
--- a/pitivi/timeline/timeline.py
+++ b/pitivi/timeline/timeline.py
@@ -73,26 +73,26 @@ class TimelineObject(Signallable, Loggable):
 
         return self.track_objects[0].start
 
-    def setStart(self, time, snap=False):
+    def setStart(self, position, snap=False):
         if not self.track_objects:
             raise TimelineError()
 
         if snap:
-            time = self.timeline.snapToEdge(time, time + self.duration)
+            position = self.timeline.snapToEdge(position, position + self.duration)
 
         if self.link is not None:
             # if we're part of a link, we need to check if it's necessary to
-            # clamp time so that we don't push the earliest element before 0s
-            delta = time - self.start
+            # clamp position so that we don't push the earliest element before 0s
+            delta = position - self.start
             off = self.link.earliest_start + delta
             if off < 0:
                 # clamp so that the earliest element is shifted to 0s
-                time -= off
+                position -= off
 
         for track_object in self.track_objects:
-            track_object.setObjectStart(time)
+            track_object.setObjectStart(position)
 
-        self.emit('start-changed', time)
+        self.emit('start-changed', position)
 
     start = property(_getStart, setStart)
 
@@ -102,22 +102,22 @@ class TimelineObject(Signallable, Loggable):
 
         return self.track_objects[0].duration
 
-    def setDuration(self, time, snap=False, set_media_stop=True):
+    def setDuration(self, position, snap=False, set_media_stop=True):
         if not self.track_objects:
             raise TimelineError()
 
         if snap:
-            time = self.timeline.snapToEdge(time)
+            position = self.timeline.snapToEdge(position)
 
         trimmed_start = self.track_objects[0].trimmed_start
-        time = min(time, self.factory.duration - trimmed_start)
+        position = min(position, self.factory.duration - trimmed_start)
 
         for track_object in self.track_objects:
-            track_object.setObjectDuration(time)
+            track_object.setObjectDuration(position)
             if set_media_stop:
-                track_object.setObjectMediaDuration(time)
+                track_object.setObjectMediaDuration(position)
 
-        self.emit('duration-changed', time)
+        self.emit('duration-changed', position)
 
     duration = property(_getDuration, setDuration)
 
@@ -127,14 +127,14 @@ class TimelineObject(Signallable, Loggable):
 
         return self.track_objects[0].in_point
 
-    def setInPoint(self, time, snap=False):
+    def setInPoint(self, position, snap=False):
         if not self.track_objects:
             raise TimelineError()
 
         for track_object in self.track_objects:
-            track_object.setObjectInPoint(time)
+            track_object.setObjectInPoint(position)
 
-        self.emit('in-point-changed', time)
+        self.emit('in-point-changed', position)
 
     in_point = property(_getInPoint, setInPoint)
 
@@ -152,14 +152,14 @@ class TimelineObject(Signallable, Loggable):
 
         return self.track_objects[0].media_duration
 
-    def setMediaDuration(self, time, snap=False):
+    def setMediaDuration(self, position, snap=False):
         if not self.track_objects:
             raise TimelineError()
 
         for track_object in self.track_objects:
-            track_object.setObjectMediaDuration(time)
+            track_object.setObjectMediaDuration(position)
 
-        self.emit('media-duration-changed', time)
+        self.emit('media-duration-changed', position)
 
     media_duration = property(_getMediaDuration, setMediaDuration)
 
@@ -198,21 +198,21 @@ class TimelineObject(Signallable, Loggable):
 
     selected = property(_getSelected, setSelected)
 
-    def trimStart(self, time, snap=False):
+    def trimStart(self, position, snap=False):
         if not self.track_objects:
             raise TimelineError()
 
         if snap:
-            time = self.timeline.snapToEdge(time)
+            position = self.timeline.snapToEdge(position)
 
         for track_object in self.track_objects:
-            track_object.trimObjectStart(time)
+            track_object.trimObjectStart(position)
 
         self.emit('start-changed', self.start)
         self.emit('duration-changed', self.duration)
         self.emit('in-point-changed', self.in_point)
 
-    def split(self, time, snap=False):
+    def split(self, position, snap=False):
         if not self.track_objects:
             raise TimelineError()
 
@@ -223,7 +223,7 @@ class TimelineObject(Signallable, Loggable):
 
         for track_object in self.track_objects:
             try:
-                other_track_object = track_object.splitObject(time)
+                other_track_object = track_object.splitObject(position)
             except TrackError, e:
                 # FIXME: hallo exception hierarchy?
                 raise TimelineError(str(e))
@@ -468,8 +468,8 @@ class TimelineEdges(object):
 
         return start + end_diff, end_diff
 
-    def closest(self, time):
-        closest, diff, index = closest_item(self.edges, time)
+    def closest(self, position):
+        closest, diff, index = closest_item(self.edges, position)
         return self.edges[max(0, index - 2)], self.edges[min(
             len(self.edges) - 1, index + 1)]
 
diff --git a/pitivi/timeline/track.py b/pitivi/timeline/track.py
index fef45f4..9daaef6 100644
--- a/pitivi/timeline/track.py
+++ b/pitivi/timeline/track.py
@@ -96,45 +96,45 @@ class TrackObject(Signallable):
     def _getStart(self):
         return self.gnl_object.props.start
 
-    def setStart(self, time, snap=False):
+    def setStart(self, position, snap=False):
         if self.timeline_object is not None:
-            self.timeline_object.setStart(time, snap)
+            self.timeline_object.setStart(position, snap)
         else:
             if snap:
                 raise TrackError()
 
-            self.setObjectStart(time)
+            self.setObjectStart(position)
 
-    def setObjectStart(self, time):
-        self.gnl_object.props.start = time
+    def setObjectStart(self, position):
+        self.gnl_object.props.start = position
 
     start = property(_getStart, setStart)
 
     def _getDuration(self):
         return self.gnl_object.props.duration
 
-    def setDuration(self, time, snap=False):
+    def setDuration(self, position, snap=False):
         if self.timeline_object is not None:
-            self.timeline_object.setDuration(time, snap)
+            self.timeline_object.setDuration(position, snap)
         else:
             if snap:
                 raise TrackError()
 
-            self.setObjectDuration(time)
+            self.setObjectDuration(position)
 
-    def setObjectDuration(self, time):
-        self.gnl_object.props.duration = time
+    def setObjectDuration(self, position):
+        self.gnl_object.props.duration = position
 
     duration = property(_getDuration, setDuration)
 
     def _getInPoint(self):
         return self.gnl_object.props.media_start
 
-    def setInPoint(self, time, snap=False):
+    def setInPoint(self, position, snap=False):
         if self.timeline_object is not None:
-            self.timeline_object.setInPoint(time, snap)
+            self.timeline_object.setInPoint(position, snap)
         else:
-            self.setObjectInPoint(time)
+            self.setObjectInPoint(position)
 
     def setObjectInPoint(self, value):
         self.gnl_object.props.media_start = value
@@ -149,14 +149,14 @@ class TrackObject(Signallable):
     def _getMediaDuration(self):
         return self.gnl_object.props.media_duration
 
-    def setMediaDuration(self, time, snap=False):
+    def setMediaDuration(self, position, snap=False):
         if self.timeline_object is not None:
-            self.timeline_object.setMediaDuration(time, snap)
+            self.timeline_object.setMediaDuration(position, snap)
         else:
-            self.setObjectMediaDuration(time)
+            self.setObjectMediaDuration(position)
 
-    def setObjectMediaDuration(self, time):
-        self.gnl_object.props.media_duration = time
+    def setObjectMediaDuration(self, position):
+        self.gnl_object.props.media_duration = position
 
     media_duration = property(_getMediaDuration, setMediaDuration)
 
@@ -179,42 +179,42 @@ class TrackObject(Signallable):
 
     priority = property(_getPriority, setPriority)
 
-    def trimStart(self, time, snap=False):
+    def trimStart(self, position, snap=False):
         if self.timeline_object is not None:
-            self.timeline_object.trimStart(time, snap)
+            self.timeline_object.trimStart(position, snap)
         else:
-            self.trimObjectStart(time)
+            self.trimObjectStart(position)
 
-    def trimObjectStart(self, time):
-        # clamp time to be inside the object
-        time = max(self.start - self.trimmed_start, time)
-        time = min(time, self.start + self.duration)
-        new_duration = max(0, self.start + self.duration - time)
+    def trimObjectStart(self, position):
+        # clamp position to be inside the object
+        position = max(self.start - self.trimmed_start, position)
+        position = min(position, self.start + self.duration)
+        new_duration = max(0, self.start + self.duration - position)
 
-        delta = time - self.start
+        delta = position - self.start
         self.trimmed_start += delta
-        self.setObjectStart(time)
+        self.setObjectStart(position)
         self.setObjectDuration(new_duration)
         self.setObjectInPoint(self.trimmed_start)
         self.setObjectMediaDuration(new_duration)
 
-    def split(self, time, snap=False):
+    def split(self, position, snap=False):
         if self.timeline_object is not None:
-            return self.timeline_object.split(time, snap)
+            return self.timeline_object.split(position, snap)
         else:
-            return self.splitObject(time)
+            return self.splitObject(position)
 
-    def splitObject(self, time):
+    def splitObject(self, position):
         start = self.gnl_object.props.start
         duration = self.gnl_object.props.duration
-        if time <= start or time >= start + duration:
-            raise TrackError("can't split at time %s" % gst.TIME_ARGS(time))
+        if position <= start or position >= start + duration:
+            raise TrackError("can't split at position %s" % gst.TIME_ARGS(position))
 
         other = self.copy()
 
-        other.trimObjectStart(time)
-        self.setObjectDuration(time - self.gnl_object.props.start)
-        self.setObjectMediaDuration(time - self.gnl_object.props.start)
+        other.trimObjectStart(position)
+        self.setObjectDuration(position - self.gnl_object.props.start)
+        self.setObjectMediaDuration(position - self.gnl_object.props.start)
 
         return other
 



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]