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 __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 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 __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, 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 __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 __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 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 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 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 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 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 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 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 testChangeTask_EmptyNotification(self): events = [] def onEvent(sender): events.append(sender) pub.subscribe(onEvent, effort.CompositeEffort.compositeEmptyEventType()) self.task.addEffort(self.effort1) self.effort1.setTask(task.Task()) self.assertEqual([self.composite], 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 testNotificationForSetStart(self): events = [] def onEvent(newValue, sender): events.append((newValue, sender)) pub.subscribe(onEvent, effort.Effort.startChangedEventType()) start = date.DateTime.now() self.effort.setStart(start) self.assertEqual([(start, self.effort)], 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 testChangeStopTimeOfEffort_NoNotification(self): self.task.addEffort(self.effort1) events = [] def onEvent(newValue, sender): events.append((newValue, sender)) pub.subscribe(onEvent, effort.Effort.durationChangedEventType()) self.effort1.setStop(self.effort1.getStop() + date.ONE_HOUR) self.failIf((self.composite.duration(), self.composite) in 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 __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)
def testRemoveMultipleEffortsFromSamePeriodFromTask(self): events = [] def onEvent(sender): events.append(sender) pub.subscribe(onEvent, effort.CompositeEffort.compositeEmptyEventType()) self.task.addEffort(self.effort1) self.task.addEffort(self.effort2) self.task.setEfforts([]) self.failUnless(events)
def __init__(self, mainWindow, settings, effortList): self._mainWindow = mainWindow self._settings = settings self._effortList = effortList self._displayed = set() super(IdleController, self).__init__() self.__tracker = effort.EffortListTracker(self._effortList) pub.subscribe(self.poweroff, 'powermgt.off') pub.subscribe(self.poweron, 'powermgt.on')
def __init__(self, viewer, trackingChangedEventType): super(SecondRefresher, self).__init__() self.__viewer = viewer self.__presentation = viewer.presentation() self.__trackedItems = set() pub.subscribe(self.onTrackingChanged, trackingChangedEventType) self.registerObserver(self.onItemAdded, eventType=self.__presentation.addItemEventType(), eventSource=self.__presentation) self.registerObserver(self.onItemRemoved, eventType=self.__presentation.removeItemEventType(), eventSource=self.__presentation) self.setTrackedItems(self.trackedItems(self.__presentation))
def __init__(self, parent, viewer): super(StatusBar, self).__init__(parent) self.SetFieldsCount(2) self.parent = parent self.viewer = viewer self.__timer = wx.Timer(self) self.Bind(wx.EVT_TIMER, self.onUpdateStatus, self.__timer) pub.subscribe(self.onViewerStatusChanged, 'viewer.status') self.scheduledStatusDisplay = None self.onViewerStatusChanged() self.wxEventTypes = (wx.EVT_MENU_HIGHLIGHT_ALL, wx.EVT_TOOL_ENTER) for eventType in self.wxEventTypes: parent.Bind(eventType, self.resetStatusBar)
def monitorClass(self, klass): if klass not in self._classes: for name in klass.monitoredAttributes(): eventType = getattr(klass, '%sChangedEventType' % name)() if eventType.startswith('pubsub'): pub.subscribe(self.onAttributeChanged, eventType) else: self.registerObserver(self.onAttributeChanged_Deprecated, eventType) self._classes.add(klass) if issubclass(klass, ObservableComposite): self.registerObserver(self.onChildAdded, klass.addChildEventType()) self.registerObserver(self.onChildRemoved, klass.removeChildEventType()) if issubclass(klass, CategorizableCompositeObject): self.registerObserver(self.onCategoryAdded, klass.categoryAddedEventType()) self.registerObserver(self.onCategoryRemoved, klass.categoryRemovedEventType()) if issubclass(klass, Task): pub.subscribe(self.onEffortAddedOrRemoved, Task.effortsChangedEventType()) pub.subscribe(self.onPrerequisitesChanged, Task.prerequisitesChangedEventType()) if issubclass(klass, NoteOwner): self.registerObserver(self.onOtherObjectAdded, klass.noteAddedEventType()) self.registerObserver(self.onOtherObjectRemoved, klass.noteRemovedEventType()) if issubclass(klass, AttachmentOwner): self.registerObserver(self.onOtherObjectAdded, klass.attachmentAddedEventType()) self.registerObserver(self.onOtherObjectRemoved, klass.attachmentRemovedEventType()) if issubclass(klass, Effort): pub.subscribe(self.onEffortTaskChanged, Effort.taskChangedEventType())
def __init__(self, parent, taskFile, settings, *args, **kwargs): super(Viewer, self).__init__(parent, -1) self.parent = parent self.taskFile = taskFile self.settings = settings self.__settingsSection = kwargs.pop('settingsSection') self.__freezeCount = 0 # The how maniest of this viewer type are we? Used for settings self.__instanceNumber = kwargs.pop('instanceNumber') self.__use_separate_settings_section = kwargs.pop('use_separate_settings_section', True) # Selection cache: self.__curselection = [] # Flag so that we don't notify observers while we're selecting all items self.__selectingAllItems = False # Popup menus we have to destroy before closing the viewer to prevent # memory leakage: self._popupMenus = [] # What are we presenting: self.__presentation = self.createSorter(self.createFilter(self.domainObjectsToView())) # The widget used to present the presentation: self.widget = self.createWidget() self.widget.SetBackgroundColour(wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)) self.toolbar = toolbar.ToolBar(self, settings, (16, 16)) self.initLayout() self.registerPresentationObservers() self.refresh() pub.subscribe(self.onBeginIO, 'taskfile.aboutToRead') pub.subscribe(self.onBeginIO, 'taskfile.aboutToClear') pub.subscribe(self.onEndIO, 'taskfile.justRead') pub.subscribe(self.onEndIO, 'taskfile.justCleared') wx.CallAfter(self.__DisplayBalloon)
def __init__(self, parent, taskFile, settings, *args, **kwargs): kwargs.setdefault('settingsSection', 'effortviewer') self.__tasksToShowEffortFor = kwargs.pop('tasksToShowEffortFor', []) self.aggregation = 'details' # Temporary value, will be properly set below self.__hiddenWeekdayColumns = [] self.__hiddenTotalColumns = [] self.__columnUICommands = None self.__domainObjectsToView = None super(EffortViewer, self).__init__(parent, taskFile, settings, *args, **kwargs) self.secondRefresher = refresher.SecondRefresher( self, effort.Effort.trackingChangedEventType()) self.aggregation = settings.get(self.settingsSection(), 'aggregation') self.__initModeToolBarUICommands() self.registerObserver( self.onAttributeChanged_Deprecated, eventType=effort.Effort.appearanceChangedEventType()) pub.subscribe(self.onRoundingChanged, 'settings.%s.round' % self.settingsSection()) pub.subscribe(self.onRoundingChanged, 'settings.%s.alwaysroundup' % self.settingsSection()) pub.subscribe(self.on_aggregation_changed, 'settings.%s.aggregation' % self.settingsSection()) pub.subscribe(self.onHourDisplayChanged, 'settings.feature.decimaltime')
def __init__(self, *args, **kwargs): self.__composites = {} self.__trackedComposites = set() aggregation = kwargs.pop('aggregation') assert aggregation in ('day', 'week', 'month') aggregation = aggregation.capitalize() self.__start_of_period = getattr(date.DateTime, 'startOf%s' % aggregation) self.__end_of_period = getattr(date.DateTime, 'endOf%s' % aggregation) super(EffortAggregator, self).__init__(*args, **kwargs) pub.subscribe(self.onCompositeEmpty, composite.CompositeEffort.compositeEmptyEventType()) pub.subscribe(self.onTaskEffortChanged, task.Task.effortsChangedEventType()) patterns.Publisher().registerObserver( self.onChildAddedToTask, eventType=task.Task.addChildEventType()) patterns.Publisher().registerObserver( self.onChildRemovedFromTask, eventType=task.Task.removeChildEventType()) patterns.Publisher().registerObserver( self.onTaskRemoved, self.observable().removeItemEventType(), eventSource=self.observable()) pub.subscribe(self.onEffortStartChanged, effort.Effort.startChangedEventType()) pub.subscribe(self.onRevenueChanged, task.Task.hourlyFeeChangedEventType())
def registerObservers(self): registerObserver = patterns.Publisher().registerObserver for eventType in (task.Task.plannedStartDateTimeChangedEventType(), task.Task.dueDateTimeChangedEventType(), task.Task.actualStartDateTimeChangedEventType(), task.Task.completionDateTimeChangedEventType(), task.Task.prerequisitesChangedEventType(), task.Task.appearanceChangedEventType(), # Proxy for status changes task.Task.addChildEventType(), task.Task.removeChildEventType()): if eventType.startswith('pubsub'): pub.subscribe(self.onTaskStatusChange, eventType) else: registerObserver(self.onTaskStatusChange_Deprecated, eventType=eventType) date.Scheduler().schedule_interval(self.atMidnight, days=1)
def __init__(self, viewer, trackingChangedEventType): super(SecondRefresher, self).__init__() self.__viewer = viewer self.__presentation = viewer.presentation() self.__trackedItems = set() id_ = wx.NewId() self.__timer = wx.Timer(self, id_) wx.EVT_TIMER(self, id_, self.onEverySecond) pub.subscribe(self.onTrackingChanged, trackingChangedEventType) self.registerObserver(self.onItemAdded, eventType=self.__presentation.addItemEventType(), eventSource=self.__presentation) self.registerObserver(self.onItemRemoved, eventType=self.__presentation.removeItemEventType(), eventSource=self.__presentation) self.setTrackedItems(self.trackedItems(self.__presentation))
def __init__(self, mainwindow, taskList, settings, defaultBitmap='taskcoach', tickBitmap='clock_icon', tackBitmap='clock_stopwatch_icon', *args, **kwargs): super(TaskBarIcon, self).__init__(*args, **kwargs) self.__window = mainwindow self.__taskList = taskList self.__settings = settings self.__bitmap = self.__defaultBitmap = defaultBitmap self.__tooltipText = '' self.__tickBitmap = tickBitmap self.__tackBitmap = tackBitmap self.registerObserver(self.onTaskListChanged, eventType=taskList.addItemEventType(), eventSource=taskList) self.registerObserver(self.onTaskListChanged, eventType=taskList.removeItemEventType(), eventSource=taskList) pub.subscribe(self.onTrackingChanged, task.Task.trackingChangedEventType()) pub.subscribe(self.onChangeDueDateTime, task.Task.dueDateTimeChangedEventType()) # When the user chances the due soon hours preferences it may cause # a task to change appearance. That also means the number of due soon # tasks has changed, so we need to change the tool tip text. # Note that directly subscribing to the setting (behavior.duesoonhours) # is not reliable. The TaskBarIcon may get the event before the tasks # do. When that happens the tasks haven't changed their status yet and # we would use the wrong status count. self.registerObserver(self.onChangeDueDateTime_Deprecated, eventType=task.Task.appearanceChangedEventType()) if operating_system.isGTK(): events = [wx.EVT_TASKBAR_LEFT_DOWN] elif operating_system.isWindows(): # See http://msdn.microsoft.com/en-us/library/windows/desktop/aa511448.aspx#interaction events = [wx.EVT_TASKBAR_LEFT_DOWN, wx.EVT_TASKBAR_LEFT_DCLICK] else: events = [wx.EVT_TASKBAR_LEFT_DCLICK] for event in events: self.Bind(event, self.onTaskbarClick) self.__setTooltipText() self.__setIcon()
def registerForMenuUpdate(self): for eventType in (self.tasks.addItemEventType(), self.tasks.removeItemEventType()): patterns.Publisher().registerObserver(self.onUpdateMenu_Deprecated, eventType=eventType, eventSource=self.tasks) for eventType in (task.Task.subjectChangedEventType(), task.Task.trackingChangedEventType(), task.Task.plannedStartDateTimeChangedEventType(), task.Task.dueDateTimeChangedEventType(), task.Task.actualStartDateTimeChangedEventType(), task.Task.completionDateTimeChangedEventType()): if eventType.startswith('pubsub'): pub.subscribe(self.onUpdateMenu, eventType) else: patterns.Publisher().registerObserver(self.onUpdateMenu_Deprecated, eventType)
def __init__(self, mainWindow, taskList, effortList, settings): super(ReminderController, self).__init__() pub.subscribe(self.onSetReminder, task.Task.reminderChangedEventType()) patterns.Publisher().registerObserver( self.onAddTask, eventType=taskList.addItemEventType(), eventSource=taskList) patterns.Publisher().registerObserver( self.onRemoveTask, eventType=taskList.removeItemEventType(), eventSource=taskList) self.__tasksWithReminders = {} # {task: reminderDateTime} self.__mainWindow = mainWindow self.__mainWindowWasHidden = False self.__registerRemindersForTasks(taskList) self.settings = settings self.taskList = taskList self.effortList = effortList
def registerObservers(self): registerObserver = patterns.Publisher().registerObserver for eventType in ( task.Task.plannedStartDateTimeChangedEventType(), task.Task.dueDateTimeChangedEventType(), task.Task.actualStartDateTimeChangedEventType(), task.Task.completionDateTimeChangedEventType(), task.Task.prerequisitesChangedEventType(), task.Task.appearanceChangedEventType( ), # Proxy for status changes task.Task.addChildEventType(), task.Task.removeChildEventType()): if eventType.startswith('pubsub'): pub.subscribe(self.onTaskStatusChange, eventType) else: registerObserver(self.onTaskStatusChange_Deprecated, eventType=eventType) date.Scheduler().schedule_interval(self.atMidnight, days=1)
def __init__(self, iocontroller, taskFile, settings, *args, **kwargs): self.__splash = kwargs.pop('splash', None) super(MainWindow, self).__init__(None, -1, '', *args, **kwargs) # This prevents the viewers from flickering on Windows 7 when refreshed: if operating_system.isWindows7_OrNewer(): turn_on_double_buffering_on_windows(self) self.__dimensions_tracker = windowdimensionstracker.WindowDimensionsTracker( self, settings) self.iocontroller = iocontroller self.taskFile = taskFile self.settings = settings self.__filename = None self.__dirty = False self.__shutdown = False self.Bind(wx.EVT_CLOSE, self.onClose) self.Bind(wx.EVT_ICONIZE, self.onIconify) self.Bind(wx.EVT_SIZE, self.onResize) self._create_window_components() # Not private for test purposes self.__init_window_components() self.__init_window() self.__register_for_window_component_changes() if settings.getboolean('feature', 'syncml'): try: import taskcoachlib.syncml.core # pylint: disable=W0612,W0404 except ImportError: if settings.getboolean('syncml', 'showwarning'): dlg = widgets.SyncMLWarningDialog(self) try: if dlg.ShowModal() == wx.ID_OK: settings.setboolean('syncml', 'showwarning', False) finally: dlg.Destroy() self.bonjourRegister = None self.bonjourAcceptor = None self._registerBonjour() pub.subscribe(self._registerBonjour, 'settings.feature.iphone') self._idleController = idlecontroller.IdleController( self, self.settings, self.taskFile.efforts()) wx.CallAfter(self.checkXFCE4)
def __init__(self, *args, **kwargs): self.__categories = kwargs.pop('categories') self.__filterOnlyWhenAllCategoriesMatch = \ kwargs.pop('filterOnlyWhenAllCategoriesMatch', False) for eventType in (self.__categories.addItemEventType(), self.__categories.removeItemEventType()): patterns.Publisher().registerObserver( self.onCategoryChanged, eventType=eventType, eventSource=self.__categories) eventTypes = (Category.categorizableAddedEventType(), Category.categorizableRemovedEventType(), Category.filterChangedEventType()) for eventType in eventTypes: patterns.Publisher().registerObserver(self.onCategoryChanged, eventType=eventType) pub.subscribe(self.onFilterMatchingChanged, 'settings.view.categoryfiltermatchall') super(CategoryFilter, self).__init__(*args, **kwargs)
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__() 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 __init__(self, parent, taskFile, settings, *args, **kwargs): super(Viewer, self).__init__(parent, -1) self.parent = parent self.taskFile = taskFile self.settings = settings self.__settingsSection = kwargs.pop('settingsSection') self.__freezeCount = 0 # The how maniest of this viewer type are we? Used for settings self.__instanceNumber = kwargs.pop('instanceNumber') self.__use_separate_settings_section = kwargs.pop( 'use_separate_settings_section', True) # Selection cache: self.__curselection = [] # Flag so that we don't notify observers while we're selecting all items self.__selectingAllItems = False # Popup menus we have to destroy before closing the viewer to prevent # memory leakage: self._popupMenus = [] # What are we presenting: self.__presentation = self.createSorter( self.createFilter(self.domainObjectsToView())) # The widget used to present the presentation: self.widget = self.createWidget() self.widget.SetBackgroundColour( wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW)) self.toolbar = toolbar.ToolBar(self, settings, (16, 16)) self.initLayout() self.registerPresentationObservers() self.refresh() pub.subscribe(self.onBeginIO, 'taskfile.aboutToRead') pub.subscribe(self.onBeginIO, 'taskfile.aboutToClear') pub.subscribe(self.onEndIO, 'taskfile.justRead') pub.subscribe(self.onEndIO, 'taskfile.justCleared') wx.CallAfter(self.__DisplayBalloon)
def testChangePage_NotifiesObserversAboutNewActiveViewer(self): pub.subscribe(self.onEvent, 'viewer.status') self.container.onPageChanged(DummyChangeEvent(self.viewer2)) self.failUnless(self.events > 0)
# First, try to load the settings file from the program directory, # if that fails, load the settings file from the settings directory try: if not self.read(self.filename(forceProgramDir=True)): self.read(self.filename()) errorMessage = '' except ConfigParser.ParsingError, errorMessage: # Ignore exceptions and simply use default values. # Also record the failure in the settings: self.initializeWithDefaults() self.setLoadStatus(ExceptionAsUnicode(errorMessage)) else: # Assume that if the settings are not to be loaded, we also # should be quiet (i.e. we are probably in test mode): self.__beQuiet() pub.subscribe(self.onSettingsFileLocationChanged, 'settings.file.saveinifileinprogramdir') def onSettingsFileLocationChanged(self, value): saveIniFileInProgramDir = value if not saveIniFileInProgramDir: try: os.remove(self.generatedIniFilename(forceProgramDir=True)) except: return # pylint: disable=W0702 def initializeWithDefaults(self): for section in self.sections(): self.remove_section(section) for section, settings in defaults.defaults.items(): self.add_section(section) for key, value in settings.items():
def testCloseViewer_NotifiesObserversAboutNewActiveViewer(self): self.container.activateViewer(self.viewer2) pub.subscribe(self.onEvent, 'viewer.status') self.container.closeViewer(self.viewer2) self.failUnless(self.events > 0)
def __init__(self, composite): self.composite = composite pub.subscribe(self.onTimeSpentChanged, task.Task.timeSpentChangedEventType()) pub.subscribe(self.onRevenueChanged, task.Task.hourlyFeeChangedEventType())
def __init_spell_checking(self): self.on_spell_checking(self.settings.getboolean('editor', 'maccheckspelling')) pub.subscribe(self.on_spell_checking, 'settings.editor.maccheckspelling')
def __init__(self, task, taskList, effortList, settings, *args, **kwargs): kwargs['title'] = _('%(name)s reminder - %(task)s') % \ dict(name=meta.name, task=task.subject(recursive=True)) super(ReminderDialog, self).__init__(*args, **kwargs) self.SetIcon(wx.ArtProvider_GetIcon('taskcoach', wx.ART_FRAME_ICON, (16, 16))) self.task = task self.taskList = taskList self.effortList = effortList self.settings = settings self.registerObserver(self.onTaskRemoved, eventType=self.taskList.removeItemEventType(), eventSource=self.taskList) pub.subscribe(self.onTaskCompletionDateChanged, task.completionDateTimeChangedEventType()) pub.subscribe(self.onTrackingChanged, task.trackingChangedEventType()) self.openTaskAfterClose = self.ignoreSnoozeOption = False pane = self.GetContentsPane() pane.SetSizerType("form") wx.StaticText(pane, label=_('Task') + ':') panel = wx.Panel(pane) sizer = wx.BoxSizer(wx.HORIZONTAL) self.openTask = wx.Button(panel, label=self.task.subject(recursive=True)) self.openTask.Bind(wx.EVT_BUTTON, self.onOpenTask) sizer.Add(self.openTask, flag=wx.ALIGN_CENTER_VERTICAL) if self.settings.getboolean('feature', 'effort'): self.startTracking = wx.BitmapButton(panel) self.setTrackingIcon() self.startTracking.Bind(wx.EVT_BUTTON, self.onStartOrStopTracking) sizer.Add((3, -1), flag=wx.ALIGN_CENTER_VERTICAL) sizer.Add(self.startTracking, flag=wx.ALIGN_CENTER_VERTICAL) panel.SetSizerAndFit(sizer) for label in _('Reminder date/time') + ':', \ render.dateTime(self.task.reminder()), _('Snooze') + ':': wx.StaticText(pane, label=label) self.snoozeOptions = wx.ComboBox(pane, style=wx.CB_READONLY) sizer.Add(self.snoozeOptions, flag=wx.ALIGN_CENTER_VERTICAL) snoozeTimesUserWantsToSee = [0] + self.settings.getlist('view', 'snoozetimes') defaultSnoozeTime = self.settings.getint('view', 'defaultsnoozetime') # Use the 1st non-zero option if we don't find the last snooze time: selectionIndex = 1 # pylint: disable=E1101 for minutes, label in date.snoozeChoices: if minutes in snoozeTimesUserWantsToSee: self.snoozeOptions.Append(label, date.TimeDelta(minutes=minutes)) if minutes == defaultSnoozeTime: selectionIndex = self.snoozeOptions.Count - 1 self.snoozeOptions.SetSelection(min(selectionIndex, self.snoozeOptions.Count - 1)) wx.StaticText(pane, label='') self.replaceDefaultSnoozeTime = wx.CheckBox(pane, label=_('Also make this the default snooze time for future ' 'reminders')) self.replaceDefaultSnoozeTime.SetValue(self.settings.getboolean('view', 'replacedefaultsnoozetime')) buttonSizer = self.CreateStdDialogButtonSizer(wx.OK) self.markCompleted = wx.Button(self, label=_('Mark task completed')) self.markCompleted.Bind(wx.EVT_BUTTON, self.onMarkTaskCompleted) if self.task.completed(): self.markCompleted.Disable() buttonSizer.Add(self.markCompleted, flag=wx.ALIGN_CENTER_VERTICAL) self.SetButtonSizer(buttonSizer) self.Bind(wx.EVT_CLOSE, self.onClose) self.Bind(wx.EVT_BUTTON, self.onOK, id=self.GetAffirmativeId()) self.Fit() self.RequestUserAttention() if self.settings.getboolean('feature', 'sayreminder'): speak.Speaker().say('"%s: %s"' % (_('Reminder'), task.subject()))
def __init__(self, settings, *args, **kwargs): super(AutoSaver, self).__init__(*args, **kwargs) self.__settings = settings self.__task_files = set() pub.subscribe(self.onTaskFileDirty, 'taskfile.dirty') wx.GetApp().Bind(wx.EVT_IDLE, self.on_idle)
def testLocationNotification(self): pub.subscribe(self.onEvent, self.attachment.locationChangedEventType()) self.attachment.setLocation('new location') self.assertEqual([('new location', self.attachment)], self.events)
def __init__(self, *args, **kwargs): self.__filename = self.__lastFilename = '' self.__needSave = self.__loading = False self.__tasks = task.TaskList() self.__categories = category.CategoryList() self.__notes = note.NoteContainer() self.__efforts = effort.EffortList(self.tasks()) self.__guid = generate() self.__syncMLConfig = createDefaultSyncConfig(self.__guid) self.__monitor = ChangeMonitor() self.__changes = dict() self.__changes[self.__monitor.guid()] = self.__monitor self.__changedOnDisk = False if kwargs.pop('poll', True): self.__notifier = TaskCoachFilesystemPollerNotifier(self) else: self.__notifier = TaskCoachFilesystemNotifier(self) self.__saving = False for collection in [self.__tasks, self.__categories, self.__notes]: self.__monitor.monitorCollection(collection) for domainClass in [ task.Task, category.Category, note.Note, effort.Effort, attachment.FileAttachment, attachment.URIAttachment, attachment.MailAttachment ]: self.__monitor.monitorClass(domainClass) super(TaskFile, self).__init__(*args, **kwargs) # Register for tasks, categories, efforts and notes being changed so we # can monitor when the task file needs saving (i.e. is 'dirty'): for container in self.tasks(), self.categories(), self.notes(): for eventType in container.modificationEventTypes(): self.registerObserver(self.onDomainObjectAddedOrRemoved, eventType, eventSource=container) for eventType in (base.Object.markDeletedEventType(), base.Object.markNotDeletedEventType()): self.registerObserver(self.onDomainObjectAddedOrRemoved, eventType) for eventType in task.Task.modificationEventTypes(): if not eventType.startswith('pubsub'): self.registerObserver(self.onTaskChanged_Deprecated, eventType) pub.subscribe(self.onTaskChanged, 'pubsub.task') for eventType in effort.Effort.modificationEventTypes(): self.registerObserver(self.onEffortChanged, eventType) for eventType in note.Note.modificationEventTypes(): if not eventType.startswith('pubsub'): self.registerObserver(self.onNoteChanged_Deprecated, eventType) pub.subscribe(self.onNoteChanged, 'pubsub.note') for eventType in category.Category.modificationEventTypes(): if not eventType.startswith('pubsub'): self.registerObserver(self.onCategoryChanged_Deprecated, eventType) pub.subscribe(self.onCategoryChanged, 'pubsub.category') for eventType in attachment.FileAttachment.modificationEventTypes() + \ attachment.URIAttachment.modificationEventTypes() + \ attachment.MailAttachment.modificationEventTypes(): if not eventType.startswith('pubsub'): self.registerObserver(self.onAttachmentChanged_Deprecated, eventType) pub.subscribe(self.onAttachmentChanged, 'pubsub.attachment')
def setUp(self): super(SettingsObservableTest, self).setUp() self.events = [] pub.subscribe(self.onEvent, 'settings.view.toolbar')
def registerForMenuUpdate(self): pub.subscribe(self.onTemplatesSaved, 'templates.saved')
def registerForMenuUpdate(self): pub.subscribe(self.onChangeAggregation, 'effortviewer.aggregation')
def registerPresentationObservers(self): super(SortableViewerMixin, self).registerPresentationObservers() pub.subscribe(self.onSortOrderChanged, self.presentation().sortEventType())
def testSubscribe(self): pub.subscribe(self.onTestTopic, 'TestTopic') pub.sendMessage('TestTopic') self.failUnless(self.calledTestTopic)
def __init__(self, settings, copyfile=compressFile): super(AutoBackup, self).__init__() self.__settings = settings self.__copyfile = copyfile pub.subscribe(self.onTaskFileAboutToSave, 'taskfile.aboutToSave') pub.subscribe(self.onTaskFileRead, 'taskfile.justRead')
def __init__(self, settings, copyfile=shutil.copyfile): super(AutoBackup, self).__init__() self.__settings = settings self.__copyfile = copyfile pub.subscribe(self.onTaskFileAboutToSave, 'taskfile.aboutToSave')
def __init__(self, *args, **kwargs): super(EffortList, self).__init__(*args, **kwargs) pub.subscribe(self.onAddEffortToOrRemoveEffortFromTask, task.Task.effortsChangedEventType())
def __init__(self, settings): super(AutoImporterExporter, self).__init__() self.__settings = settings pub.subscribe(self.onTaskFileAboutToBeSaved, 'taskfile.aboutToSave') pub.subscribe(self.onTaskFileJustRead, 'taskfile.justRead')