def __init__(self, **kwargs):
if not kwargs.has_key('CellFormatter'):
kwargs['CellFormatter'] = CellFormatter(self)
if not kwargs.has_key('RowFormatter'):
kwargs['RowFormatter'] = RowFormatter(self)
self.tableListeners = []
self.dbltableListeners = []
self.widgetMap = {}
if kwargs.has_key('Element'):
self.tableElem = kwargs.pop('Element')
fc = DOM.getFirstChild(self.tableElem)
if fc:
self.bodyElem = fc
else:
self.bodyElem = DOM.createTBody()
DOM.appendChild(self.tableElem, self.bodyElem)
else:
self.tableElem = DOM.createTable()
self.bodyElem = DOM.createTBody()
DOM.appendChild(self.tableElem, self.bodyElem)
self.setElement(self.tableElem)
self.sinkEvents(Event.ONCLICK | Event.ONDBLCLICK)
Panel.__init__(self, **kwargs)
def insert(self, widget, container, beforeIndex=None):
""" has two modes of operation:
widget, beforeIndex
widget, container, beforeIndex.
if beforeIndex argument is not given, the 1st mode is assumed.
this technique is less costly than using *args.
"""
if widget.getParent() == self:
return
if beforeIndex is None:
beforeIndex = container
container = self.getBody()
widget.removeFromParent()
tr = DOM.createTR()
td = DOM.createTD()
DOM.insertChild(container, tr, beforeIndex)
DOM.appendChild(tr, td)
CellPanel.insert(self, widget, td, beforeIndex)
self.setCellHorizontalAlignment(widget, self.horzAlign)
self.setCellVerticalAlignment(widget, self.vertAlign)
def setWidget(self, widget):
""" Add child widget
"""
widget.removeFromParent()
widget.setParent(self)
self.widget = widget
DOM.appendChild(self.getElement(), widget.getElement())
def __init__(self,
min_value,
max_value,
start_value=None,
step=None,
**kwargs):
if not kwargs.has_key("StyleName"):
kwargs['StyleName'] = "gwt-VerticalSlider"
if kwargs.has_key('Element'):
# XXX FIXME: Focus.createFocusable is here for a reason...
element = kwargs.pop('Element')
else:
element = Focus.createFocusable()
DOM.setStyleAttribute(element, "position", "relative")
DOM.setStyleAttribute(element, "overflow", "hidden")
self.handle = DOM.createDiv()
DOM.appendChild(element, self.handle)
DOM.setStyleAttribute(self.handle, "border", "1px")
DOM.setStyleAttribute(self.handle, "width", "100%")
DOM.setStyleAttribute(self.handle, "height", "10px")
DOM.setStyleAttribute(self.handle, "backgroundColor", "#808080")
Control.__init__(self, element, min_value, max_value, start_value,
step, **kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addMouseListener(self)
def __init__(self, **ka):
ka['StyleName'] = ka.get('StyleName', "gwt-Tree")
self.root = None
self.childWidgets = Set()
self.curSelection = None
self.focusable = None
self.focusListeners = []
self.mouseListeners = []
self.imageBase = pygwt.getModuleBaseURL()
self.keyboardListeners = []
self.listeners = []
self.lastEventType = ""
element = ka.pop('Element', None) or DOM.createDiv()
self.setElement(element)
DOM.setStyleAttribute(self.getElement(), "position", "relative")
self.focusable = Focus.createFocusable()
# Hide focus outline in Mozilla/Webkit/Opera
DOM.setStyleAttribute(self.focusable, "outline", "0px")
# Hide focus outline in IE 6/7
DOM.setElemAttribute(self.focusable, "hideFocus", "true");
DOM.setStyleAttribute(self.focusable, "fontSize", "0")
DOM.setStyleAttribute(self.focusable, "position", "absolute")
DOM.setIntStyleAttribute(self.focusable, "zIndex", -1)
DOM.appendChild(self.getElement(), self.focusable)
self.root = RootTreeItem()
self.root.setTree(self)
Widget.__init__(self, **ka)
self.sinkEvents(Event.ONMOUSEDOWN | Event.ONCLICK | Event.KEYEVENTS)
DOM.sinkEvents(self.focusable, Event.FOCUSEVENTS)
def __init__(self,
text="",
asHTML=False,
targetHistoryToken="",
Element=None,
**kwargs):
self.targetHistoryToken = ""
if not Element:
Element = DOM.createDiv()
self.anchorElem = DOM.createAnchor()
self.setElement(Element)
DOM.appendChild(self.getElement(), self.anchorElem)
if not kwargs.has_key('StyleName'):
kwargs['StyleName'] = "gwt-Hyperlink"
if text:
if asHTML:
kwargs['HTML'] = text
else:
kwargs['Text'] = text
if targetHistoryToken:
kwargs['TargetHistoryToken'] = targetHistoryToken
Widget.__init__(self, **kwargs)
ClickHandler.__init__(self)
def __init__(self, **kwargs):
self.body = None
self.visibleStack = -1
self.indices = {}
if kwargs.has_key('Element'):
table = kwargs.pop('Element')
fc = DOM.getFirstChild(table)
if fc:
self.body = fc
else:
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
else:
table = DOM.createTable()
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
self.setElement(table)
if not kwargs.has_key('Spacing'): kwargs['Spacing'] = 0
if not kwargs.has_key('Padding'): kwargs['Padding'] = 0
if not kwargs.has_key('StyleName'):
kwargs['StyleName'] = "gwt-StackPanel"
DOM.sinkEvents(table, Event.ONCLICK)
ComplexPanel.__init__(self, **kwargs)
def setWidget(self, index, w):
""" Sets one of the contained widgets.
@param index the index, only 0 and 1 are valid
@param w the widget
"""
oldWidget = self.widgets[index]
if oldWidget == w:
return
if w is not None:
w.removeFromParent()
# Remove the old child.
if oldWidget is not None:
# Orphan old.
self.disown(oldWidget)
# Physical detach old.
#DOM.removeChild(self.elements[index], oldWidget.getElement())
# Logical detach old / attach new.
self.widgets[index] = w
if w is not None:
# Physical attach new.
DOM.appendChild(self.elements[index], w.getElement())
# Adopt new.
self.adopt(w, None)
def __init__(self,
title,
titleStyle=None,
imgStyle=None,
rowStyles=None,
containerIndex=2,
titleIndex=1,
**kwargs):
if rowStyles is None:
rowStyles = ["top", "top2", "middle", "bottom"]
if titleStyle is None:
titleStyle = "title"
DecoratorPanel.__init__(self, rowStyles, containerIndex, **kwargs)
inner = self.getCellElement(titleIndex, 1)
if imgStyle:
img = DOM.createDiv()
DOM.setAttribute(img, "className", imgStyle)
DOM.appendChild(inner, img)
tdiv = DOM.createDiv()
DOM.setAttribute(tdiv, "className", titleStyle)
DOM.setInnerText(tdiv, title)
DOM.appendChild(inner, tdiv)
def __init__(self, width=0, height=0):
Widget.__init__(self)
self.context = None
self.setElement(DOM.createDiv())
canvas = DOM.createElement("canvas")
self.setWidth(width)
self.setHeight(height)
canvas.width=width
canvas.height=height
DOM.appendChild(self.getElement(), canvas)
self.setStyleName("gwt-Canvas")
self.init()
self.context.fillStyle = "black"
self.context.strokeStyle = "black"
self.focusable = None
self.focusable = Focus.createFocusable()
self.focusListeners = []
self.clickListeners = []
self.mouseListeners = []
self.keyboardListeners = []
DOM.appendChild(self.getElement(), self.focusable)
DOM.sinkEvents(canvas, Event.ONCLICK | Event.MOUSEEVENTS | DOM.getEventsSunk(canvas))
DOM.sinkEvents(self.focusable, Event.FOCUSEVENTS | Event.KEYEVENTS)
def setWidget(self, widget):
""" Add child widget
"""
widget.removeFromParent()
widget.setParent(self)
self.widget = widget
DOM.appendChild(self.getElement(), widget.getElement())
def __init__(self, text, disclosurePanel):
Widget.__init__(self)
self.disclosurePanel = disclosurePanel
self.imageBase = pygwt.getModuleBaseURL()
self.root = DOM.createTable()
self.tbody = DOM.createTBody()
self.tr = DOM.createTR()
self.imageTD = DOM.createTD()
self.labelTD = DOM.createTD()
self.imgElem = DOM.createImg()
self.updateState()
self.setElement(self.root)
DOM.appendChild(self.root, self.tbody)
DOM.appendChild(self.tbody, self.tr)
DOM.appendChild(self.tr, self.imageTD)
DOM.appendChild(self.tr, self.labelTD)
DOM.appendChild(self.imageTD, self.imgElem)
self.setText(text)
disclosurePanel.addEventHandler(self)
self.updateState()
def __init__(self,
min_value,
max_value,
start_value=None,
step=None,
**ka):
ka["StyleName"] = ka.get('StyleName', "gwt-VerticalSlider")
# XXX FIXME: Focus.createFocusable is here for a reason...
element = ka.pop('Element', None) or Focus.createFocusable()
DOM.setStyleAttribute(element, "position", "relative")
DOM.setStyleAttribute(element, "overflow", "hidden")
self.handle = DOM.createDiv()
DOM.appendChild(element, self.handle)
self.setHandleStyle("1px", "100%", "10px", "#808080")
Control.__init__(self, element, min_value, max_value, start_value,
step, **ka)
self.addClickListener(self)
self.addFocusListener(self)
self.addMouseListener(self)
def _checkVerticalContainer(self):
""" use this to delay effect of self.vertical being set.
self.setVertical can now be used, rather than self.vertical
force-set in constructor
"""
if DOM.getChildCount(self.body) == 0:
DOM.appendChild(self.body, DOM.createTR())
def setWidget(self, index, w):
""" Sets one of the contained widgets.
@param index the index, only 0 and 1 are valid
@param w the widget
"""
oldWidget = self.widgets[index]
if oldWidget == w:
return
if w is not None:
w.removeFromParent()
# Remove the old child.
if oldWidget is not None:
# Orphan old.
self.disown(oldWidget)
# Physical detach old.
#DOM.removeChild(self.elements[index], oldWidget.getElement())
# Logical detach old / attach new.
self.widgets[index] = w
if w is not None:
# Physical attach new.
DOM.appendChild(self.elements[index], w.getElement())
# Adopt new.
self.adopt(w, None)
def __init__(self, min_value, max_value, start_value=None, step=None,
**kwargs):
if not kwargs.has_key("StyleName"): kwargs['StyleName'] = "gwt-VerticalSlider"
if kwargs.has_key('Element'):
# XXX FIXME: Focus.createFocusable is here for a reason...
element = kwargs.pop('Element')
else:
element = Focus.createFocusable()
DOM.setStyleAttribute(element, "position", "relative")
DOM.setStyleAttribute(element, "overflow", "hidden")
self.handle = DOM.createDiv()
DOM.appendChild(element, self.handle)
DOM.setStyleAttribute(self.handle, "border", "1px")
DOM.setStyleAttribute(self.handle, "width", "100%")
DOM.setStyleAttribute(self.handle, "height", "10px")
DOM.setStyleAttribute(self.handle, "backgroundColor", "#808080")
Control.__init__(self, element, min_value, max_value, start_value, step,
**kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addMouseListener(self)
def insert(self, widget, container, beforeIndex=None):
""" has two modes of operation:
widget, beforeIndex
widget, container, beforeIndex.
if beforeIndex argument is not given, the 1st mode is assumed.
this technique is less costly than using *args.
"""
if widget.getParent() == self:
return
if beforeIndex is None:
beforeIndex = container
container = self.getBody()
widget.removeFromParent()
tr = DOM.createTR()
td = DOM.createTD()
DOM.insertChild(container, tr, beforeIndex)
DOM.appendChild(tr, td)
CellPanel.insert(self, widget, td, beforeIndex)
self.setCellHorizontalAlignment(widget, self.horzAlign)
self.setCellVerticalAlignment(widget, self.vertAlign)
def _checkVerticalContainer(self):
""" use this to delay effect of self.vertical being set.
self.setVertical can now be used, rather than self.vertical
force-set in constructor
"""
if DOM.getChildCount(self.body) == 0:
DOM.appendChild(self.body, DOM.createTR())
def __init__(self, **ka):
ka['StyleName'] = ka.get('StyleName', "gwt-Tree")
self.root = None
self.childWidgets = Set()
self.curSelection = None
self.focusable = None
self.focusListeners = []
self.mouseListeners = []
self.imageBase = pygwt.getModuleBaseURL()
self.keyboardListeners = []
self.listeners = []
self.lastEventType = ""
element = ka.pop('Element', None) or DOM.createDiv()
self.setElement(element)
DOM.setStyleAttribute(self.getElement(), "position", "relative")
self.focusable = Focus.createFocusable()
# Hide focus outline in Mozilla/Webkit/Opera
DOM.setStyleAttribute(self.focusable, "outline", "0px")
# Hide focus outline in IE 6/7
DOM.setElemAttribute(self.focusable, "hideFocus", "true")
DOM.setStyleAttribute(self.focusable, "fontSize", "0")
DOM.setStyleAttribute(self.focusable, "position", "absolute")
DOM.setIntStyleAttribute(self.focusable, "zIndex", -1)
DOM.appendChild(self.getElement(), self.focusable)
self.root = RootTreeItem()
self.root.setTree(self)
Widget.__init__(self, **ka)
self.sinkEvents(Event.ONMOUSEDOWN | Event.ONCLICK | Event.KEYEVENTS)
DOM.sinkEvents(self.focusable, Event.FOCUSEVENTS)
def __init__(self, min_value, max_value,
start_value=None, step=None,
**kwargs):
if not kwargs.has_key("StyleName"):
kwargs['StyleName'] = "gwt-VerticalSlider"
if kwargs.has_key('Element'):
# XXX FIXME: Focus.createFocusable is here for a reason...
element = kwargs.pop('Element')
else:
element = Focus.createFocusable()
DOM.setStyleAttribute(element, "position", "relative")
DOM.setStyleAttribute(element, "overflow", "hidden")
self.handle = DOM.createDiv()
DOM.appendChild(element, self.handle)
self.setHandleStyle("1px", "100%", "10px", "#808080")
# must use DoubleControl; otherwise, this init is = Vertical init,
# plus a change in the handle style
# this should be refactored, so that the AreaSlider
# can be built on VerticalSlider
DoubleControl.__init__(self, element, min_value, max_value,
start_value, step,
**kwargs)
self.addClickListener(self)
self.addFocusListener(self)
self.addMouseListener(self)
#Redefine VDS's styles for handle
self.setHandleStyle("1px", "10px", "10px", "#808080")
def __init__(self, **kwargs):
self.body = None
self.visibleStack = -1
self.indices = {}
if kwargs.has_key('Element'):
table = kwargs.pop('Element')
fc = DOM.getFirstChild(table)
if fc:
self.body = fc
else:
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
else:
table = DOM.createTable()
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
self.setElement(table)
if not kwargs.has_key('Spacing'): kwargs['Spacing'] = 0
if not kwargs.has_key('Padding'): kwargs['Padding'] = 0
if not kwargs.has_key('StyleName'): kwargs['StyleName'] = "gwt-StackPanel"
DOM.sinkEvents(table, Event.ONCLICK)
ComplexPanel.__init__(self, **kwargs)
def setCurrentFaceElement(self, newFaceElement):
# XXX: TODO
if self.curFaceElement != newFaceElement:
if self.curFaceElement is not None:
DOM.removeChild(self.getElement(), self.curFaceElement)
self.curFaceElement = newFaceElement
DOM.appendChild(self.getElement(), self.curFaceElement)
def adopt(self, widget, container):
if container is not None:
widget.removeFromParent()
if indexBefore:
DOM.insertChild(container, widget.getElement(), indexBefore)
else:
DOM.appendChild(container, widget.getElement())
widget.setParent(self)
def __addLogElement(self):
"""Add a container in the DOM where logging output will be written to.
This cannot be done in the constructor as it must happen late enough
to ensure a document body (to add an element to) does already exist."""
if self.div == None:
self.div = DOM.createDiv()
self.div.setAttribute('id', self.div_id)
DOM.appendChild(doc().body, self.div)
def adopt(self, widget, container):
if container is not None:
widget.removeFromParent()
if indexBefore:
DOM.insertChild(container, widget.getElement(), indexBefore)
else:
DOM.appendChild(container, widget.getElement())
widget.setParent(self)
def setCurrentFaceElement(self, newFaceElement):
# XXX: TODO
if self.curFaceElement != newFaceElement:
if self.curFaceElement is not None:
DOM.removeChild(self.getElement(), self.curFaceElement)
self.curFaceElement = newFaceElement
DOM.appendChild(self.getElement(), self.curFaceElement)
def __init__(self, img, **kwargs):
self.mouseListeners = []
if not kwargs.has_key('StyleName'):
kwargs['StyleName'] = 'gwt-HyperlinkImage'
Hyperlink.__init__(self, **kwargs)
DOM.appendChild(DOM.getFirstChild(self.getElement()), img.getElement())
img.unsinkEvents(Event.ONCLICK | Event.MOUSEEVENTS)
self.sinkEvents(Event.ONCLICK | Event.MOUSEEVENTS)
def __addLogElement(self):
"""Add a container in the DOM where logging output will be written to.
This cannot be done in the constructor as it must happen late enough
to ensure a document body (to add an element to) does already exist."""
if self.div == None:
self.div = DOM.createDiv()
self.div.setAttribute('id', self.div_id)
DOM.appendChild(doc().body, self.div)
def testDivHTML(self):
e = DOM.getElementById('tests')
div = DOM.createElement('div')
DOM.appendChild(e, div)
DOM.setInnerHTML(div, 'hello world\n')
self.write_test_output('addDiv')
DOM.removeChild(e, div)
self.write_test_output('removeDiv')
def testDivHTML(self):
e = DOM.getElementById('tests')
div = DOM.createElement('div')
DOM.appendChild(e, div)
DOM.setInnerHTML(div, 'hello world\n')
self.write_test_output('addDiv')
DOM.removeChild(e, div)
self.write_test_output('removeDiv')
def insertItem(self, item, index=None):
if isinstance(item, basestring):
item = TreeItem(item)
ret = self.root.addItem(item)
if index is None:
DOM.appendChild(self.getElement(), item.getElement())
else:
DOM.insertChild(self.getElement(), item.getElement(), index)
return ret
def __init__(self, caption, widget=None, **kwargs):
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
else:
element = DOM.createElement("fieldset")
self.legend = DOM.createElement("legend")
DOM.appendChild(element, self.legend)
kwargs['Caption'] = caption
if widget is not None:
kwargs['Widget'] = widget
SimplePanel.__init__(self, element, **kwargs)
def surroundContents(rng, copyInto):
"""
Surround the contents of the range with the given element, and put the
element in their place. Any tags needed to make the contents complete
are included. Element object ids are not maintained.
@param range js range to surround with this element
@param copyInto element to surround the range's contents with
"""
DOM.appendChild(copyInto, rng.extractContents())
rng.insertNode(copyInto)
def addColorStop(self, offset, color):
# create a color stop element
stop = self._createElementSVG("stop")
stop.setAttributeNS(None, "stop-color", color);
# offset is specified as a float, but it should be percent
offset = int(offset*100)
# and it's a string
offset = str(offset)+"%"
stop.setAttributeNS(None, "offset", offset);
# now add the color stop as child
DOM.appendChild(self.elem, stop)
def insertItem(self, item, index=None):
if isinstance(item, basestring):
item = TreeItem(item)
ret = self.root.addItem(item)
if index is None:
DOM.appendChild(self.getElement(), item.getElement())
else:
DOM.insertChild(self.getElement(), item.getElement(), index)
return ret
def addColorStop(self, offset, color):
# create a color stop element
stop = self._createElementSVG("stop")
stop.setAttributeNS(None, "stop-color", color)
# offset is specified as a float, but it should be percent
offset = int(offset * 100)
# and it's a string
offset = str(offset) + "%"
stop.setAttributeNS(None, "offset", offset)
# now add the color stop as child
DOM.appendChild(self.elem, stop)
def __init__(self, caption, widget=None, **kwargs):
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
else:
element = DOM.createElement("fieldset")
self.legend = DOM.createElement("legend")
DOM.appendChild(element, self.legend)
kwargs['Caption'] = caption
if widget is not None:
kwargs['Widget'] = widget
SimplePanel.__init__(self, element, **kwargs)
def surroundContents(rng, copyInto):
"""
Surround the contents of the range with the given element, and put the
element in their place. Any tags needed to make the contents complete
are included. Element object ids are not maintained.
@param range js range to surround with this element
@param copyInto element to surround the range's contents with
"""
DOM.appendChild(copyInto, rng.extractContents())
rng.insertNode(copyInto)
def createTD(self, styleName):
""" Create a new table cell with a specific style name.
@param styleName: the style name
@return the new cell {@link Element}
"""
tdElem = DOM.createTD()
inner = DOM.createDiv()
DOM.appendChild(tdElem, inner)
self.setStyleName(tdElem, styleName)
self.setStyleName(inner, styleName + "Inner")
return tdElem
def __init__(self, **kwargs):
if not kwargs.has_key('Spacing'): kwargs['Spacing'] = 0
if not kwargs.has_key('Padding'): kwargs['Padding'] = 0
self.horzAlign = HasHorizontalAlignment.ALIGN_LEFT
self.vertAlign = HasVerticalAlignment.ALIGN_TOP
CellPanel.__init__(self, **kwargs)
self.tableRow = DOM.createTR()
DOM.appendChild(self.getBody(), self.tableRow)
def __init__(self, **kwargs):
if not kwargs.has_key('Spacing'): kwargs['Spacing'] = 0
if not kwargs.has_key('Padding'): kwargs['Padding'] = 0
self.horzAlign = HasHorizontalAlignment.ALIGN_LEFT
self.vertAlign = HasVerticalAlignment.ALIGN_TOP
CellPanel.__init__(self, **kwargs)
self.tableRow = DOM.createTR()
DOM.appendChild(self.getBody(), self.tableRow)
def createTD(self, styleName) :
""" Create a new table cell with a specific style name.
@param styleName the style name
@return the new cell {@link Element}
"""
tdElem = DOM.createTD()
inner = DOM.createDiv()
DOM.appendChild(tdElem, inner)
self.setStyleName(tdElem, styleName)
self.setStyleName(inner, styleName + "Inner")
return tdElem
def __init__(self,
coordX=None,
coordY=None,
pixelX=None,
pixelY=None,
**kwargs):
"""
Creates an SVGCanvas element. Element type is 'svg'
@param coordX the size of the coordinate space in the x direction
@param coordY the size of the coordinate space in the y direction
@param pixelX the CSS width in pixels of the canvas element
@param pixelY the CSS height in pixels of the canvas element
"""
# init default coordinates/size
self.pixelHeight = 150
self.pixelWidth = 300
self.coordHeight = self.pixelHeight
self.coordWidth = self.pixelWidth
focusable = Focus.createFocusable()
self.canvas = self._createElementSVG("svg")
# create an empty defs element
self.defs = self._createElementSVG("defs")
# and add it to the canvas
DOM.appendChild(self.canvas, self.defs)
# now add canvas to container
DOM.appendChild(focusable, self.canvas)
# init base widget (invokes settables)
FocusWidget.__init__(self, focusable, **kwargs)
# since the Applier class provides settable access,
# we only override the dimensions if user actually
# provided them as keyword args
if pixelX is not None:
self.setPixelWidth(pixelX)
if pixelY is not None:
self.setPixelHeight(pixelY)
if coordX is not None:
self.setCoordWidth(coordX)
if coordY is not None:
self.setCoordHeight(coordY)
# init styles context stack
self.ctx_stack = []
# init current context
self._init_context()
# insure we clear/init the canvas
self.clear()
def __init__(self, options=None, *args, **kwargs):
element = DOM.createDiv()
if not 'StyleName' in kwargs:
kwargs['StyleName'] = 'leaflet-Map'
FocusWidget.__init__(self, element, *args, **kwargs)
map_element = DOM.createDiv()
DOM.setStyleAttribute(map_element, 'width', '100%')
DOM.setStyleAttribute(map_element, 'height', '100%')
DOM.appendChild(element, map_element)
JS('this._map = new $wnd.L.Map(map_element, pyjslib.toJSObjects(options));')
self._layers = []
def insert(self, widget, beforeIndex):
widget.removeFromParent()
tr = DOM.createTR()
td = DOM.createTD()
DOM.insertChild(self.getBody(), tr, beforeIndex)
DOM.appendChild(tr, td)
CellPanel.insert(self, widget, td, beforeIndex)
self.setCellHorizontalAlignment(widget, self.horzAlign)
self.setCellVerticalAlignment(widget, self.vertAlign)
def insert(self, widget, beforeIndex):
widget.removeFromParent()
tr = DOM.createTR()
td = DOM.createTD()
DOM.insertChild(self.getBody(), tr, beforeIndex)
DOM.appendChild(tr, td)
CellPanel.insert(self, widget, td, beforeIndex)
self.setCellHorizontalAlignment(widget, self.horzAlign)
self.setCellVerticalAlignment(widget, self.vertAlign)
def buildDOM(self):
leftDiv = self.getWidgetElement(0)
rightDiv = self.getWidgetElement(1)
splitDiv = self.getSplitElement()
DOM.appendChild(self.getElement(), self.container)
DOM.appendChild(self.container, leftDiv)
DOM.appendChild(self.container, splitDiv)
DOM.appendChild(self.container, rightDiv)
# Sadly, this is the only way I've found to get vertical
# centering in this case. The usually CSS hacks (display:
# table-cell, vertical-align: middle) don't work in an
# absolute positioned DIV.
thumb_html = '<img src="splitPanelThumb.png" />'
DOM.setInnerHTML(splitDiv,
"<table class='hsplitter' height='100%' cellpadding='0' " +
"cellspacing='0'><tr><td align='center' valign='middle'>" +
thumb_html +
"</td></tr></table>")
self.addScrolling(leftDiv)
self.addScrolling(rightDiv)
def add(self, widget, stackText="", asHTML=False):
widget.removeFromParent()
index = self.getWidgetCount()
tr = DOM.createTR()
td = DOM.createTD()
DOM.appendChild(self.body, tr)
DOM.appendChild(tr, td)
self.setStyleName(td, "gwt-StackPanelItem", True)
self._setIndex(td, index)
DOM.setAttribute(td, "height", "1px")
tr = DOM.createTR()
td = DOM.createTD()
DOM.appendChild(self.body, tr)
DOM.appendChild(tr, td)
DOM.setAttribute(td, "height", "100%")
DOM.setAttribute(td, "vAlign", "top")
CellPanel.add(self, widget, td)
self.setStackVisible(index, False)
if self.visibleStack == -1:
self.showStack(0)
if stackText != "":
self.setStackText(self.getWidgetCount() - 1, stackText, asHTML)
def __init__(self, vertical=False, **kwargs):
if not kwargs.has_key('StyleName'): kwargs['StyleName']="gwt-MenuBar"
self.body = None
self.items = []
self.parentMenu = None
self.popup = None
self.selectedItem = None
self.shownChildMenu = None
self.vertical = False
self.autoOpen = False
if kwargs.has_key('Element'):
table = kwargs.pop('Element')
fc = DOM.getFirstChild(table)
if fc:
self.body = fc
else:
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
else:
table = DOM.createTable()
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
if not vertical:
tr = DOM.createTR()
DOM.appendChild(self.body, tr)
self.vertical = vertical
outer = DOM.createDiv()
DOM.appendChild(outer, table)
self.setElement(outer)
Widget.__init__(self, **kwargs)
def initElement(self, element, **ka):
self.inputElem = element
self.labelElem = DOM.createLabel()
element = ka.pop('Element', None) or DOM.createSpan()
ButtonBase.__init__(self, element, **ka)
self.sinkEvents(Event.FOCUSEVENTS | Event.ONCLICK)
DOM.appendChild(self.getElement(), self.inputElem)
DOM.appendChild(self.getElement(), self.labelElem)
uid = "check%d" % self.getUniqueID()
DOM.setAttribute(self.inputElem, "id", uid)
DOM.setAttribute(self.labelElem, "htmlFor", uid)
def initElement(self, element, **ka):
self.inputElem = element
self.labelElem = DOM.createLabel()
element = ka.pop('Element', None) or DOM.createSpan()
ButtonBase.__init__(self, element, **ka)
self.sinkEvents(Event.FOCUSEVENTS | Event.ONCLICK)
DOM.appendChild(self.getElement(), self.inputElem)
DOM.appendChild(self.getElement(), self.labelElem)
uid = "check%d" % self.getUniqueID()
DOM.setAttribute(self.inputElem, "id", uid)
DOM.setAttribute(self.labelElem, "htmlFor", uid)
def __init__(self, vertical=False, **kwargs):
if not kwargs.has_key('StyleName'): kwargs['StyleName']="gwt-MenuBar"
self.body = None
self.items = []
self.parentMenu = None
self.popup = None
self.selectedItem = None
self.shownChildMenu = None
self.vertical = False
self.autoOpen = False
if kwargs.has_key('Element'):
table = kwargs.pop('Element')
fc = DOM.getFirstChild(table)
if fc:
self.body = fc
else:
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
else:
table = DOM.createTable()
self.body = DOM.createTBody()
DOM.appendChild(table, self.body)
if not vertical:
tr = DOM.createTR()
DOM.appendChild(self.body, tr)
self.vertical = vertical
outer = DOM.createDiv()
DOM.appendChild(outer, table)
self.setElement(outer)
Widget.__init__(self, **kwargs)
def __init__(self, **kwargs):
element = None
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
if element is None:
element = DOM.createTable()
self.table = element
self.setElement(self.table)
self.body = DOM.createTBody()
self.spacing = None
self.padding = None
DOM.appendChild(self.table, self.body)
ComplexPanel.__init__(self, **kwargs)
def add(self, widget, stackText="", asHTML=False):
widget.removeFromParent()
index = self.getWidgetCount()
tr = DOM.createTR()
td = DOM.createTD()
DOM.appendChild(self.body, tr)
DOM.appendChild(tr, td)
self.setStyleName(td, "gwt-StackPanelItem", True)
self._setIndex(td, index)
DOM.setAttribute(td, "height", "1px")
tr = DOM.createTR()
td = DOM.createTD()
DOM.appendChild(self.body, tr)
DOM.appendChild(tr, td)
DOM.setAttribute(td, "height", "100%")
DOM.setAttribute(td, "vAlign", "top")
ComplexPanel.add(self, widget, td)
self.setStackVisible(index, False)
if self.visibleStack == -1:
self.showStack(0)
if stackText != "":
self.setStackText(self.getWidgetCount() - 1, stackText, asHTML)
def __init__(self, coordX=None, coordY=None, pixelX=None, pixelY=None,
**kwargs):
"""
Creates an SVGCanvas element. Element type is 'svg'
@param coordX the size of the coordinate space in the x direction
@param coordY the size of the coordinate space in the y direction
@param pixelX the CSS width in pixels of the canvas element
@param pixelY the CSS height in pixels of the canvas element
"""
# init default coordinates/size
self.pixelHeight = 150
self.pixelWidth = 300
self.coordHeight = self.pixelHeight
self.coordWidth = self.pixelWidth
focusable = Focus.createFocusable()
self.canvas = self._createElementSVG("svg")
# create an empty defs element
self.defs = self._createElementSVG("defs")
# and add it to the canvas
DOM.appendChild(self.canvas, self.defs)
# now add canvas to container
DOM.appendChild(focusable, self.canvas)
# init base widget (invokes settables)
FocusWidget.__init__(self, focusable, **kwargs)
# since the Applier class provides settable access,
# we only override the dimensions if user actually
# provided them as keyword args
if pixelX is not None:
self.setPixelWidth(pixelX)
if pixelY is not None:
self.setPixelHeight(pixelY)
if coordX is not None:
self.setCoordWidth(coordX)
if coordY is not None:
self.setCoordHeight(coordY)
# init styles context stack
self.ctx_stack = []
# init current context
self._init_context()
# insure we clear/init the canvas
self.clear()
