'''
Task Coach - Your friendly task manager
Copyright (C) 2004-2009 Frank Niessink <frank@niessink.com>
Task Coach is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Task Coach is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
import wx
from taskcoachlib import patterns
class ViewerContainer(object):
''' ViewerContainer is a container of viewers. It has a containerWidget
that displays the viewers. The containerWidget can be a notebook or
an AUI managed frame. The ViewerContainer knows which of its viewers
is active and dispatches method calls to the active viewer or to the
first viewer that can handle the method. This allows other GUI
components, e.g. menu's, to talk to the ViewerContainer as were
it a regular viewer. '''
def __init__(self, containerWidget, settings, setting, *args, **kwargs):
self.containerWidget = containerWidget
self.bindContainerWidgetEvents()
self._settings = settings
self.__setting = setting
self.__tabbedMainWindow = settings.getboolean('view', 'tabbedmainwindow')
self.viewers = []
self.__currentPageNumber = 0
# Prepare for an exception, because this setting used to be a string
try:
self.__desiredPageNumber = int(self._settings.get('view', setting))
except ValueError:
self.__desiredPageNumber = 0
super(ViewerContainer, self).__init__(*args, **kwargs)
def isViewerContainer(self):
return True
def bindContainerWidgetEvents(self):
eventsAndHandlers = dict(pageClosedEvent=self.onPageClosed,
pageChangedEvent=self.onPageChanged)
for event, handler in eventsAndHandlers.items():
if hasattr(self.containerWidget, event):
self.containerWidget.Bind(getattr(self.containerWidget, event),
handler)
def __getitem__(self, index):
return self.viewers[index]
def addViewer(self, viewer):
self.containerWidget.AddPage(viewer, viewer.title(), viewer.bitmap())
self.viewers.append(viewer)
if len(self.viewers) - 1 == self.__desiredPageNumber:
# We need to use CallAfter because the AuiNotebook doesn't allow
# PAGE_CHANGING events while the window is not active. See
# widgets/notebook.py
wx.CallAfter(self.containerWidget.SetSelection,
self.__desiredPageNumber)
patterns.Publisher().registerObserver(self.onSelect,
eventType=viewer.selectEventType(), eventSource=viewer)
@classmethod
def selectEventType(class_):
return '%s.select'%class_
@classmethod
def viewerChangeEventType(class_):
return '%s.viewerChange'%class_
def __getattr__(self, method):
''' Return a function that will call the method on the first viewer
that both has the requested method and does not raise an exception.
Start looking in the current viewer. NB: this auto forwarding only
works for methods, not for properties. '''
def findFirstViewer(*args, **kwargs):
for viewer in [self.activeViewer()] + self.viewers:
if hasattr(viewer, method):
return getattr(viewer, method)(*args, **kwargs)
else:
raise AttributeError
return findFirstViewer
def activeViewer(self):
''' Return the active viewer, i.e. the viewer that has the focus. '''
# There is no pageChanged event for the AuiManager, so we have
# to check which pane is active.
if not self.__tabbedMainWindow:
for viewer in self.viewers:
info = self.containerWidget.manager.GetPane(viewer)
if info.HasFlag(info.optionActive):
return viewer
return self.viewers[self.__currentPageNumber]
def __del__(self):
pass # Don't forward del to one of the viewers.
def onSelect(self, event):
patterns.Event(self.selectEventType(), self, *event.values()).send()
def onPageChanged(self, event):
self._changePage(event.GetSelection())
event.Skip()
def onPageClosed(self, event):
if hasattr(event, 'GetPane'):
if event.GetPane().IsToolbar():
return
window = event.GetPane().window
else:
window = self.containerWidget.GetPage(event.GetSelection())
if hasattr(window, 'GetPage'):
# Window is a notebook, close each of its pages
for pageIndex in range(window.GetPageCount()):
self._closePage(window.GetPage(pageIndex))
else:
# Window is a viewer, close it
self._closePage(window)
# Make sure the current pane is a valid pane
if self.__currentPageNumber >= len(self.viewers):
self._changePage(0)
event.Skip()
def _closePage(self, viewer):
# When closing an AUI managed frame, we get two close events,
# be prepared:
if not viewer in self.viewers:
return
self.viewers.remove(viewer)
viewer.detach()
setting = viewer.__class__.__name__.lower() + 'count'
viewerCount = self._settings.getint('view', setting)
self._settings.set('view', setting, str(viewerCount-1))
def _changePage(self, pageNumber):
self.__currentPageNumber = pageNumber
self._settings.set('view', self.__setting, str(pageNumber))
patterns.Event(self.viewerChangeEventType(), self, pageNumber).send()
|