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 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 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')
