本文整理汇总了Python中pitivi.undo.undo.UndoableActionLog类的典型用法代码示例。如果您正苦于以下问题：Python UndoableActionLog类的具体用法？Python UndoableActionLog怎么用？Python UndoableActionLog使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了UndoableActionLog类的14个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
def __init__(self):
Loggable.__init__(self)
# Init logging as early as possible so we can log startup code
enable_color = not os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '1')
# Let's show a human-readable pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
self.settings = GlobalSettings()
self.threads = ThreadMaster()
self.effects = EffectsHandler()
self.system = getSystem()
self.current_project = None
self.projectManager = ProjectManager(self)
self._connectToProjectManager(self.projectManager)
self.action_log = UndoableActionLog()
self.debug_action_log_observer = DebugActionLogObserver()
self.debug_action_log_observer.startObserving(self.action_log)
# TODO reimplement the observing after GES port
#self.timelineLogObserver = TimelineLogObserver(self.action_log)
self.projectLogObserver = ProjectLogObserver(self.action_log)
self._version_information = {}
self._checkVersion()示例2: setUp
def setUp(self):
self.timeline = GES.Timeline.new_audio_video()
self.layer = GES.Layer()
self.timeline.add_layer(self.layer)
self.action_log = UndoableActionLog()
self.observer = TimelineLogObserverSpy(self.action_log)
self.observer.startObserving(self.timeline)示例3: __init__
def __init__(self):
Gtk.Application.__init__(self,
application_id="org.pitivi",
flags=Gio.ApplicationFlags.HANDLES_OPEN)
Loggable.__init__(self)
self.settings = None
self.threads = None
self.effects = None
self.system = None
self.project_manager = ProjectManager(self)
self.action_log = UndoableActionLog(self)
self.timeline_log_observer = None
self.project_log_observer = None
self._last_action_time = Gst.util_get_timestamp()
self.gui = None
self.welcome_wizard = None
self._version_information = {}
self._scenario_file = None
self._first_action = True
Zoomable.app = self
self.connect("startup", self._startupCb)
self.connect("activate", self._activateCb)
self.connect("open", self.openCb)示例4: _startupCb
def _startupCb(self, unused_app):
# Init logging as early as possible so we can log startup code
enable_color = not os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '1')
# Let's show a human-readable Pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
self.settings = GlobalSettings()
self.threads = ThreadMaster()
self.effects = EffectsHandler()
self.system = getSystem()
self.action_log = UndoableActionLog()
self.action_log.connect("commit", self._actionLogCommit)
self.action_log.connect("undo", self._actionLogUndo)
self.action_log.connect("redo", self._actionLogRedo)
self.action_log.connect("cleaned", self._actionLogCleaned)
self.timeline_log_observer = TimelineLogObserver(self.action_log)
self.project_log_observer = ProjectLogObserver(self.action_log)
self.project_manager.connect("new-project-loaded", self._newProjectLoaded)
self.project_manager.connect("project-closed", self._projectClosed)
self._createActions()
self._checkVersion()示例5: setUp
def setUp(self):
app = Pitivi()
app._startupCb(app)
app.project_manager.newBlankProject()
self.timeline = app.project_manager.current_project.timeline
self.layer = GES.Layer()
self.timeline.add_layer(self.layer)
self.action_log = UndoableActionLog()
self.observer = TimelineLogObserverSpy(self.action_log)
self.observer.startObserving(self.timeline)示例6: __init__
def __init__(self):
"""
initialize pitivi with the command line arguments
"""
Loggable.__init__(self)
# init logging as early as possible so we can log startup code
enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
# Let's show a human-readable pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
# store ourself in the instance global
if instance.PiTiVi:
raise RuntimeWarning(_("There is already a %s instance, please inform "
"the developers by filing a bug at "
"http://bugzilla.gnome.org/enter_bug.cgi?product=pitivi")
% APPNAME)
instance.PiTiVi = self
self.current = None
# get settings
self.settings = GlobalSettings()
self.threads = ThreadMaster()
#self.screencast = False
self.effects = EffectsHandler()
self.system = getSystem()
self.projectManager = ProjectManager(self.effects)
self._connectToProjectManager(self.projectManager)
self.action_log = UndoableActionLog()
self.debug_action_log_observer = DebugActionLogObserver()
self.debug_action_log_observer.startObserving(self.action_log)
# TODO reimplement the observing after GES port
#self.timelineLogObserver = TimelineLogObserver(self.action_log)
self.projectLogObserver = ProjectLogObserver(self.action_log)
self.medialibrary_log_observer = MediaLibraryLogObserver(self.action_log)
self.version_information = {}
self._checkVersion()示例7: Pitivi
class Pitivi(Loggable, Signallable):
"""
Pitivi's main application class.
Signals:
- C{new-project} : A new C{Project} is loaded and ready to use.
- C{new-project-loading} : Pitivi is attempting to load a new project.
- C{new-project-loaded} : A new L{Project} has been loaded, and the UI should refresh it's view.
- C{new-project-failed} : A new L{Project} failed to load.
- C{closing-project} : pitivi would like to close a project. handlers should return false
if they do not want this project to close. by default, assumes
true. This signal should only be used by classes that might want to abort
the closing of a project.
- C{project-closed} : The project is closed, it will be freed when the callback returns.
Classes should connect to this instance when they want to know that
data related to that project is no longer going to be used.
- C{shutdown} : Used internally, do not use this signal.`
@ivar settings: Application-wide settings.
@type settings: L{GlobalSettings}.
@ivar current: Currently used project.
@type current: L{Project}.
"""
__signals__ = {
"new-project": ["project"],
"new-project-loading": ["uri"],
"new-project-created": ["project"],
"new-project-loaded": ["project"],
"new-project-failed": ["uri", "exception"],
"closing-project": ["project"],
"project-closed": ["project"],
"missing-uri": ["formatter", "uri"],
"version-info-received": ["versions"],
"shutdown": None}
def __init__(self):
"""
initialize pitivi with the command line arguments
"""
Loggable.__init__(self)
# init logging as early as possible so we can log startup code
enable_color = os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '0')
# Let's show a human-readable pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
# store ourself in the instance global
if instance.PiTiVi:
raise RuntimeWarning(_("There is already a %s instance, please inform "
"the developers by filing a bug at "
"http://bugzilla.gnome.org/enter_bug.cgi?product=pitivi")
% APPNAME)
instance.PiTiVi = self
self.current = None
# get settings
self.settings = GlobalSettings()
self.threads = ThreadMaster()
#self.screencast = False
self.effects = EffectsHandler()
self.system = getSystem()
self.projectManager = ProjectManager(self.effects)
self._connectToProjectManager(self.projectManager)
self.action_log = UndoableActionLog()
self.debug_action_log_observer = DebugActionLogObserver()
self.debug_action_log_observer.startObserving(self.action_log)
# TODO reimplement the observing after GES port
#self.timelineLogObserver = TimelineLogObserver(self.action_log)
self.projectLogObserver = ProjectLogObserver(self.action_log)
self.medialibrary_log_observer = MediaLibraryLogObserver(self.action_log)
self.version_information = {}
self._checkVersion()
def shutdown(self):
"""
Close PiTiVi.
@return: C{True} if PiTiVi was successfully closed, else C{False}.
@rtype: C{bool}
"""
self.debug("shutting down")
# we refuse to close if we're running a user interface and the user
# doesn't want us to close the current project.
if self.current and not self.projectManager.closeRunningProject():
self.warning("Not closing since running project doesn't want to close")
return False
self.threads.stopAllThreads()
self.settings.storeSettings()
self.current = None
#.........这里部分代码省略.........
示例8: TestTimelineUndo
class TestTimelineUndo(TestCase):
def setUp(self):
app = Pitivi()
app._startupCb(app)
app.project_manager.newBlankProject()
self.timeline = app.project_manager.current_project.timeline
self.layer = GES.Layer()
self.timeline.add_layer(self.layer)
self.action_log = UndoableActionLog()
self.observer = TimelineLogObserverSpy(self.action_log)
self.observer.startObserving(self.timeline)
def getTimelineClips(self):
for layer in self.timeline.layers:
for clip in layer.get_clips():
yield clip
@staticmethod
def commitCb(action_log, stack, nested, stacks):
stacks.append(stack)
def testAddClip(self):
stacks = []
self.action_log.connect("commit", TestTimelineUndo.commitCb, stacks)
clip1 = GES.TitleClip()
self.action_log.begin("add clip")
self.layer.add_clip(clip1)
self.action_log.commit()
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions))
action = stack.done_actions[0]
self.assertTrue(isinstance(action, ClipAdded))
self.assertTrue(clip1 in self.getTimelineClips())
self.action_log.undo()
self.assertFalse(clip1 in self.getTimelineClips())
self.action_log.redo()
self.assertTrue(clip1 in self.getTimelineClips())
def testRemoveClip(self):
stacks = []
self.action_log.connect("commit", TestTimelineUndo.commitCb, stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
self.action_log.begin("remove clip")
self.layer.remove_clip(clip1)
self.action_log.commit()
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions))
action = stack.done_actions[0]
self.assertTrue(isinstance(action, ClipRemoved))
self.assertFalse(clip1 in self.getTimelineClips())
self.action_log.undo()
self.assertTrue(clip1 in self.getTimelineClips())
self.action_log.redo()
self.assertFalse(clip1 in self.getTimelineClips())
def testAddEffectToClip(self):
stacks = []
self.action_log.connect("commit", TestTimelineUndo.commitCb, stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
self.action_log.begin("add effect")
clip1.add(effect1)
self.action_log.commit()
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions), stack.done_actions)
action = stack.done_actions[0]
self.assertTrue(isinstance(action, TrackElementAdded))
self.assertTrue(effect1 in clip1.get_children(True))
self.assertEqual(1, len([effect for effect in
clip1.get_children(True)
if isinstance(effect, GES.Effect)]))
self.action_log.undo()
self.assertFalse(effect1 in clip1.get_children(True))
self.action_log.redo()
self.assertEqual(1, len([effect for effect in
clip1.get_children(True)
if isinstance(effect, GES.Effect)]))
def testRemoveEffectFromClip(self):
#.........这里部分代码省略.........
示例9: Pitivi
class Pitivi(Loggable, Signallable):
"""
Pitivi's main application class.
Signals:
- C{new-project} : A new C{Project} is loaded and ready to use.
- C{new-project-loading} : Pitivi is attempting to load a new project.
- C{new-project-loaded} : A new L{Project} has been loaded, and the UI should refresh it's view.
- C{new-project-failed} : A new L{Project} failed to load.
- C{project-closed} : The project is closed, it will be freed when the callback returns.
Classes should connect to this instance when they want to know that
data related to that project is no longer going to be used.
- C{shutdown} : Used internally, do not use this signal.`
@ivar settings: Application-wide settings.
@type settings: L{GlobalSettings}.
@ivar current: Currently used project.
@type current: L{Project}.
"""
__signals__ = {
"new-project": ["project"],
"new-project-loading": ["uri"],
"new-project-created": ["project"],
"new-project-loaded": ["project"],
"new-project-failed": ["uri", "exception"],
"project-closed": ["project"],
"missing-uri": ["formatter", "uri"],
"version-info-received": ["versions"],
"shutdown": None}
def __init__(self):
Loggable.__init__(self)
# Init logging as early as possible so we can log startup code
enable_color = not os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '1')
# Let's show a human-readable pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
self.settings = GlobalSettings()
self.threads = ThreadMaster()
self.effects = EffectsHandler()
self.system = getSystem()
self.current_project = None
self.projectManager = ProjectManager(self)
self._connectToProjectManager(self.projectManager)
self.action_log = UndoableActionLog()
self.debug_action_log_observer = DebugActionLogObserver()
self.debug_action_log_observer.startObserving(self.action_log)
# TODO reimplement the observing after GES port
#self.timelineLogObserver = TimelineLogObserver(self.action_log)
self.projectLogObserver = ProjectLogObserver(self.action_log)
self._version_information = {}
self._checkVersion()
def shutdown(self):
"""
Close Pitivi.
@return: C{True} if Pitivi was successfully closed, else C{False}.
@rtype: C{bool}
"""
self.debug("shutting down")
# we refuse to close if we're running a user interface and the user
# doesn't want us to close the current project.
if self.current_project and not self.projectManager.closeRunningProject():
self.warning("Not closing since running project doesn't want to close")
return False
self.threads.stopAllThreads()
self.settings.storeSettings()
self.current_project = None
self.emit("shutdown")
return True
def _connectToProjectManager(self, projectManager):
pm = projectManager
pm.connect("new-project-loading", self._projectManagerNewProjectLoading)
pm.connect("new-project-created", self._projectManagerNewProjectCreated)
pm.connect("new-project-loaded", self._projectManagerNewProjectLoaded)
pm.connect("new-project-failed", self._projectManagerNewProjectFailed)
pm.connect("project-closed", self._projectManagerProjectClosed)
def _projectManagerNewProjectLoading(self, unused_project_manager, uri):
self.emit("new-project-loading", uri)
def _projectManagerNewProjectCreated(self, unused_project_manager, project):
self.current_project = project
self.emit("new-project-created", project)
def _newProjectLoaded(self, unused_project):
pass
#.........这里部分代码省略.........
示例10: Pitivi
class Pitivi(Gtk.Application, Loggable):
"""
Pitivi's application.
@type effects: L{EffectsManager}
@ivar gui: The main window of the app.
@type gui: L{PitiviMainWindow}
@ivar project_manager: The project manager object used in the application
@type project_manager: L{ProjectManager}
@ivar settings: Application-wide settings.
@type settings: L{GlobalSettings}.
"""
__gsignals__ = {
"version-info-received": (GObject.SIGNAL_RUN_LAST, None, (object,))
}
def __init__(self):
Gtk.Application.__init__(self,
application_id="org.pitivi",
flags=Gio.ApplicationFlags.HANDLES_OPEN)
Loggable.__init__(self)
self.settings = None
self.threads = None
self.effects = None
self.system = None
self.project_manager = ProjectManager(self)
self.action_log = UndoableActionLog(self)
self.timeline_log_observer = None
self.project_log_observer = None
self._last_action_time = Gst.util_get_timestamp()
self.gui = None
self.welcome_wizard = None
self._version_information = {}
self._scenario_file = None
self._first_action = True
self.connect("startup", self._startupCb)
self.connect("activate", self._activateCb)
self.connect("open", self.openCb)
def write_action(self, action, properties={}):
if self._first_action:
self._scenario_file.write(
"description, seek=true, handles-states=true\n")
self._first_action = False
now = Gst.util_get_timestamp()
if now - self._last_action_time > 0.05 * Gst.SECOND:
# We need to make sure that the waiting time was more than 50 ms.
st = Gst.Structure.new_empty("wait")
st["duration"] = float((now - self._last_action_time) / Gst.SECOND)
self._scenario_file.write(st.to_string() + "\n")
self._last_action_time = now
if not isinstance(action, Gst.Structure):
structure = Gst.Structure.new_empty(action)
for key, value in properties.items():
structure[key] = value
action = structure
self._scenario_file.write(action.to_string() + "\n")
self._scenario_file.flush()
def _startupCb(self, unused_app):
# Init logging as early as possible so we can log startup code
enable_color = not os.environ.get(
'PITIVI_DEBUG_NO_COLOR', '0') in ('', '1')
# Let's show a human-readable Pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
self.settings = GlobalSettings()
self.threads = ThreadMaster()
self.effects = EffectsManager()
self.system = getSystem()
self.action_log.connect("commit", self._actionLogCommit)
self.action_log.connect("undo", self._actionLogUndo)
self.action_log.connect("redo", self._actionLogRedo)
self.action_log.connect("cleaned", self._actionLogCleaned)
self.timeline_log_observer = TimelineLogObserver(self.action_log)
self.project_log_observer = ProjectLogObserver(self.action_log)
self.project_manager.connect(
"new-project-loading", self._newProjectLoadingCb)
self.project_manager.connect(
"new-project-loaded", self._newProjectLoaded)
self.project_manager.connect("project-closed", self._projectClosed)
#.........这里部分代码省略.........
示例11: Pitivi
class Pitivi(Gtk.Application, Loggable):
"""
Pitivi's application.
@type effects: L{EffectsManager}
@ivar gui: The main window of the app.
@type gui: L{PitiviMainWindow}
@ivar project_manager: The project manager object used in the application
@type project_manager: L{ProjectManager}
@ivar settings: Application-wide settings.
@type settings: L{GlobalSettings}.
"""
__gsignals__ = {
"version-info-received": (GObject.SIGNAL_RUN_LAST, None, (object,))
}
def __init__(self):
Gtk.Application.__init__(self,
application_id="org.pitivi",
flags=Gio.ApplicationFlags.HANDLES_OPEN)
Loggable.__init__(self)
self.settings = None
self.threads = None
self.effects = None
self.system = None
self.project_manager = ProjectManager(self)
self.action_log = UndoableActionLog()
self.timeline_log_observer = None
self.project_log_observer = None
self.gui = None
self.welcome_wizard = None
self._version_information = {}
self.connect("startup", self._startupCb)
self.connect("activate", self._activateCb)
self.connect("open", self.openCb)
def _startupCb(self, unused_app):
# Init logging as early as possible so we can log startup code
enable_color = not os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '1')
# Let's show a human-readable Pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
self.settings = GlobalSettings()
self.threads = ThreadMaster()
self.effects = EffectsManager()
self.system = getSystem()
self.action_log.connect("commit", self._actionLogCommit)
self.action_log.connect("undo", self._actionLogUndo)
self.action_log.connect("redo", self._actionLogRedo)
self.action_log.connect("cleaned", self._actionLogCleaned)
self.timeline_log_observer = TimelineLogObserver(self.action_log)
self.project_log_observer = ProjectLogObserver(self.action_log)
self.project_manager.connect("new-project-loaded", self._newProjectLoaded)
self.project_manager.connect("project-closed", self._projectClosed)
self._createActions()
self._checkVersion()
def _createActions(self):
self.undo_action = Gio.SimpleAction.new("undo", None)
self.undo_action.connect("activate", self._undoCb)
self.add_action(self.undo_action)
self.add_accelerator("<Control>z", "app.undo", None)
self.redo_action = Gio.SimpleAction.new("redo", None)
self.redo_action.connect("activate", self._redoCb)
self.add_action(self.redo_action)
self.add_accelerator("<Control><Shift>z", "app.redo", None)
self.quit_action = Gio.SimpleAction.new("quit", None)
self.quit_action.connect("activate", self._quitCb)
self.add_action(self.quit_action)
self.add_accelerator("<Control>q", "app.quit", None)
def _activateCb(self, unused_app):
if self.gui:
# The app is already started and the window already created.
# Present the already existing window.
# TODO: Use present() instead of present_with_time() when
# https://bugzilla.gnome.org/show_bug.cgi?id=688830 is fixed.
x11_server_time = GdkX11.x11_get_server_time(self.gui.get_window())
self.gui.present_with_time(x11_server_time)
# No need to show the welcome wizard.
return
self.createMainWindow()
self.welcome_wizard = StartUpWizard(self)
self.welcome_wizard.show()
def createMainWindow(self):
#.........这里部分代码省略.........
示例12: TestUndoableActionLog
class TestUndoableActionLog(TestCase):
def setUp(self):
self.log = UndoableActionLog()
self._connectToUndoableActionLog(self.log)
self.signals = []
def tearDown(self):
self._disconnectFromUndoableActionLog(self.log)
def _undoActionLogSignalCb(self, log, *args):
args = list(args)
signalName = args.pop(-1)
self.signals.append((signalName, args))
def _connectToUndoableActionLog(self, log):
for signalName in ("begin", "push", "rollback", "commit", "move"):
log.connect(signalName, self._undoActionLogSignalCb, signalName)
def _disconnectFromUndoableActionLog(self, log):
self.log.disconnect_by_func(self._undoActionLogSignalCb)
def testRollbackWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.rollback)
def testCommitWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.commit, "")
def testPushWrongState(self):
# no error in this case
self.log.push(None)
def testUndoWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.undo)
def testRedoWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.redo)
def testCheckpoint(self):
self.log.begin("meh")
self.log.push(mock.Mock(spec=UndoableAction))
self.assertRaises(UndoWrongStateError, self.log.checkpoint)
self.log.rollback()
self.log.checkpoint()
self.assertNotEqual(self.log._checkpoint, None)
def testDirty(self):
self.assertFalse(self.log.dirty())
self.log.begin("meh")
self.log.push(mock.Mock(spec=UndoableAction))
self.log.commit("meh")
self.assertTrue(self.log.dirty())
self.log.checkpoint()
self.assertFalse(self.log.dirty())
self.log.undo()
self.assertTrue(self.log.dirty())
self.log.redo()
self.assertFalse(self.log.dirty())
def testCommit(self):
"""
Commit a stack.
"""
self.assertEqual(len(self.log.undo_stacks), 0)
self.assertEqual(len(self.log.redo_stacks), 0)
self.log.begin("meh")
self.assertEqual(len(self.signals), 1)
name, (stack,) = self.signals[0]
self.assertEqual(name, "begin")
self.assertTrue(self.log.is_in_transaction())
self.assertEqual(self.log.undo_stacks, [])
self.log.push(mock.Mock(spec=UndoableAction))
self.log.commit("meh")
self.assertEqual(len(self.signals), 3)
name, (stack, action) = self.signals[1]
self.assertEqual(name, "push")
name, (stack,) = self.signals[2]
self.assertEqual(name, "commit")
self.assertFalse(self.log.is_in_transaction())
self.assertEqual(len(self.log.undo_stacks), 1)
self.assertEqual(len(self.log.redo_stacks), 0)
def test_commit_proper(self):
self.log.begin("meh")
self.assertRaises(UndoWrongStateError, self.log.commit, "notmeh")
def testNestedCommit(self):
"""
Do two nested commits.
"""
self.assertEqual(len(self.log.undo_stacks), 0)
self.assertEqual(len(self.log.redo_stacks), 0)
self.log.begin("meh")
self.assertEqual(len(self.signals), 1)
name, (stack,) = self.signals[0]
self.assertEqual(name, "begin")
self.assertTrue(self.log.is_in_transaction())
self.assertEqual(len(self.log.undo_stacks), 0)
#.........这里部分代码省略.........
示例13: setUp
def setUp(self):
self.log = UndoableActionLog()
self._connectToUndoableActionLog(self.log)
self.signals = []示例14: TestUndoableActionLog
class TestUndoableActionLog(TestCase):
def setUp(self):
self.log = UndoableActionLog()
self._connectToUndoableActionLog(self.log)
self.signals = []
def tearDown(self):
self._disconnectFromUndoableActionLog(self.log)
def _undoActionLogSignalCb(self, log, *args):
args = list(args)
signalName = args.pop(-1)
self.signals.append((signalName, args))
def _connectToUndoableActionLog(self, log):
for signalName in ("begin", "push", "rollback", "commit",
"undo", "redo"):
log.connect(signalName, self._undoActionLogSignalCb, signalName)
def _disconnectFromUndoableActionLog(self, log):
self.log.disconnect_by_func(self._undoActionLogSignalCb)
def testRollbackWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.rollback)
def testCommitWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.commit)
def testPushWrongState(self):
# no error in this case
self.log.push(None)
def testUndoWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.undo)
def testRedoWrongState(self):
self.assertRaises(UndoWrongStateError, self.log.redo)
def testCheckpoint(self):
self.log.begin("meh")
self.log.push(DummyUndoableAction())
self.assertRaises(UndoWrongStateError, self.log.checkpoint)
self.log.rollback()
self.log.checkpoint()
self.assertNotEqual(self.log._checkpoint, None)
def testDirty(self):
self.assertFalse(self.log.dirty())
self.log.begin("meh")
self.log.push(DummyUndoableAction())
self.log.commit()
self.assertTrue(self.log.dirty())
self.log.checkpoint()
self.assertFalse(self.log.dirty())
self.log.undo()
self.assertTrue(self.log.dirty())
self.log.redo()
self.assertFalse(self.log.dirty())
def testCommit(self):
"""
Commit a stack.
"""
self.assertEqual(len(self.log.undo_stacks), 0)
self.assertEqual(len(self.log.redo_stacks), 0)
self.log.begin("meh")
self.assertEqual(len(self.signals), 1)
name, (stack, nested) = self.signals[0]
self.assertEqual(name, "begin")
self.assertFalse(nested)
self.assertEqual(self.log.undo_stacks, [])
self.log.commit()
self.assertEqual(len(self.signals), 2)
name, (stack, nested) = self.signals[1]
self.assertEqual(name, "commit")
self.assertFalse(nested)
self.assertEqual(len(self.log.undo_stacks), 1)
self.assertEqual(len(self.log.redo_stacks), 0)
def testNestedCommit(self):
"""
Do two nested commits.
"""
self.assertEqual(len(self.log.undo_stacks), 0)
self.assertEqual(len(self.log.redo_stacks), 0)
self.log.begin("meh")
self.assertEqual(len(self.signals), 1)
name, (stack, nested) = self.signals[0]
self.assertEqual(name, "begin")
self.assertFalse(nested)
self.assertEqual(len(self.log.undo_stacks), 0)
self.assertEqual(len(self.log.redo_stacks), 0)
self.log.begin("nested")
self.assertEqual(len(self.signals), 2)
name, (stack, nested) = self.signals[1]
self.assertEqual(name, "begin")
self.assertTrue(nested)
#.........这里部分代码省略.........