Python pub.sendMessage函数代码示例

 def setFilename(self, filename):
     if filename == self.__filename:
         return
     self.__lastFilename = filename or self.__filename
     self.__filename = filename
     self.__notifier.setFilename(filename)
     pub.sendMessage('taskfile.filenameChanged', filename=filename)

    def save(self):
        try:
            pub.sendMessage('taskfile.aboutToSave', taskFile=self)
        except:
            pass
        # When encountering a problem while saving (disk full,
        # computer on fire), if we were writing directly to the file,
        # it's lost. So write to a temporary file and rename it if
        # everything went OK.
        self.__saving = True
        try:
            self.mergeDiskChanges()

            if self.__needSave or not os.path.exists(self.__filename):
                fd = self._openForWrite()
                try:
                    xml.XMLWriter(fd).write(self.tasks(), self.categories(), self.notes(),
                                            self.syncMLConfig(), self.guid())
                finally:
                    fd.close()

            self.markClean()
        finally:
            self.__saving = False
            self.__notifier.saved()
            try:
                pub.sendMessage('taskfile.justSaved', taskFile=self)
            except:
                pass

 def __show_effort_aggregation(self, aggregation):
     ''' Change the aggregation mode. Can be one of 'details', 'day', 'week'
         and 'month'. '''
     assert aggregation in ('details', 'day', 'week', 'month')
     self.aggregation = aggregation
     self.setPresentation(self.createSorter(self.createFilter(\
                          self.domainObjectsToView())))
     self.secondRefresher.updatePresentation()
     self.registerPresentationObservers()
     # Invalidate the UICommands used for the column popup menu:
     self.__columnUICommands = None
     # Clear the selection to remove the cached selection
     self.clear_selection()
     # If the widget is auto-resizing columns, turn it off temporarily to 
     # make removing/adding columns faster
     autoResizing = self.widget.IsAutoResizing()
     if autoResizing:
         self.widget.ToggleAutoResizing(False)
     # Refresh first so that the list control doesn't think there are more
     # efforts than there really are when switching from aggregate mode to
     # detail mode.
     self.refresh()
     self._showWeekdayColumns(show=aggregation == 'week')
     self._showTotalColumns(show=aggregation != 'details')
     if autoResizing:
         self.widget.ToggleAutoResizing(True)
     self.__initRoundingToolBarUICommands()
     pub.sendMessage('effortviewer.aggregation')

 def _refresh(self, clear=False):
     if clear:
         self.__domainObjectsToView = None
     self.setPresentation(self.createSorter(self.createFilter(self.domainObjectsToView())))
     self.secondRefresher.updatePresentation()
     self.registerPresentationObservers()
     # Invalidate the UICommands used for the column popup menu:
     self.__columnUICommands = None
     # Clear the selection to remove the cached selection
     self.clear_selection()
     # If the widget is auto-resizing columns, turn it off temporarily to
     # make removing/adding columns faster
     autoResizing = self.widget.IsAutoResizing()
     if autoResizing:
         self.widget.ToggleAutoResizing(False)
     # Refresh first so that the list control doesn't think there are more
     # efforts than there really are when switching from aggregate mode to
     # detail mode.
     self.refresh()
     self._showWeekdayColumns(show=self.aggregation == "week")
     self._showTotalColumns(show=self.aggregation != "details")
     if autoResizing:
         self.widget.ToggleAutoResizing(True)
     self.__initRoundingToolBarUICommands()
     pub.sendMessage("effortviewer.aggregation")

 def reset(self, forceEvent=False):
     ''' reset does the actual sorting. If the order of the list changes, 
         observers are notified by means of the list-sorted event. '''
     oldSelf = self[:]
     self.sort(key=self.createSortKeyFunction(), 
               reverse=not self._sortAscending)
     if forceEvent or self != oldSelf:
         pub.sendMessage(self.sortEventType(), sender=self)

 def __extend_self_with_composites(self, new_composites, event=None):
     ''' Add composites to the aggregator. '''
     super(EffortAggregator, self).extendSelf(new_composites, event=event)
     for new_composite in new_composites:
         if new_composite.isBeingTracked():
             self.__trackedComposites.add(new_composite)
             pub.sendMessage(effort.Effort.trackingChangedEventType(),
                             newValue=True, sender=new_composite)

    def load(self, filename=None):
        pub.sendMessage('taskfile.aboutToRead', taskFile=self)
        self.__loading = True
        if filename:
            self.setFilename(filename)
        try:
            if self.exists():
                fd = self._openForRead()
                try:
                    tasks, categories, notes, syncMLConfig, changes, guid = self._read(fd)
                finally:
                    fd.close()
            else:
                tasks = []
                categories = []
                notes = []
                changes = dict()
                guid = generate()
                syncMLConfig = createDefaultSyncConfig(guid)
            self.clear()
            self.__monitor.reset()
            self.__changes = changes
            self.__changes[self.__monitor.guid()] = self.__monitor
            self.categories().extend(categories)
            self.tasks().extend(tasks)
            self.notes().extend(notes)
            def registerOtherObjects(objects):
                for obj in objects:
                    if isinstance(obj, base.CompositeObject):
                        registerOtherObjects(obj.children())
                    if isinstance(obj, note.NoteOwner):
                        registerOtherObjects(obj.notes())
                    if isinstance(obj, attachment.AttachmentOwner):
                        registerOtherObjects(obj.attachments())
                    if isinstance(obj, task.Task):
                        registerOtherObjects(obj.efforts())
                    if isinstance(obj, note.Note) or \
                           isinstance(obj, attachment.Attachment) or \
                           isinstance(obj, effort.Effort):
                        self.__monitor.setChanges(obj.id(), set())
            registerOtherObjects(self.categories().rootItems())
            registerOtherObjects(self.tasks().rootItems())
            registerOtherObjects(self.notes().rootItems())
            self.__monitor.resetAllChanges()
            self.__syncMLConfig = syncMLConfig
            self.__guid = guid

            if os.path.exists(self.filename()):
                # We need to reset the changes on disk because we're up to date.
                xml.ChangesXMLWriter(file(self.filename() + '.delta', 'wb')).write(self.__changes)
        except:
            self.setFilename('')
            raise
        finally:
            self.__loading = False
            self.markClean()
            self.__changedOnDisk = False
            pub.sendMessage('taskfile.justRead', taskFile=self)

 def clear(self, regenerate=True, event=None):
     pub.sendMessage('taskfile.aboutToClear', taskFile=self)
     try:
         self.tasks().clear(event=event)
         self.categories().clear(event=event)
         self.notes().clear(event=event)
         if regenerate:
             self.__guid = generate()
             self.__syncMLConfig = createDefaultSyncConfig(self.__guid)
     finally:
         pub.sendMessage('taskfile.justCleared', taskFile=self)

 def setStart(self, startDateTime):
     if startDateTime == self._start:
         return
     self._start = startDateTime
     self.__updateDurationCache()
     pub.sendMessage(self.startChangedEventType(), newValue=startDateTime,
                     sender=self)
     self.task().sendTimeSpentChangedMessage()
     self.sendDurationChangedMessage()
     if self.task().hourlyFee():
         self.sendRevenueChangedMessage()

 def expand(self, expand=True, context='None', notify=True):
     ''' Expands (or collapses) the composite object in the specified 
         context. ''' 
     if expand == self.isExpanded(context):
         return
     if expand:
         self.__expandedContexts.add(context)
     else:
         self.__expandedContexts.discard(context)
     if notify:
         pub.sendMessage(self.expansionChangedEventType(), newValue=expand,
                         sender=self)

    def save(self):
        pickle.dump([name for task, name in self._templates], file(os.path.join(self._path, 'list.pickle'), 'wb'))

        for task, name in self._templates:
            templateFile = file(os.path.join(self._path, name), 'w')
            writer = TemplateXMLWriter(templateFile)
            writer.write(task)
            templateFile.close()

        for task, name in self._toDelete:
            os.remove(os.path.join(self._path, name))
        self._toDelete = []
        pub.sendMessage('templates.saved')

    def reset(self, forceEvent=False):
        ''' reset does the actual sorting. If the order of the list changes, 
            observers are notified by means of the list-sorted event. '''
        if self.isFrozen():
            return

        oldSelf = self[:]
        # XXXTODO: create only one function with all keys ? Reversing may
        # be problematic.
        for sortKey in reversed(self._sortKeys):
            self.sort(key=self.createSortKeyFunction(sortKey.lstrip('-')), reverse=sortKey.startswith('-'))
        if forceEvent or self != oldSelf:
            pub.sendMessage(self.sortEventType(), sender=self)

 def extendSelf(self, tasks, event=None):
     ''' This method is called when a task is added to the observed list.
         It overrides ObservableListObserver.extendSelf whose default 
         behaviour is to add the item that is added to the observed 
         list to the observing list (this list) unchanged. But we want to 
         add the efforts of the tasks, rather than the tasks themselves. '''
     effortsToAdd = []
     for task in tasks:
         effortsToAdd.extend(task.efforts())
     super(EffortList, self).extendSelf(effortsToAdd, event)
     for effort in effortsToAdd:
         if effort.getStop() is None:
             pub.sendMessage(effort.trackingChangedEventType(), newValue=True, sender=effort)

 def onAddEffortToOrRemoveEffortFromTask(self, newValue, sender):
     if sender not in self.observable():
         return
     newValue, oldValue = newValue
     effortsToAdd = [effort for effort in newValue if not effort in oldValue]
     effortsToRemove = [effort for effort in oldValue if not effort in newValue]
     super(EffortList, self).extendSelf(effortsToAdd)
     super(EffortList, self).removeItemsFromSelf(effortsToRemove)
     for effort in effortsToAdd + effortsToRemove:
         if effort.getStop() is None:
             pub.sendMessage(effort.trackingChangedEventType(),
                             newValue=effort in effortsToAdd,
                             sender=effort)

 def removeItemsFromSelf(self, tasks, event=None):
     ''' This method is called when a task is removed from the observed 
         list. It overrides ObservableListObserver.removeItemsFromSelf 
         whose default behaviour is to remove the item that was removed
         from the observed list from the observing list (this list) 
         unchanged. But we want to remove the efforts of the tasks, rather 
         than the tasks themselves. '''
     effortsToRemove = []
     for task in tasks:
         effortsToRemove.extend(task.efforts())
     for effort in effortsToRemove:
         if effort.getStop() is None:
             pub.sendMessage(effort.trackingChangedEventType(), newValue=False, sender=effort)
     super(EffortList, self).removeItemsFromSelf(effortsToRemove, event)