def __init__(self, world, windowHandle, width, height):
Panel.__init__(self)
#self.viewHandle = getRenderer().createView(world)
self.world = world
self.windowHandle = windowHandle
## attach to the desktop background windowHandle.
primView = (pyui2.locals.VIEW, 0, 0, width, height, self.viewHandle)
def __init__(self):
Panel.__init__(self)
self._tabBar = TabBar(self.onTabChange)
self._tabBar.setWindow(self.window)
self._tabBar.setParent(self)
self.activePanel = None
self.tabPanels = {} # mapping of titles to panels
self.activePanel = None
self.registerEvent(pyui2.locals.LMOUSEBUTTONDOWN, self._pyui2MouseDown)
self.registerEvent(pyui2.locals.KEYDOWN, self._pyui2KeyDown)
self.calcInnerRect()
self.placeInnerObjects()
def __init__(self, direction = VERTICAL, method = PERCENTAGE, ratio = 50 ):
self.direction = direction # vertical/horizontal
self.method = method # pixels/percentage
self.ratio = ratio # number of pixels or percentage
self.splitPos = 0 # pixel width/height of first panel
if self.method == SplitterPanel.PERCENTAGE:
self.ratio = float(ratio) / 100.0
Panel.__init__(self)
self.panel1 = Panel()
self.panel2 = Panel()
self.addChild(self.panel1)
self.addChild(self.panel2)
def __init__(self, fieldList):
self.fieldList = fieldList
Panel.__init__(self)
self.object = None
# setup layout
num = 0
span = 0
for t, n, l, vspan, d in fieldList:
span = span + vspan
self.setLayout(pyui2.layouts.TableLayoutManager( 3, span))
for fieldType, fieldName, fieldLabel, fieldSpan, fieldData in fieldList:
newLabel = Label(fieldLabel)
newWidget = self.createFormWidget(fieldType, fieldData)
self.addChild( newLabel, (0,num,1,fieldSpan) )
self.addChild( newWidget, (1,num,2,fieldSpan) )
self.__dict__["label_%s" % fieldName] = newLabel
self.__dict__["widget_%s" % fieldName] = newWidget
num = num + fieldSpan
self.pack()
def __init__(self, x, y, w, h, topmost = 0):
self._panel = Panel()
Base.__init__(self)
self.topMost = topmost
# the content panel is added as a child through Base::addChild to avoid recursively adding it to itself
Base.addChild(self, self._panel)
self._panel.setWindow(self)
self._panel.setParent(self)
self.placeInnerObjects()
self.drawCommands = []
# these are drawing callbacks to draw _after_ all the widgets are drawn
self.drawLastCallbacks = []
self.moveto(x, y)
self.resize(w, h)
getDesktop().addWindow(self)
# Create the graphics context that will be used to display this window
self.graphicsContext = getPresenter().getDeviceContext().createGraphicsContext((w, h))
def addPanel(self, title, panel = None):
"""Can add an existing panel, or have a panel created by default.
Adding an existing panel is useful for adding special panel types (splitters/tabs)
"""
if not panel:
panel = Panel()
self.addChild(panel)
panel.moveto(self.innerRect[0], self.innerRect[1])
panel.resize(self.innerRect[2], self.innerRect[3])
panel.calcSize()
panel.tabTitle = title
self.tabPanels[title] = panel
self._tabBar.addTab(title)
if not self.activePanel:
self.activePanel = panel
self.setDirty()
return panel
class Window(Base):
"""window - contains other objects.
Windows have a main panel (_panel) which can be replaced with a custom panel. this main panel is
kept the size of the interior of the window.
"""
def __init__(self, x, y, w, h, topmost = 0):
self._panel = Panel()
Base.__init__(self)
self.topMost = topmost
# the content panel is added as a child through Base::addChild to avoid recursively adding it to itself
Base.addChild(self, self._panel)
self._panel.setWindow(self)
self._panel.setParent(self)
self.placeInnerObjects()
self.drawCommands = []
# these are drawing callbacks to draw _after_ all the widgets are drawn
self.drawLastCallbacks = []
self.moveto(x, y)
self.resize(w, h)
getDesktop().addWindow(self)
# Create the graphics context that will be used to display this window
self.graphicsContext = getPresenter().getDeviceContext().createGraphicsContext((w, h))
def getGraphicsContext(self):
return self.graphicsContext
def beginDraw(self):
self.graphicsContext.beginDraw(self.posX, self.posY)
def endDraw(self):
self.graphicsContext.endDraw()
def present(self, presenter):
"""Performs the rendering of the window and it's children to the windows graphic context.
"""
if self.graphicsContext.getSize() != (self.width, self.height):
# The size has changed since we last rendered, we need to resize the graphics context.
# Note we only really need to do this when we redraw it, since creating and releasing
# the context every time we get a window resize call may be very inefficient.
self.graphicsContext.resize((self.width, self.height))
# Draw the window first
presenter.drawWidget("WINDOW", self, self.graphicsContext)
# Draw each of the children on to the graphics context using the theme supplied through
# the presenter
for child in self.children:
child.present(presenter, self.graphicsContext)
def render(self):
self.graphicsContext.render((self.posX, self.posY))
def resize(self, w, h):
Base.resize(self, w, h)
self._panel.resize(w,h)
def addDrawCallback(self, callback):
self.drawLastCallbacks.append(callback)
# for windows, children get added to the content panel
def addChild(self, child, option = None):
self._panel.addChild(child, option)
child.calcSize()
def move(self, x, y):
Base.move(self, x,y)
def moveto(self, x, y):
Base.moveto(self, x,y)
def setLayout(self, layout):
self._panel.setLayout(layout)
layout.setPanel(self._panel)
def pack(self):
self._panel.pack()
def destroy(self):
self._panel = None
self.handle = 0
self.drawList = []
Base.destroy(self)
def replacePanel(self, panel):
for c in self.children:
if c.id == self._panel.id:
self.children.remove(c)
self._panel = panel
Base.addChild(self, self._panel)
self._panel.setWindow(self)
self.calcInnerRect()
self.placeInnerObjects()
self._panel.moveto(self.innerRect[0], self.innerRect[1])
self._panel.resize(self.innerRect[2], self.innerRect[3])
self._panel.calcInnerRect()
self._panel.placeInnerObjects()
def placeInnerObjects(self):
self._panel.moveto(0,0)
self._panel.resize(self.width, self.height)
def setDirty(self, collide = 1):
#self.dirty = 1
if self.dirty:
return
if collide:
getDesktop().dirtyCollidingWindows(self.rect)
Base.setDirty(self)
def setTopMost(self, value):
if value == 0:
self.topMost = 0
else:
self.topMost = 1
#print "set topmost to ", self.topMost
def setShow(self, value):
if value:
getDesktop().activateWindow(self)
return Base.setShow(self, value)
def isWindow(self):
return True
def desktopToWindow(self, point):
"""Convert a point in desktop coordinates into coordinates
relative to the windows position.
"""
x = int(point[0] - self.posX)
y = int(point[1] - self.posY)
return (x, y)
def resize(self, w, h):
"""Only resize the current tab. other tabs are resized when switched to later if it is required."""
#print "tabbed panel resizing ", w, h, self
Panel.resize(self, w, h)
self.calcInnerRect()
def setWindow(self, window):
Panel.setWindow(self, window)
self._tabBar.setWindow(self.window)
def destroy(self):
#print "Destroying view:", self.viewHandle
self.windowHandle = None
#getRenderer().destroyView(self.viewHandle)
Panel.destroy(self)
class SplitterPanel(Panel):
"""A panel that is split in half - vertically or horizontally.
Can use pixels or percentage to split. Each side of the split is a panel.
The default panels can be replaced with custom panels.
There is a middle bar of the splitter panel. This middle bar _could_ be used
to resize it...
"""
VERTICAL = 0
HORIZONTAL = 1
PIXELS = 0
PERCENTAGE = 1
PADDING = 2
def __init__(self, direction = VERTICAL, method = PERCENTAGE, ratio = 50 ):
self.direction = direction # vertical/horizontal
self.method = method # pixels/percentage
self.ratio = ratio # number of pixels or percentage
self.splitPos = 0 # pixel width/height of first panel
if self.method == SplitterPanel.PERCENTAGE:
self.ratio = float(ratio) / 100.0
Panel.__init__(self)
self.panel1 = Panel()
self.panel2 = Panel()
self.addChild(self.panel1)
self.addChild(self.panel2)
def setVerticalSplit(self, x):
self.panel1.moveto(0,0)
self.panel1.resize(x-self.PADDING, self.height)
self.panel2.moveto(x+self.PADDING, 0)
self.panel2.resize(self.width-x-self.PADDING, self.height)
self.splitPos = x
def setHorizontalSplit(self, y):
self.panel1.moveto(0,0)
self.panel1.resize(self.width, y-self.PADDING)
self.panel2.moveto(0, y+self.PADDING)
self.panel2.resize(self.width, self.height-y-self.PADDING)
self.splitPos = y
def resize(self, w, h):
Base.resize(self, w,h)
#print "splitter resizing", w, h
if self.method == SplitterPanel.PIXELS:
if self.direction == SplitterPanel.VERTICAL:
if self.ratio >= 0:
self.setVerticalSplit(self.ratio)
else:
self.setVerticalSplit(self.width + self.ratio)
if self.direction == SplitterPanel.HORIZONTAL:
if self.ratio >= 0:
self.setHorizontalSplit(self.ratio)
else:
self.setHorizontalSplit(self.height + self.ratio)
else:
if self.direction == SplitterPanel.VERTICAL:
self.setVerticalSplit(self.width * self.ratio)
if self.direction == SplitterPanel.HORIZONTAL:
self.setHorizontalSplit(self.height * self.ratio)
def draw(self, renderer):
self.panel1.draw(renderer)
if self.direction == SplitterPanel.HORIZONTAL:
getTheme().drawSplitter(
(self.windowRect[0], self.windowRect[1]+self.splitPos-self.PADDING, self.width, self.PADDING*2))
else:
getTheme().drawSplitter(
(self.windowRect[0]+self.splitPos-self.PADDING, self.windowRect[1], 2*self.PADDING, self.height))
self.panel2.draw(renderer)
def pack(self):
self.panel1.pack()
self.panel2.pack()
def getFirstPanel(self):
""" returns the left or top panel
"""
return self.panel1
def getSecondPanel(self):
""" returns to right or bottom panel
"""
return self.panel2
def replaceFirstPanel(self, panel):
panel.moveto(self.panel1.posX, self.panel1.posY)
for c in self.children:
if c.id == self.panel1.id:
self.children.remove(c)
c.destroy()
self.addChild(panel)
self.panel1 = panel
self.resize(self.width, self.height)
def replaceSecondPanel(self, panel):
panel.moveto(self.panel2.posX, self.panel2.posY)
for c in self.children:
if c.id == self.panel2.id:
self.children.remove(c)
c.destroy()
self.addChild(panel)
self.panel2 = panel
self.resize(self.width, self.height)
def __init__(self):
Panel.__init__(self)
