[pitivi] timeline: Don't use time as variable name
- From: Edward Hervey <edwardrv src gnome org>
- To: svn-commits-list gnome org
- Subject: [pitivi] timeline: Don't use time as variable name
- Date: Fri, 29 May 2009 06:30:20 -0400 (EDT)
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]