def __init__(self, width, height, fullscreen, ThemeClass, deviceName):
# setup singleton desktop
Desktop.theDesktop = self
self.presenter = Presenter(width, height, fullscreen)
self.presenter.determineDeviceContext(deviceName)
newTheme = ThemeClass()
setTheme(newTheme)
self.width = width
self.height = height
self.lastID= 1000
self.windows = [] # list of top level windows
self.allWidgets = {} # list of ALL the widgets
self.running = 1 # set this to zero to exit
self.userEvents = [] # list of user events to be processed
self.focusWidget = None # widget with the focus
self.userHandlers = {} # map of user event handlers
self.callbacks = {} # list of timed callback methods (dict for fast removal)
self.modal = None # current modal dialog
self.waiting = 0 # flag for waiting mode
self.tooltipCallback = None # callback to enable tooltip
self.toooltipFocus = None # widget with tooltip focus
self.tooltipPosition = None # position of mouse when tooltip is activated
self.tooltipWindow = None #pyui2.widgets.TooltipWindow(5,50,100,100)
class Desktop:
"""The Desktop. I am the container for all global pyui2 data.
"""
lastEvent = 999 # used to generate user event numbers
theDesktop = None
def __init__(self, width, height, fullscreen, ThemeClass, deviceName):
# setup singleton desktop
Desktop.theDesktop = self
self.presenter = Presenter(width, height, fullscreen)
self.presenter.determineDeviceContext(deviceName)
newTheme = ThemeClass()
setTheme(newTheme)
self.width = width
self.height = height
self.lastID= 1000
self.windows = [] # list of top level windows
self.allWidgets = {} # list of ALL the widgets
self.running = 1 # set this to zero to exit
self.userEvents = [] # list of user events to be processed
self.focusWidget = None # widget with the focus
self.userHandlers = {} # map of user event handlers
self.callbacks = {} # list of timed callback methods (dict for fast removal)
self.modal = None # current modal dialog
self.waiting = 0 # flag for waiting mode
self.tooltipCallback = None # callback to enable tooltip
self.toooltipFocus = None # widget with tooltip focus
self.tooltipPosition = None # position of mouse when tooltip is activated
self.tooltipWindow = None #pyui2.widgets.TooltipWindow(5,50,100,100)
#self.theme.setArrowCursor()
def setDeviceContext(self, deviceName):
self.presenter.determineDeviceContext(deviceName)
def quit(self):
"""Called to destroy all the windows on shutdown.
"""
#use a copy of list as we delete from it.
ww = copy.copy(self.windows)
for w in ww:
w.destroy()
self.running = 0
self.windows = []
self.allWidgets = {}
del Desktop.theDesktop
Desktop.theDesktop = None
self.presenter.getDeviceContext().quit()
def update(self):
"""Called constantly by the application to process pyui2 events and scheduled callbacks.
"""
self.presenter.getDeviceContext().update()
# process user events
while self.running and self.userEvents:
e = self.userEvents.pop(0)
self.handleEvent(e)
if not self.running:
return self.running
# process timer callbacks
timer = self.presenter.getDeviceContext().readTimer()
for callback in self.callbacks.keys():
if callback.process(timer):
del self.callbacks[callback]
return self.running
def draw(self):
"""Called to draw the widgets!
"""
self.presenter.present(self.windows)
def findWidget(self, id):
"""Lookup a widget by its ID.
(public)
"""
return self.allWidgets.get(id, None)
def registerWidget(self, widget):
"""Register a top level window instance with the system.
(internal)
"""
widget.id = self.nextID()
self.allWidgets[widget.id] = widget
def removeWidget(self, widget):
"""Remove a widget previously registered from the top-level widget list
"""
self.windows.remove(widget)
def destroyWidget(self, widget):
"""cleanup all global references to widget. This is called by destroy() so don't call it twice.
(internal)
"""
if self.allWidgets.has_key(widget.id):
del self.allWidgets[widget.id]
for w in self.windows:
if w.id == widget.id:
self.windows.remove(w)
break
if self.focusWidget == widget:
self.focusWidget = None
def activateWindow(self, window):
"""This adds a window to the set of windows and puts it on top, except
for any topMost widgets on the screen.
"""
if window == None:
return
i = 0
try:
self.windows.remove(window)
except ValueError:
pass
if not window.topMost:
for w in self.windows:
if not w.topMost:
break
i += 1
self.windows.insert(i, window)
def addWindow(self, window):
"""This adds a window to the set of windows and puts it on top, except
for any topMost widgets on the screen.
"""
self.activateWindow(window)
self.focusWidget = None
def registerHandler(self, eventType, handler):
"""Register a user defined handler for an event.
(public)
"""
self.userHandlers[eventType] = handler
def unregisterHandler(self, eventType):
"""Un-Register a user defined handler for an event.
(public)
"""
del self.userHandlers[eventType]
def readTimer(self):
return self.presenter.getDeviceContext().readTimer()
def handleEvent(self, event):
"""Process all outstanding events.
(private)
"""
if event.type != 0:
if event.type == pyui2.locals.QUIT:
self.quit()
print "DONE!"
return
# pre-handle mouse move events here for tool tips
if event.type == pyui2.locals.MOUSEMOVE:
self.updateToolTips(event)
# events go to the focus branch first
w = self.focusWidget
while w != None:
if w.handleEvent(event):
return
if w == self.modal:
break
w = w.parent
if self.modal and ((event.type & pyui2.locals.EVENT_MASK) == pyui2.locals.EVENT_MOUSE or
(event.type & pyui2.locals.EVENT_MASK) == pyui2.locals.EVENT_KEYBOARD):
return self.updateModal(event)
# pass events to all widgets
for w in self.windows:
if w.handleEvent(event):
return
# check for application handlers
if self.userHandlers.has_key(event.type):
if self.userHandlers[event.type](event) == 1:
return
def updateToolTips(self, event):
##NOTE: turned off for now...
return
# find the widget under the mouse
found = None
for w in self.windows:
if w == self.tooltipWindow:
continue
found = w.checkHit(event.pos)
if found:
break
#print "Mouse Move. found = ", found
# cancel current tooltip callback
if self.tooltipCallback:
self.removeCallback(self.tooltipCallback)
self.tooltipCallback = None
# disable current tooltip window
if self.tooltipWindow:
self.tooltipWindow.setShow(0)
if found:
# setup a callback to enable the tooltip after a delay
self.tooltipCallback = addCallback(self.enableTooltip, 0.333)
self.tooltipFocus = found
self.tooltipPosition = event.pos
else:
self.tooltipFocus = None
def updateModal(self, event):
"""in modal mode, only the modal dialog gets mouse events
"""
if self.modal.handleEvent(event):
return
if event.type == pyui2.locals.KEYDOWN and event.key == pyui2.locals.K_ESCAPE:
self.modal.setShow(0)
self.modal = None
return
def setModal(self, window):
"""Sets the modal window.
(internal)
"""
self.modal = window
if window:
window.getFocus()
def getModal(self):
return self.modal
def setWaiting(self, value):
self.waiting = value
if value:
self.theme.setWaitCursor()
else:
self.theme.setArrowCursor()
def setFocus(self, widget):
"""Set the focus to this widget.
"""
if not widget:
self.focusWidgets = None
return
if self.focusWidget and self.focusWidget != widget:
self.focusWidget.loseFocus()
self.focusWidget = widget
def getFocus(self):
"""return the current focused widget.
"""
return self.focusWidget
def getTheme(self):
"""return the global theme object"""
return self.theme
def setTheme(self, theme):
"""sets the global theme object
"""
self.theme = theme
def postUserEvent(self, type, x = 0, y = 0, key = 0, mods = 0):
"""Post a user event into the system. This comes from a non-widget object
(public)
"""
newEvent = guiEvent(type, 0, x, y, key, mods)
self.userEvents.append(newEvent)
return newEvent
def postEvent(self, type, id = 0):
"""Post an event object into the system. Comes from a widget object.
(internal)
"""
newEvent = guiEvent(type, id, 0, 0)
self.userEvents.append(newEvent)
return newEvent
def addCallback(self, method, interval = 0):
callback = guiCallback(method, interval, self.presenter.readTimer() )
self.callbacks[callback] = None
return callback
def removeCallback(self, callback):
if self.callbacks.has_key(callback):
del self.callbacks[callback]
def findWindowByHandle(self, handle):
for w in self.windows:
if w.handle == handle:
return w
return None
def enableTooltip(self, interval):
result = self.ooltipFocus.getToolTipInfo(self.tooltipPosition)
self.removeCallback(self.tooltipCallback)
self.tooltipCallback = None
#print "Enabling tool tip", result, gTooltipWindow
if result:
(text, rect) = result
self.tooltipWindow.activate(text, rect)
self.activateWindow(self.tooltipWindow)
def setMustFill(self):
"""tell the UI the screen must be cleared. if this is not set, only dirt rects get updated.
Setting this means that all the windows will redraw.
"""
self.presenter.setMustFill()
def getMustFill(self):
return self.presenter.mustFill
def dirtyCollidingWindows(self, inRect):
"""If a dirty rect collides with any other rects, they should be dirty also. This recurses
so that all colliding rects get dirtied. the second parameter to setDirty() prevents infinite
recursion.
"""
self.presenter.dirtyCollidingWindows(inRect)
def nextID(self):
self.lastID = self.lastID + 1
return self.lastID
def getSize(self):
return (self.width, self.height)
