예제 #1
0
    def testConnectionAndDisconnection(self):
        timeline = Timeline()
        stream = new_stream()
        factory = new_source_factory()
        track = Track(stream)
        track_object1 = SourceTrackObject(factory, stream)
        track.addTrackObject(track_object1)
        timeline.addTrack(track)
        timeline_object1 = TimelineObject(factory)
        timeline_object1.addTrackObject(track_object1)
        timeline.addTimelineObject(timeline_object1)

        self.observer.startObserving(timeline)
        self.failUnless(timeline.connected)
        self.failUnless(timeline_object1.connected)

        timeline.removeTimelineObject(timeline_object1)
        self.failIf(timeline_object1.connected)

        timeline.addTimelineObject(timeline_object1)
        self.failUnless(timeline_object1)

        self.observer.stopObserving(timeline)
        self.failIf(timeline.connected)
        self.failIf(timeline_object1.connected)
예제 #2
0
    def testConnectionAndDisconnection(self):
        timeline = Timeline()
        stream = new_stream()
        factory = new_source_factory()
        track = Track(stream)
        track_object1 = SourceTrackObject(factory, stream)
        track.addTrackObject(track_object1)
        timeline.addTrack(track)
        timeline_object1 = TimelineObject(factory)
        timeline_object1.addTrackObject(track_object1)
        timeline.addTimelineObject(timeline_object1)

        self.observer.startObserving(timeline)
        self.failUnless(timeline.connected)
        self.failUnless(timeline_object1.connected)

        timeline.removeTimelineObject(timeline_object1)
        self.failIf(timeline_object1.connected)

        timeline.addTimelineObject(timeline_object1)
        self.failUnless(timeline_object1)

        self.observer.stopObserving(timeline)
        self.failIf(timeline.connected)
        self.failIf(timeline_object1.connected)
예제 #3
0
class  TestTimelineUndo(TestCase):
    def setUp(self):
        self.stream = new_stream()
        self.factory = new_source_factory()
        self.effect_factory = TestEffectFactory(self.stream)
        self.track1 = Track(self.stream)
        self.track2 = Track(self.stream)
        self.timeline = Timeline()
        self.timeline.addTrack(self.track1)
        self.timeline.addTrack(self.track2)
        self.track_object1 = SourceTrackObject(self.factory, self.stream)
        self.track_object2 = SourceTrackObject(self.factory, self.stream)
        self.track_effect1 = TrackEffect(self.effect_factory, self.stream)
        self.track_effect2 = TrackEffect(self.effect_factory, self.stream)
        self.track1.addTrackObject(self.track_object1)
        self.track2.addTrackObject(self.track_object2)
        self.timeline_object1 = TimelineObject(self.factory)
        self.timeline_object1.addTrackObject(self.track_object1)
        self.timeline_object1.addTrackObject(self.track_object2)
        self.action_log = UndoableActionLog()
        self.observer = TestTimelineLogObserver(self.action_log)
        self.observer.startObserving(self.timeline)

    def testAddTimelineObject(self):
        stacks = []

        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)

        self.action_log.begin("add clip")
        self.timeline.addTimelineObject(self.timeline_object1)
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TimelineObjectAdded))

        self.failUnless(self.timeline_object1 \
                in self.timeline.timeline_objects)
        self.action_log.undo()
        self.failIf(self.timeline_object1 \
                in self.timeline.timeline_objects)

        self.action_log.redo()
        self.failUnless(self.timeline_object1 \
                in self.timeline.timeline_objects)

    def testRemoveTimelineObject(self):
        stacks = []

        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)

        self.timeline.addTimelineObject(self.timeline_object1)
        self.action_log.begin("remove clip")
        self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TimelineObjectRemoved))

        self.failIf(self.timeline_object1 \
                in self.timeline.timeline_objects)
        self.action_log.undo()
        self.failUnless(self.timeline_object1 \
                in self.timeline.timeline_objects)

        self.action_log.redo()
        self.failIf(self.timeline_object1 \
                in self.timeline.timeline_objects)

    def testAddEffectToTimelineObject(self):
        stacks = []
        pipeline = Pipeline()

        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)
        self.observer.pipeline = pipeline

        #FIXME Should I commit it and check there are 2 elements
        #in the stacks
        self.timeline.addTimelineObject(self.timeline_object1)
        self.track1.addTrackObject(self.track_effect1)

        self.action_log.begin("add effect")
        self.timeline_object1.addTrackObject(self.track_effect1)
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TrackEffectAdded))

        self.failUnless(self.track_effect1 \
                in self.timeline_object1.track_objects)
        self.failUnless(self.track_effect1 \
                in self.track1.track_objects)
        self.failUnless(len([effect for effect in \
                                self.timeline_object1.track_objects
                                if isinstance(effect, TrackEffect)]) == 1)
        self.failUnless(len([effect for effect in self.track1.track_objects
                             if isinstance(effect, TrackEffect)]) == 1)

        self.action_log.undo()
        self.failIf(self.track_effect1 \
                in self.timeline_object1.track_objects)
        self.failIf(self.track_effect1 \
                in self.track1.track_objects)

        self.action_log.redo()
        self.failUnless(len([effect for effect in
                                self.timeline_object1.track_objects
                                if isinstance(effect, TrackEffect)]) == 1)
        self.failUnless(len([effect for effect in self.track1.track_objects
                             if isinstance(effect, TrackEffect)]) == 1)

        self.timeline.removeTimelineObject(self.timeline_object1, deep=True)

    def testTimelineObjectPropertyChange(self):
        stacks = []

        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)

        self.timeline_object1.start = 5 * gst.SECOND
        self.timeline_object1.duration = 20 * gst.SECOND
        self.timeline.addTimelineObject(self.timeline_object1)
        self.action_log.begin("modify clip")
        self.timeline_object1.start = 10 * gst.SECOND
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TimelineObjectPropertyChanged))

        self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)
        self.action_log.undo()
        self.failUnlessEqual(self.timeline_object1.start, 5 * gst.SECOND)
        self.action_log.redo()
        self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)

        self.timeline_object1.priority = 10
        self.action_log.begin("priority change")
        self.timeline_object1.priority = 20
        self.action_log.commit()

        self.failUnlessEqual(self.timeline_object1.priority, 20)
        self.action_log.undo()
        self.failUnlessEqual(self.timeline_object1.priority, 10)
        self.action_log.redo()
        self.failUnlessEqual(self.timeline_object1.priority, 20)

    def testUngroup(self):
        self.timeline_object1.start = 5 * gst.SECOND
        self.timeline_object1.duration = 20 * gst.SECOND

        self.timeline.addTimelineObject(self.timeline_object1)
        self.timeline.setSelectionToObj(self.track_object1, SELECT_ADD)

        self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
        self.failUnlessEqual(self.timeline.timeline_objects[0].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
                20 * gst.SECOND)

        self.action_log.begin("ungroup")
        self.timeline.ungroupSelection()
        self.action_log.commit()

        self.failUnlessEqual(len(self.timeline.timeline_objects), 2)
        self.failUnlessEqual(self.timeline.timeline_objects[0].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
                20 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[1].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[1].duration,
                20 * gst.SECOND)

        self.action_log.undo()

        self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
        self.failUnlessEqual(self.timeline.timeline_objects[0].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
                20 * gst.SECOND)
예제 #4
0
파일: test_gap.py 프로젝트: bemasc/pitivi
class TestGap(TestCase):
    def setUp(self):
        self.factory = StubFactory()
        self.stream = AudioStream(gst.Caps('audio/x-raw-int'))
        self.factory.addOutputStream(self.stream)
        self.track1 = Track(self.stream)
        self.timeline = Timeline()

    def makeTimelineObject(self):
        track_object = SourceTrackObject(self.factory, self.stream)
        self.track1.addTrackObject(track_object)
        timeline_object = TimelineObject(self.factory)
        timeline_object.addTrackObject(track_object)
        self.timeline.addTimelineObject(timeline_object)

        return timeline_object

    def testGapCmp(self):
        gap1 = Gap(None, None, start=10, duration=5)
        gap2 = Gap(None, None, start=10, duration=5)
        self.failUnlessEqual(gap1, gap2)

        gap2 = Gap(None, None, start=15, duration=4)
        self.failUnless(gap1 > gap2)
        self.failUnless(gap2 < gap1)

    def testFindAroundObject(self):
        timeline_object1 = self.makeTimelineObject()
        timeline_object2 = self.makeTimelineObject()

        timeline_object1.start = 5 * gst.SECOND
        timeline_object1.duration = 10 * gst.SECOND
        timeline_object2.start = 20 * gst.SECOND
        timeline_object2.duration = 10 * gst.SECOND

        left_gap, right_gap = Gap.findAroundObject(timeline_object1)
        self.failUnlessEqual(left_gap.left_object, None)
        self.failUnlessEqual(left_gap.right_object, timeline_object1)
        self.failUnlessEqual(left_gap.start, 0 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 5 * gst.SECOND)
        self.failUnlessEqual(right_gap.left_object, timeline_object1)
        self.failUnlessEqual(right_gap.right_object, timeline_object2)
        self.failUnlessEqual(right_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, 5 * gst.SECOND)

        left_gap, right_gap = Gap.findAroundObject(timeline_object2)
        self.failUnlessEqual(left_gap.left_object, timeline_object1)
        self.failUnlessEqual(left_gap.right_object, timeline_object2)
        self.failUnlessEqual(left_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 5 * gst.SECOND)
        self.failUnlessEqual(right_gap.left_object, timeline_object2)
        self.failUnlessEqual(right_gap.right_object, None)
        self.failUnlessEqual(right_gap.start, 30 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, infinity)

        # make the objects overlap
        timeline_object2.start = 10 * gst.SECOND
        left_gap, right_gap = Gap.findAroundObject(timeline_object1)
        self.failUnlessEqual(right_gap.left_object, timeline_object1)
        self.failUnlessEqual(right_gap.right_object, timeline_object2)
        self.failUnlessEqual(right_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, -5 * gst.SECOND)

    def testGapFinder(self):
        timeline_object1 = self.makeTimelineObject()
        timeline_object2 = self.makeTimelineObject()
        timeline_object3 = self.makeTimelineObject()
        timeline_object4 = self.makeTimelineObject()

        timeline_object1.start = 5 * gst.SECOND
        timeline_object1.duration = 10 * gst.SECOND
        timeline_object1.priority = 1

        timeline_object2.start = 20 * gst.SECOND
        timeline_object2.duration = 10 * gst.SECOND
        timeline_object2.priority = 1

        timeline_object3.start = 31 * gst.SECOND
        timeline_object3.duration = 10 * gst.SECOND
        timeline_object3.priority = 2

        timeline_object4.start = 50 * gst.SECOND
        timeline_object4.duration = 10 * gst.SECOND
        timeline_object4.priority = 2

        gap_finder = SmallestGapsFinder(set([timeline_object2,
                timeline_object3]))
        gap_finder.update(*Gap.findAroundObject(timeline_object2))
        gap_finder.update(*Gap.findAroundObject(timeline_object3))

        left_gap = gap_finder.left_gap
        right_gap = gap_finder.right_gap
        self.failUnlessEqual(left_gap.left_object, timeline_object1)
        self.failUnlessEqual(left_gap.right_object, timeline_object2)
        self.failUnlessEqual(left_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 5 * gst.SECOND)
        self.failUnlessEqual(right_gap.left_object, timeline_object3)
        self.failUnlessEqual(right_gap.right_object, timeline_object4)
        self.failUnlessEqual(right_gap.start, 41 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, 9 * gst.SECOND)

        # make timeline_object3 and timeline_object4 overlap
        timeline_object3.duration = 20 * gst.SECOND

        gap_finder = SmallestGapsFinder(set([timeline_object4]))
        gap_finder.update(*Gap.findAroundObject(timeline_object4))
        left_gap = gap_finder.left_gap
        right_gap = gap_finder.right_gap
        self.failUnlessEqual(left_gap, invalid_gap)
        self.failUnlessEqual(right_gap.left_object, timeline_object4)
        self.failUnlessEqual(right_gap.right_object, None)
        self.failUnlessEqual(right_gap.start, 60 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, infinity)

        gap_finder = SmallestGapsFinder(set([timeline_object3]))
        gap_finder.update(*Gap.findAroundObject(timeline_object3))
        left_gap = gap_finder.left_gap
        right_gap = gap_finder.right_gap
        self.failUnlessEqual(left_gap.left_object, None)
        self.failUnlessEqual(left_gap.right_object, timeline_object3)
        self.failUnlessEqual(left_gap.start, 0 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 31 * gst.SECOND)
        self.failUnlessEqual(right_gap, invalid_gap)

    def testFindAllGaps(self):

        simple = (
            (3 * gst.SECOND, 1 * gst.SECOND),
            (1 * gst.SECOND, 1 * gst.SECOND)
        )

        objs = []
        for start, duration in simple:
            obj = self.makeTimelineObject()
            obj.start = start
            obj.duration = duration
            objs.append(obj)

        result = [(g.start, g.initial_duration) for g in
            Gap.findAllGaps(objs)]

        self.assertEquals(result, [
            (0 * gst.SECOND, 1 * gst.SECOND),
            (2 * gst.SECOND, 1 * gst.SECOND),
        ])

        complex = [
            (1 * gst.SECOND, 2 * gst.SECOND),
            (6 * gst.SECOND, 2 * gst.SECOND),
            (10 * gst.SECOND, 2 * gst.SECOND),
            (8 * gst.SECOND, 2 * gst.SECOND),
            (14 * gst.SECOND, 1 * gst.SECOND),
            (4 * gst.SECOND, 1 * gst.SECOND),
        ]

        objs = []
        for start, duration in complex:
            obj = self.makeTimelineObject()
            obj.start = start
            obj.duration = duration
            objs.append(obj)

        result = [(g.start, g.initial_duration) for g in
            Gap.findAllGaps(objs)]

        self.assertEquals(result, [
            (0 * gst.SECOND, 1 * gst.SECOND),
            (3 * gst.SECOND, 1 * gst.SECOND),
            (5 * gst.SECOND, 1 * gst.SECOND),
            (12 * gst.SECOND, 2 * gst.SECOND),
        ])

        complex.append((2 * gst.SECOND, 5 * gst.SECOND))

        objs = []
        for start, duration in complex:
            obj = self.makeTimelineObject()
            obj.start = start
            obj.duration = duration
            objs.append(obj)

        result = [(g.start, g.initial_duration) for g in
            Gap.findAllGaps(objs)]

        self.assertEquals(result, [
            (0 * gst.SECOND, 1 * gst.SECOND),
            (12 * gst.SECOND, 2 * gst.SECOND),
        ])
예제 #5
0
class TestGap(TestCase):
    def setUp(self):
        self.factory = StubFactory()
        self.stream = AudioStream(gst.Caps('audio/x-raw-int'))
        self.factory.addOutputStream(self.stream)
        self.track1 = Track(self.stream)
        self.timeline = Timeline()

    def makeTimelineObject(self):
        track_object = SourceTrackObject(self.factory, self.stream)
        self.track1.addTrackObject(track_object)
        timeline_object = TimelineObject(self.factory)
        timeline_object.addTrackObject(track_object)
        self.timeline.addTimelineObject(timeline_object)

        return timeline_object

    def testGapCmp(self):
        gap1 = Gap(None, None, start=10, duration=5)
        gap2 = Gap(None, None, start=10, duration=5)
        self.failUnlessEqual(gap1, gap2)

        gap2 = Gap(None, None, start=15, duration=4)
        self.failUnless(gap1 > gap2)
        self.failUnless(gap2 < gap1)

    def testFindAroundObject(self):
        timeline_object1 = self.makeTimelineObject()
        timeline_object2 = self.makeTimelineObject()

        timeline_object1.start = 5 * gst.SECOND
        timeline_object1.duration = 10 * gst.SECOND
        timeline_object2.start = 20 * gst.SECOND
        timeline_object2.duration = 10 * gst.SECOND

        left_gap, right_gap = Gap.findAroundObject(timeline_object1)
        self.failUnlessEqual(left_gap.left_object, None)
        self.failUnlessEqual(left_gap.right_object, timeline_object1)
        self.failUnlessEqual(left_gap.start, 0 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 5 * gst.SECOND)
        self.failUnlessEqual(right_gap.left_object, timeline_object1)
        self.failUnlessEqual(right_gap.right_object, timeline_object2)
        self.failUnlessEqual(right_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, 5 * gst.SECOND)

        left_gap, right_gap = Gap.findAroundObject(timeline_object2)
        self.failUnlessEqual(left_gap.left_object, timeline_object1)
        self.failUnlessEqual(left_gap.right_object, timeline_object2)
        self.failUnlessEqual(left_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 5 * gst.SECOND)
        self.failUnlessEqual(right_gap.left_object, timeline_object2)
        self.failUnlessEqual(right_gap.right_object, None)
        self.failUnlessEqual(right_gap.start, 30 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, infinity)

        # make the objects overlap
        timeline_object2.start = 10 * gst.SECOND
        left_gap, right_gap = Gap.findAroundObject(timeline_object1)
        self.failUnlessEqual(right_gap.left_object, timeline_object1)
        self.failUnlessEqual(right_gap.right_object, timeline_object2)
        self.failUnlessEqual(right_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, -5 * gst.SECOND)

    def testGapFinder(self):
        timeline_object1 = self.makeTimelineObject()
        timeline_object2 = self.makeTimelineObject()
        timeline_object3 = self.makeTimelineObject()
        timeline_object4 = self.makeTimelineObject()

        timeline_object1.start = 5 * gst.SECOND
        timeline_object1.duration = 10 * gst.SECOND
        timeline_object1.priority = 1

        timeline_object2.start = 20 * gst.SECOND
        timeline_object2.duration = 10 * gst.SECOND
        timeline_object2.priority = 1

        timeline_object3.start = 31 * gst.SECOND
        timeline_object3.duration = 10 * gst.SECOND
        timeline_object3.priority = 2

        timeline_object4.start = 50 * gst.SECOND
        timeline_object4.duration = 10 * gst.SECOND
        timeline_object4.priority = 2

        gap_finder = SmallestGapsFinder(
            set([timeline_object2, timeline_object3]))
        gap_finder.update(*Gap.findAroundObject(timeline_object2))
        gap_finder.update(*Gap.findAroundObject(timeline_object3))

        left_gap = gap_finder.left_gap
        right_gap = gap_finder.right_gap
        self.failUnlessEqual(left_gap.left_object, timeline_object1)
        self.failUnlessEqual(left_gap.right_object, timeline_object2)
        self.failUnlessEqual(left_gap.start, 15 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 5 * gst.SECOND)
        self.failUnlessEqual(right_gap.left_object, timeline_object3)
        self.failUnlessEqual(right_gap.right_object, timeline_object4)
        self.failUnlessEqual(right_gap.start, 41 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, 9 * gst.SECOND)

        # make timeline_object3 and timeline_object4 overlap
        timeline_object3.duration = 20 * gst.SECOND

        gap_finder = SmallestGapsFinder(set([timeline_object4]))
        gap_finder.update(*Gap.findAroundObject(timeline_object4))
        left_gap = gap_finder.left_gap
        right_gap = gap_finder.right_gap
        self.failUnlessEqual(left_gap, invalid_gap)
        self.failUnlessEqual(right_gap.left_object, timeline_object4)
        self.failUnlessEqual(right_gap.right_object, None)
        self.failUnlessEqual(right_gap.start, 60 * gst.SECOND)
        self.failUnlessEqual(right_gap.duration, infinity)

        gap_finder = SmallestGapsFinder(set([timeline_object3]))
        gap_finder.update(*Gap.findAroundObject(timeline_object3))
        left_gap = gap_finder.left_gap
        right_gap = gap_finder.right_gap
        self.failUnlessEqual(left_gap.left_object, None)
        self.failUnlessEqual(left_gap.right_object, timeline_object3)
        self.failUnlessEqual(left_gap.start, 0 * gst.SECOND)
        self.failUnlessEqual(left_gap.duration, 31 * gst.SECOND)
        self.failUnlessEqual(right_gap, invalid_gap)

    def testFindAllGaps(self):

        simple = ((3 * gst.SECOND, 1 * gst.SECOND), (1 * gst.SECOND,
                                                     1 * gst.SECOND))

        objs = []
        for start, duration in simple:
            obj = self.makeTimelineObject()
            obj.start = start
            obj.duration = duration
            objs.append(obj)

        result = [(g.start, g.initial_duration) for g in Gap.findAllGaps(objs)]

        self.assertEquals(result, [
            (0 * gst.SECOND, 1 * gst.SECOND),
            (2 * gst.SECOND, 1 * gst.SECOND),
        ])

        complex = [
            (1 * gst.SECOND, 2 * gst.SECOND),
            (6 * gst.SECOND, 2 * gst.SECOND),
            (10 * gst.SECOND, 2 * gst.SECOND),
            (8 * gst.SECOND, 2 * gst.SECOND),
            (14 * gst.SECOND, 1 * gst.SECOND),
            (4 * gst.SECOND, 1 * gst.SECOND),
        ]

        objs = []
        for start, duration in complex:
            obj = self.makeTimelineObject()
            obj.start = start
            obj.duration = duration
            objs.append(obj)

        result = [(g.start, g.initial_duration) for g in Gap.findAllGaps(objs)]

        self.assertEquals(result, [
            (0 * gst.SECOND, 1 * gst.SECOND),
            (3 * gst.SECOND, 1 * gst.SECOND),
            (5 * gst.SECOND, 1 * gst.SECOND),
            (12 * gst.SECOND, 2 * gst.SECOND),
        ])

        complex.append((2 * gst.SECOND, 5 * gst.SECOND))

        objs = []
        for start, duration in complex:
            obj = self.makeTimelineObject()
            obj.start = start
            obj.duration = duration
            objs.append(obj)

        result = [(g.start, g.initial_duration) for g in Gap.findAllGaps(objs)]

        self.assertEquals(result, [
            (0 * gst.SECOND, 1 * gst.SECOND),
            (12 * gst.SECOND, 2 * gst.SECOND),
        ])
예제 #6
0
class  TestTimelineUndo(TestCase):
    def setUp(self):
        self.stream = new_stream()
        self.factory = new_source_factory()
        self.effect_factory = TestEffectFactory(self.stream)
        self.track1 = Track(self.stream)
        self.track2 = Track(self.stream)
        self.timeline = Timeline()
        self.timeline.addTrack(self.track1)
        self.timeline.addTrack(self.track2)
        self.track_object1 = SourceTrackObject(self.factory, self.stream)
        self.track_object2 = SourceTrackObject(self.factory, self.stream)
        self.track_effect1 = TrackEffect(self.effect_factory, self.stream)
        self.track_effect2 = TrackEffect(self.effect_factory, self.stream)
        self.track1.addTrackObject(self.track_object1)
        self.track2.addTrackObject(self.track_object2)
        self.timeline_object1 = TimelineObject(self.factory)
        self.timeline_object1.addTrackObject(self.track_object1)
        self.timeline_object1.addTrackObject(self.track_object2)
        self.action_log = UndoableActionLog()
        self.observer = TestTimelineLogObserver(self.action_log)
        self.observer.startObserving(self.timeline)

    def testAddTimelineObject(self):
        stacks = []
        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)

        self.action_log.begin("add clip")
        self.timeline.addTimelineObject(self.timeline_object1)
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TimelineObjectAdded))

        self.failUnless(self.timeline_object1 \
                in self.timeline.timeline_objects)
        self.action_log.undo()
        self.failIf(self.timeline_object1 \
                in self.timeline.timeline_objects)

        self.action_log.redo()
        self.failUnless(self.timeline_object1 \
                in self.timeline.timeline_objects)

    def testRemoveTimelineObject(self):
        stacks = []
        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)

        self.timeline.addTimelineObject(self.timeline_object1)
        self.action_log.begin("remove clip")
        self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TimelineObjectRemoved))

        self.failIf(self.timeline_object1 \
                in self.timeline.timeline_objects)
        self.action_log.undo()
        self.failUnless(self.timeline_object1 \
                in self.timeline.timeline_objects)

        self.action_log.redo()
        self.failIf(self.timeline_object1 \
                in self.timeline.timeline_objects)

    def testAddEffectToTimelineObject(self):
        stacks = []
        pipeline = Pipeline()
        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)
        self.observer.pipeline = pipeline

        #FIXME Should I commit it and check there are 2 elements
        #in the stacks
        self.timeline.addTimelineObject(self.timeline_object1)
        self.track1.addTrackObject(self.track_effect1)

        self.action_log.begin("add effect")
        self.timeline_object1.addTrackObject(self.track_effect1)
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TrackEffectAdded))

        self.failUnless(self.track_effect1 \
                in self.timeline_object1.track_objects)
        self.failUnless(self.track_effect1 \
                in self.track1.track_objects)
        self.failUnless(len([effect for effect in \
                                self.timeline_object1.track_objects
                                if isinstance(effect, TrackEffect)]) == 1)
        self.failUnless(len([effect for effect in self.track1.track_objects
                             if isinstance(effect, TrackEffect)]) == 1)

        self.action_log.undo()
        self.failIf(self.track_effect1 \
                in self.timeline_object1.track_objects)
        self.failIf(self.track_effect1 \
                in self.track1.track_objects)

        self.action_log.redo()
        self.failUnless(len([effect for effect in
                                self.timeline_object1.track_objects
                                if isinstance(effect, TrackEffect)]) == 1)
        self.failUnless(len([effect for effect in self.track1.track_objects
                             if isinstance(effect, TrackEffect)]) == 1)

        self.timeline.removeTimelineObject(self.timeline_object1, deep=True)

    def testTimelineObjectPropertyChange(self):
        stacks = []
        def commitCb(action_log, stack, nested):
            stacks.append(stack)
        self.action_log.connect("commit", commitCb)

        self.timeline_object1.start = 5 * gst.SECOND
        self.timeline_object1.duration = 20 * gst.SECOND
        self.timeline.addTimelineObject(self.timeline_object1)
        self.action_log.begin("modify clip")
        self.timeline_object1.start = 10 * gst.SECOND
        self.action_log.commit()

        self.failUnlessEqual(len(stacks), 1)
        stack = stacks[0]
        self.failUnlessEqual(len(stack.done_actions), 1)
        action = stack.done_actions[0]
        self.failUnless(isinstance(action, TimelineObjectPropertyChanged))

        self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)
        self.action_log.undo()
        self.failUnlessEqual(self.timeline_object1.start, 5 * gst.SECOND)
        self.action_log.redo()
        self.failUnlessEqual(self.timeline_object1.start, 10 * gst.SECOND)

        self.timeline_object1.priority = 10
        self.action_log.begin("priority change")
        self.timeline_object1.priority = 20
        self.action_log.commit()

        self.failUnlessEqual(self.timeline_object1.priority, 20)
        self.action_log.undo()
        self.failUnlessEqual(self.timeline_object1.priority, 10)
        self.action_log.redo()
        self.failUnlessEqual(self.timeline_object1.priority, 20)

    def testUngroup(self):
        self.timeline_object1.start = 5 * gst.SECOND
        self.timeline_object1.duration = 20 * gst.SECOND

        self.timeline.addTimelineObject(self.timeline_object1)
        self.timeline.setSelectionToObj(self.track_object1, SELECT_ADD)

        self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
        self.failUnlessEqual(self.timeline.timeline_objects[0].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
                20 * gst.SECOND)

        self.action_log.begin("ungroup")
        self.timeline.ungroupSelection()
        self.action_log.commit()

        self.failUnlessEqual(len(self.timeline.timeline_objects), 2)
        self.failUnlessEqual(self.timeline.timeline_objects[0].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
                20 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[1].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[1].duration,
                20 * gst.SECOND)

        self.action_log.undo()

        self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
        self.failUnlessEqual(self.timeline.timeline_objects[0].start,
                5 * gst.SECOND)
        self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
                20 * gst.SECOND)