def _registerObserverForAttribute(self, attribute):
     for eventType in self._getSortEventTypes(attribute):
         if eventType.startswith('pubsub'):
             pub.subscribe(self.onAttributeChanged, eventType)
         else:
             patterns.Publisher().registerObserver(self.onAttributeChanged_Deprecated, 
                                                   eventType=eventType)

 def __startObserving(self, eventTypes):
     for eventType in eventTypes:
         if eventType.startswith('pubsub'):
             pub.subscribe(self.onAttributeChanged, eventType)
         else:
             self.registerObserver(self.onAttributeChanged_Deprecated, 
                                   eventType=eventType)                    

 def addViewer(self, viewer, floating=False):
     ''' Add a new pane with the specified viewer. '''
     self.containerWidget.addPane(viewer, viewer.title(), floating=floating)
     self.viewers.append(viewer)
     if len(self.viewers) == 1:
         self.activateViewer(viewer)
     pub.subscribe(self.onStatusChanged, viewer.viewerStatusEventType())

 def __register_for_window_component_changes(self):
     pub.subscribe(self.__onFilenameChanged, 'taskfile.filenameChanged')
     pub.subscribe(self.__onDirtyChanged, 'taskfile.dirty')
     pub.subscribe(self.__onDirtyChanged, 'taskfile.clean')
     pub.subscribe(self.showStatusBar, 'settings.view.statusbar')
     pub.subscribe(self.showToolBar, 'settings.view.toolbar')
     self.Bind(aui.EVT_AUI_PANE_CLOSE, self.onCloseToolBar)

    def __init__(self, effortList, includeComposites=False):
        '''@param effortList: The effort list to observe.
        @param includeComposites: if False, composite efforts will be
            ignored.'''
        super(EffortListTracker, self).__init__()
        Publisher.__init__(self)

        self.__effortList = effortList
        self.__includeComposites = includeComposites

        # __trackedEfforts is a list and not a set because when an effort is
        # moved from one task to another task we might get the event that the
        # effort is (re)added to the effortList before the event that the effort
        # was removed from the effortList. If we would use a set, the effort
        # would be missing from the set after the removal event.    
        self.__trackedEfforts = self.__filterTrackedEfforts(self.__effortList)

        self.registerObserver(self.onEffortAdded, 
                              eventType=self.__effortList.addItemEventType(),
                              eventSource=self.__effortList)
        self.registerObserver(self.onEffortRemoved, 
                              eventType=self.__effortList.removeItemEventType(),
                              eventSource=self.__effortList)
        pub.subscribe(self.onTrackingChanged, 
                      effort.Effort.trackingChangedEventType())

 def __start_observing_attribute(self, eventType, eventSource):
     if eventType.startswith('pubsub'):
         pub.subscribe(self.onAttributeChanged, eventType)
     else:
         patterns.Publisher().registerObserver(self.onAttributeChanged_Deprecated,
                                               eventType=eventType,
                                               eventSource=eventSource)

 def __init__(self, *args, **kwargs):
     kwargs.setdefault("settingsSection", "effortviewerforselectedtasks")
     self.__viewerContainer = kwargs.pop("viewerContainer")
     self.__currentTaskViewer = (
         self.__viewerContainer.activeViewer() if self.__viewerContainer.activeViewer().isShowingTasks() else None
     )
     pub.subscribe(self.onTaskSelectionChanged, "all.viewer.status")
     super(EffortViewerForSelectedTasks, self).__init__(*args, **kwargs)

 def testNoNotificationForSetStopWhenNewStopEqualsOldStop(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.stopChangedEventType())
     self.effort.setStop(self.effort.getStop())
     self.failIf(events)

 def testAddTrackedEffortToTaskDoesNotCauseListEmptyNotification(self):
     events = []
     
     def onEvent(sender):
         events.append(sender)
         
     pub.subscribe(onEvent, effort.CompositeEffort.compositeEmptyEventType())
     self.task.addEffort(effort.Effort(self.task, self.composite.getStart()))
     self.failIf(events)

 def testNotificationForStartTracking(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, self.effort.trackingChangedEventType())
     self.effort.setStop(date.DateTime())
     self.assertEqual([(True, self.effort)], events)

 def testAddEffortNotification(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.durationChangedEventType())
     self.task.addEffort(self.effort1)
     self.assertEqual([(self.composite.duration(), self.composite)], events)

 def testAddEffortToChildTaskNotification(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.durationChangedEventType())
     self.child.addEffort(self.childEffort)
     self.failUnless((self.composite.duration(), self.composite) in events)

 def testDurationNotificationForSetStop(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.durationChangedEventType())
     self.effort.setStop(date.DateTime.now())
     self.assertEqual([(self.effort.duration(), self.effort)], events)

 def testThatAnHourlyFeeChangeCausesARevenueNotification(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.revenueChangedEventType())
     self.child.setHourlyFee(100)
     self.failUnless((0.0, self.composite) in events)

 def testRevenueNotificationForTaskHourlyFeeChange(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.revenueChangedEventType())
     self.task.setHourlyFee(100)
     self.assertEqual([(2400.0, self.effort)], events)

 def testNotificationForSetTask(self):
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.taskChangedEventType())
     task2 = task.Task()
     self.effort.setTask(task2)
     self.assertEqual([(task2, self.effort)], events)

 def testRevenueNotificationForEffortDurationChange_ChangeStart(self):
     self.task.setHourlyFee(100)
     events = []
     
     def onEvent(newValue, sender):
         events.append((newValue, sender))
         
     pub.subscribe(onEvent, effort.Effort.revenueChangedEventType())
     self.effort.setStart(date.DateTime(2004, 1, 1, 12, 0, 0))
     self.assertEqual([(1200.0, self.effort)], events)

 def testRemoveChildWithEffortCausesEmptyNotification(self):
     events = []
     
     def onEvent(sender):
         events.append(sender)
         
     pub.subscribe(onEvent, effort.CompositeEffort.compositeEmptyEventType())
     self.child.addEffort(self.childEffort)
     self.task.removeChild(self.child)
     self.assertEqual([self.composite], events)

 def testRemoveEffortFromChildNotification(self):
     self.child.addEffort(self.childEffort)
     events = []
     
     def onEvent(sender):
         events.append(sender)
         
     pub.subscribe(onEvent, effort.CompositeEffort.compositeEmptyEventType())
     self.child.removeEffort(self.childEffort)
     self.assertEqual([self.composite], events)

 def __init__(self, *args, **kwargs):
     self.__treeMode = kwargs.pop('treeMode', False)
     self.__sortByTaskStatusFirst = kwargs.pop('sortByTaskStatusFirst', True)
     super(Sorter, self).__init__(*args, **kwargs)
     for eventType in (task.Task.prerequisitesChangedEventType(),
                       task.Task.dueDateTimeChangedEventType(),
                       task.Task.plannedStartDateTimeChangedEventType(),
                       task.Task.actualStartDateTimeChangedEventType(),
                       task.Task.completionDateTimeChangedEventType()):
         pub.subscribe(self.onAttributeChanged, eventType)