class FlowPanelDemo:
"""Demos the flow panel. Because of how the Flow Panel works, all elements have to be inline elements.
Divs, tables, etc. can't be used, unless specified with CSS that they are inline or inline-block.
Because of how Vertical Panels work (with tables), we use CSS to display tables as inline-blocks.
IE, excluding IE8, doesn't support inline-blocks, so we have to use a CSS hack
(see http://blog.mozilla.com/webdev/2009/02/20/cross-browser-inline-block/ for more on the hack)
However, we use spans instead of divs for the Label by providing an 'element' argument."""
def __init__(self):
self.root = RootPanel()
#Flow panel taking up 70% of the page. CSS centers it.
self.flow = FlowPanel(Width="70%", StyleName='flow-panel')
for x in range(0, 10):
self.panel = VerticalPanel()
#Label each image with its number in the sequence
title = Label("Item %s" % x,
Element=DOM.createElement('span'),
StyleName="title item")
#Add a neat-o image.
image = Image('images/pyjamas.png',
Width="200px",
Height="200px",
StyleName="cat-image cat-item")
#Add to the Vertical Panel the image title
self.panel.add(title)
self.panel.add(image)
self.flow.add(self.panel)
self.root.add(self.flow)
def reduceterm(sender, maxlines):
"""When the Reduce button is pressed: call cc.runfile with our input.
There is a maximum number of lines that we will output, to prevent a
stalling browser and an overfull document. The user can raise this limit
with a link.
"""
input = inputArea.getText()
output = ""
nlines = 0
def catchoutput(s, end="\n"):
output += s + end
nlines += 1
if nlines > maxlines:
raise OverlongOutput()
cc._defs = dict()
try:
cc.runfile(inputfile=io.StringIO(input), verbose=False, printout=catchoutput, printerr=catchoutput)
except OverlongOutput:
extra = FlowPanel(StyleName="terminated")
extra.add(InlineLabel("Reduction terminated after %s lines. " % (maxlines,)))
extra.add(Button("Try longer", functools.partial(queuereduce, maxlines=nextmaxlines(maxlines))))
showOutput(output, extra=extra)
except Exception, e:
Window.alert(e)
class WordBox(ScrollPanel):
def __init__(self, **kwargs):
Width = kwargs.get("Width")
self.table = FlowPanel(Width=Width, StyleName="wordpanel")
ScrollPanel.__init__(self, self.table, **kwargs)
def setWords(self, words):
self.words = words
self.createBoxes()
def createBoxes(self):
while self.table.getWidgetCount():
self.table.remove(0)
for w in self.words:
el = DOM.createDiv()
DOM.setStyleAttribute(el, "float", "left")
wid = HTML(w, Element=el,
StyleName="flowpanelword")
self.table.add(wid)
def markWords(self, wordstarter):
for box in self.table:
box.removeStyleName("flowpanelwordhighlight")
for box in self.table:
txt = box.getHTML()
if txt.startswith(wordstarter):
box.addStyleName("flowpanelwordhighlight")
def __init__(self, **kwargs):
if not kwargs.has_key('StyleName'): kwargs['StyleName'] = "gwt-TabBar"
# this is awkward: FlowPanel is the composite,
# so we either the element here, and pass it in to FlowPanel.
element = None
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
self.panel = FlowPanel(Element=element)
self.selectedTab = None
self.tabListeners = []
#self.panel.setVerticalAlignment(HasAlignment.ALIGN_BOTTOM)
first = HTML(" ", True)
rest = HTML(" ", True)
first.setStyleName("gwt-TabBarFirst")
rest.setStyleName("gwt-TabBarRest")
first.setHeight("100%")
rest.setHeight("100%")
self.panel.add(first)
self.panel.add(rest)
first.setHeight("100%")
#self.panel.setCellHeight(first, "100%")
#self.panel.setCellWidth(rest, "100%")
Composite.__init__(self, self.panel, **kwargs)
self.sinkEvents(Event.ONCLICK)
class FlowPanelDemo:
"""Demos the flow panel. Because of how the Flow Panel works, all elements have to be inline elements.
Divs, tables, etc. can't be used, unless specified with CSS that they are inline or inline-block.
Because of how Vertical Panels work (with tables), we use CSS to display tables as inline-blocks.
IE, excluding IE8, doesn't support inline-blocks, so we have to use a CSS hack
(see http://blog.mozilla.com/webdev/2009/02/20/cross-browser-inline-block/ for more on the hack)
However, we use spans instead of divs for the Label by providing an 'element' argument."""
def __init__(self):
self.root = RootPanel()
#Flow panel taking up 70% of the page. CSS centers it.
self.flow = FlowPanel(Width="70%", StyleName='flow-panel')
for x in range(0, 10):
self.panel = VerticalPanel()
#Label each image with its number in the sequence
title = Label("Item %s" % x, element=DOM.createElement('span'), StyleName="title item")
#Add a neat-o image.
image = Image('images/pyjamas.png', Width="200px", Height="200px", StyleName="cat-image cat-item")
#Add to the Vertical Panel the image title
self.panel.add(title)
self.panel.add(image)
self.flow.add(self.panel)
self.root.add(self.flow)
class NavigationBar(SimplePanel):
def __init__(self, *args, **kwargs):
super(NavigationBar, self).__init__(*args, **kwargs)
navbar = SimplePanel(StyleName="navbar navbar-fixed")
navbar_inner = SimplePanel(StyleName="navbar-inner")
self._navbar_container = FlowPanel()
navbar_inner.add(self._navbar_container)
navbar.add(navbar_inner)
SimplePanel.add(self, navbar)
def add(self, widget):
self._navbar_container.add(widget)
def __init__(self, **kwargs):
if not kwargs.has_key('StyleName'): kwargs['StyleName']="gwt-TabBar"
# this is awkward: FlowPanel is the composite,
# so we either the element here, and pass it in to FlowPanel.
element = None
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
self.panel = FlowPanel(Element=element)
self.selectedTab = None
self.tabListeners = []
#self.panel.setVerticalAlignment(HasAlignment.ALIGN_BOTTOM)
first = HTML(" ", True)
rest = HTML(" ", True)
first.setStyleName("gwt-TabBarFirst")
rest.setStyleName("gwt-TabBarRest")
first.setHeight("100%")
rest.setHeight("100%")
self.panel.add(first)
self.panel.add(rest)
first.setHeight("100%")
#self.panel.setCellHeight(first, "100%")
#self.panel.setCellWidth(rest, "100%")
Composite.__init__(self, self.panel, **kwargs)
self.sinkEvents(Event.ONCLICK)
def __init__(self, name, description, widget, **kwargs):
if not kwargs.has_key('StyleName'):
kwargs['StyleName'] = "ctrlHolder"
if not kwargs.has_key('ID'):
kwargs['ID'] = "div_id_%s" % name
FlowPanel.__init__(self, **kwargs)
self.errors = []
self.label = FormLabel(description, "id_%s" % name)
self.widget = widget
self.widget.setID("id_%s" % name)
self.widget.setName(name)
self.add(self.label)
self.add(self.widget)
def __init__(self):
self.root = RootPanel()
#Flow panel taking up 70% of the page. CSS centers it.
self.flow = FlowPanel(Width="70%", StyleName='flow-panel')
for x in range(0, 10):
self.panel = VerticalPanel()
#Label each image with its number in the sequence
title = Label("Item %s" % x, element=DOM.createElement('span'), StyleName="title item")
#Add a neat-o image.
image = Image('images/pyjamas.png', Width="200px", Height="200px", StyleName="cat-image cat-item")
#Add to the Vertical Panel the image title
self.panel.add(title)
self.panel.add(image)
self.flow.add(self.panel)
self.root.add(self.flow)
def createControlPanel(self, controlNames):
flowPanel=FlowPanel()
newLabels=[]
for buttonName in controlNames:
newPanel=HorizontalPanel()
newLabels.append(Label(buttonName))
newPanel.add(newLabels[-1])
newTextBox=TextBox()
newTextBox.setEnabled(True)
newTextBox.setWidth(80)
newPanel.add(newTextBox)
if buttonName=="RangeLo" :
newTextBox.setText("100") # Default values
self.rangeLowBox=newTextBox
elif buttonName=="RangeHi" :
newTextBox.setText("150")
self.rangeHighBox=newTextBox
elif buttonName=="Steps" :
newTextBox.setText("1")
self.stepSizeBox=newTextBox
elif buttonName=="FileName": newTextBox.setText("TestRun.png")
#newTextBox.addChangeListener(self)
newTextBox.setTitle(buttonName)
self.controlValueEntries[buttonName]=newTextBox
flowPanel.add(newPanel)
# Set all of the widths of the labels to be the same, so that the boxes line up
maxWidth=0
for label in newLabels :
# This doesn't work for some reason
#if label.getWidth() > maxWidth : maxWidth=label.getWidth()
if len(label.getText())*9 > maxWidth : maxWidth=len(label.getText())*9
for label in newLabels :
label.setWidth(maxWidth)
return flowPanel
class TextBoxArray:
def __init__(self, default_value='0', show_indices=True):
self._default_value = default_value
self._show_indices = show_indices
self._values = []
self.panel = FlowPanel()
# public interface
@property
def values(self):
return self._values
@property
def size(self):
return len(self._values)
@size.setter
def size(self, value):
add_count = value - len(self._values)
if add_count < 0:
for w in self._values[add_count:]:
self.panel.remove(w.getParent())
self._values.remove(w)
elif add_count > 0:
if self._values:
newval = self._values[-1].getText()
else:
newval = self._default_value
for i in range(add_count):
w = TextBox(Width='3em', Text=newval)
self._values.append(w)
panel = VerticalPanel(StyleName='TextBoxArrayCell')
panel.add(w)
panel.add(
HTML("{}".format(i + value - add_count + 1),
HorizontalAlignment='center',
Visible=self._show_indices))
self.panel.add(panel)
def createRegisterPanel( self, registerNames ) :
"""
Creates panels and buttons for everything given in registerNames, and returns the main panel.
"""
flowPanel=FlowPanel()
for buttonName in registerNames :
newPanel=HorizontalPanel()
label=Label(buttonName)
newPanel.add( label )
newTextBox=TextBox()
newTextBox.setEnabled(False)
newTextBox.setWidth(80)
statusBox=TextBox()
statusBox.setEnabled(False)
statusBox.setWidth(30)
newPanel.add(newTextBox)
newPanel.add(statusBox)
newPanel.setCellHorizontalAlignment( newTextBox, HasHorizontalAlignment.ALIGN_RIGHT )
newPanel.setCellHorizontalAlignment( statusBox, HasHorizontalAlignment.ALIGN_RIGHT )
newPanel.setCellWidth( statusBox, "20px" )
newPanel.setWidth("100%")
#newPanel.setStyleName("areaStyle");
#newPanel.setBorderWidth(5);
newTextBox.setText("select chip...")
newTextBox.addChangeListener(self)
newTextBox.setTitle(buttonName) # This isn't displayed, but it's useful to have stored
self.i2cValueEntries[buttonName]=newTextBox
self.statusValueEntries[buttonName]=statusBox
statusBox.setTitle(buttonName)
statusBox.setText("...")
flowPanel.add(newPanel)
return flowPanel
def __init__(self, *args, **kwargs):
# set defaults
if not 'StyleName' in kwargs:
kwargs['StyleName'] = "rjw-HorizontalCollapsePanel"
FlowPanel.__init__(self, *args, **kwargs)
self._containers = [
ScrollPanel(StyleName = self.getStylePrimaryName() + '-left'),
ScrollPanel(StyleName = self.getStylePrimaryName() + '-right'),
]
self._collapse_widget = ScrollPanel(StyleName = self.getStylePrimaryName() + '-collapse')
collapse_button = ToggleButton(StyleName = self.getStylePrimaryName() + '-collapse-button')
collapse_button.addClickListener(self._sync_collapse)
self._collapse_widget.add(collapse_button)
FlowPanel.add(self, self._containers[0])
FlowPanel.add(self, self._collapse_widget)
FlowPanel.add(self, self._containers[1])
self._sync_collapse()
def finishgroup():
global curgroup, curgroupwidgets, curgrouphead, fp
if curgroup == 0:
for widget in curgroupwidgets:
fp.add(widget)
elif curgroup == 1:
dp = DisclosurePanel("Definitions")
dpflow = FlowPanel()
dp.add(dpflow)
for widget in curgroupwidgets:
dpflow.add(widget)
fp.add(dp)
elif curgroup == 2:
curgrouphead += " (%s steps)" % (len(curgroupwidgets), )
dp = DisclosurePanel(curgrouphead)
dpflow = FlowPanel()
dp.add(dpflow)
for widget in curgroupwidgets[:-1]:
dpflow.add(widget)
fp.add(dp)
fp.add(curgroupwidgets[-1])
curgroup = 0
curgroupwidgets = []
curgrouphead = None
def reduceterm(sender, maxlines):
"""When the Reduce button is pressed: call cc.runfile with our input.
There is a maximum number of lines that we will output, to prevent a
stalling browser and an overfull document. The user can raise this limit
with a link.
"""
input = inputArea.getText()
output = ""
nlines = 0
def catchoutput(s, end="\n"):
output += s + end
nlines += 1
if nlines > maxlines:
raise OverlongOutput()
cc._defs = dict()
try:
cc.runfile(inputfile=io.StringIO(input),
verbose=False,
printout=catchoutput,
printerr=catchoutput)
except OverlongOutput:
extra = FlowPanel(StyleName="terminated")
extra.add(
InlineLabel("Reduction terminated after %s lines. " %
(maxlines, )))
extra.add(
Button(
"Try longer",
functools.partial(queuereduce,
maxlines=nextmaxlines(maxlines))))
showOutput(output, extra=extra)
except Exception, e:
Window.alert(e)
def finishgroup():
global curgroup, curgroupwidgets, curgrouphead, fp
if curgroup == 0:
for widget in curgroupwidgets:
fp.add(widget)
elif curgroup == 1:
dp = DisclosurePanel("Definitions")
dpflow = FlowPanel()
dp.add(dpflow)
for widget in curgroupwidgets:
dpflow.add(widget)
fp.add(dp)
elif curgroup == 2:
curgrouphead += " (%s steps)" % (len(curgroupwidgets),)
dp = DisclosurePanel(curgrouphead)
dpflow = FlowPanel()
dp.add(dpflow)
for widget in curgroupwidgets[:-1]:
dpflow.add(widget)
fp.add(dp)
fp.add(curgroupwidgets[-1])
curgroup = 0
curgroupwidgets = []
curgrouphead = None
def __init__(self, default_value='0', show_indices=True):
self._default_value = default_value
self._show_indices = show_indices
self._values = []
self.panel = FlowPanel()
def __init__(self):
Sink.__init__(self)
text="""This is a <code>ScrollPanel</code> contained at
the center of a <code>DockPanel</code>.
By putting some fairly large contents
in the middle and setting its size explicitly, it becomes a
scrollable area within the page, but without requiring the use of
an IFRAME.
Here's quite a bit more meaningless text that will serve primarily
to make this thing scroll off the bottom of its visible area.
Otherwise, you might have to make it really, really small in order
to see the nifty scroll bars!"""
contents = HTML(text)
scroller = ScrollPanel(contents, StyleName="ks-layouts-Scroller")
dock = DockPanel(HorizontalAlignment=HasAlignment.ALIGN_CENTER,
Spacing=10)
north0 = HTML("This is the <i>first</i> north component", True)
east = HTML("<center>This<br>is<br>the<br>east<br>component</center>", True)
south = HTML("This is the south component")
west = HTML("<center>This<br>is<br>the<br>west<br>component</center>", True)
north1 = HTML("This is the <b>second</b> north component", True)
dock.add(north0, DockPanel.NORTH)
dock.add(east, DockPanel.EAST)
dock.add(south, DockPanel.SOUTH)
dock.add(west, DockPanel.WEST)
dock.add(north1, DockPanel.NORTH)
dock.add(scroller, DockPanel.CENTER)
#Logger.write("Layouts", "TODO: flowpanel")
flow = FlowPanel()
for i in range(8):
flow.add(CheckBox("Flow %d" % i))
horz = HorizontalPanel(VerticalAlignment=HasAlignment.ALIGN_MIDDLE)
horz.add(Button("Button"))
horz.add(HTML("<center>This is a<br>very<br>tall thing</center>", True))
horz.add(Button("Button"))
vert = VerticalPanel(HorizontalAlignment=HasAlignment.ALIGN_CENTER)
vert.add(Button("Small"))
vert.add(Button("--- BigBigBigBig ---"))
vert.add(Button("tiny"))
menu = MenuBar()
menu0 = MenuBar(True)
menu1 = MenuBar(True)
menu.addItem("menu0", menu0)
menu.addItem("menu1", menu1)
menu0.addItem("child00")
menu0.addItem("child01")
menu0.addItem("child02")
menu1.addItem("child10")
menu1.addItem("child11")
menu1.addItem("child12")
#Logger.write("Layouts", "TODO: htmlpanel")
id = HTMLPanel.createUniqueId()
text="""This is an <code>HTMLPanel</code>. It allows you to add
components inside existing HTML, like this: <span id='%s' />
Notice how the menu just fits snugly in there? Cute.""" % id
html = HTMLPanel(text)
DOM.setStyleAttribute(menu.getElement(), "display", "inline")
html.add(menu, id)
disclose = DisclosurePanel("Click to disclose")
disclose.add(HTML("""<b>Ta-daaaaa!</b><br />Ok - it could have
been<br />more of a surprise."""))
panel = VerticalPanel(Spacing=8,
HorizontalAlignment=HasAlignment.ALIGN_CENTER)
panel.add(self.makeLabel("Dock Panel"))
panel.add(dock)
panel.add(self.makeLabel("Flow Panel"))
panel.add(flow)
panel.add(self.makeLabel("Horizontal Panel"))
panel.add(horz)
panel.add(self.makeLabel("Vertical Panel"))
panel.add(vert)
panel.add(self.makeLabel("HTML Panel"))
panel.add(html)
panel.add(self.makeLabel("Disclosure Panel"))
panel.add(disclose)
self.initWidget(panel)
self.setStyleName("ks-layouts")
def __init__(self):
Sink.__init__(self)
text = """This is a <code>ScrollPanel</code> contained at
the center of a <code>DockPanel</code>.
By putting some fairly large contents
in the middle and setting its size explicitly, it becomes a
scrollable area within the page, but without requiring the use of
an IFRAME.
Here's quite a bit more meaningless text that will serve primarily
to make this thing scroll off the bottom of its visible area.
Otherwise, you might have to make it really, really small in order
to see the nifty scroll bars!"""
contents = HTML(text)
scroller = ScrollPanel(contents, StyleName="ks-layouts-Scroller")
dock = DockPanel(HorizontalAlignment=HasAlignment.ALIGN_CENTER,
Spacing=10)
north0 = HTML("This is the <i>first</i> north component", True)
east = HTML("<center>This<br>is<br>the<br>east<br>component</center>",
True)
south = HTML("This is the south component")
west = HTML("<center>This<br>is<br>the<br>west<br>component</center>",
True)
north1 = HTML("This is the <b>second</b> north component", True)
dock.add(north0, DockPanel.NORTH)
dock.add(east, DockPanel.EAST)
dock.add(south, DockPanel.SOUTH)
dock.add(west, DockPanel.WEST)
dock.add(north1, DockPanel.NORTH)
dock.add(scroller, DockPanel.CENTER)
#Logger.write("Layouts", "TODO: flowpanel")
flow = FlowPanel()
for i in range(8):
flow.add(CheckBox("Flow %d" % i))
horz = HorizontalPanel(VerticalAlignment=HasAlignment.ALIGN_MIDDLE)
horz.add(Button("Button"))
horz.add(HTML("<center>This is a<br>very<br>tall thing</center>",
True))
horz.add(Button("Button"))
vert = VerticalPanel(HorizontalAlignment=HasAlignment.ALIGN_CENTER)
vert.add(Button("Small"))
vert.add(Button("--- BigBigBigBig ---"))
vert.add(Button("tiny"))
menu = MenuBar()
menu0 = MenuBar(True)
menu1 = MenuBar(True)
menu.addItem("menu0", menu0)
menu.addItem("menu1", menu1)
menu0.addItem("child00")
menu0.addItem("child01")
menu0.addItem("child02")
menu1.addItem("child10")
menu1.addItem("child11")
menu1.addItem("child12")
#Logger.write("Layouts", "TODO: htmlpanel")
id = HTMLPanel.createUniqueId()
text = """This is an <code>HTMLPanel</code>. It allows you to add
components inside existing HTML, like this: <span id='%s' />
Notice how the menu just fits snugly in there? Cute.""" % id
html = HTMLPanel(text)
DOM.setStyleAttribute(menu.getElement(), "display", "inline")
html.add(menu, id)
disclose = DisclosurePanel("Click to disclose")
disclose.add(
HTML("""<b>Ta-daaaaa!</b><br />Ok - it could have
been<br />more of a surprise."""))
panel = VerticalPanel(Spacing=8,
HorizontalAlignment=HasAlignment.ALIGN_CENTER)
panel.add(self.makeLabel("Dock Panel"))
panel.add(dock)
panel.add(self.makeLabel("Flow Panel"))
panel.add(flow)
panel.add(self.makeLabel("Horizontal Panel"))
panel.add(horz)
panel.add(self.makeLabel("Vertical Panel"))
panel.add(vert)
panel.add(self.makeLabel("HTML Panel"))
panel.add(html)
panel.add(self.makeLabel("Disclosure Panel"))
panel.add(disclose)
self.initWidget(panel)
self.setStyleName("ks-layouts")
def __init__(self, **kwargs):
Width = kwargs.get("Width")
self.table = FlowPanel(Width=Width, StyleName="wordpanel")
ScrollPanel.__init__(self, self.table, **kwargs)
class FlowTabBar(Composite):
STYLENAME_DEFAULT = "gwt-TabBarItem"
def __init__(self, **kwargs):
if not kwargs.has_key('StyleName'): kwargs['StyleName'] = "gwt-TabBar"
# this is awkward: FlowPanel is the composite,
# so we either the element here, and pass it in to FlowPanel.
element = None
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
self.panel = FlowPanel(Element=element)
self.selectedTab = None
self.tabListeners = []
#self.panel.setVerticalAlignment(HasAlignment.ALIGN_BOTTOM)
first = HTML(" ", True)
rest = HTML(" ", True)
first.setStyleName("gwt-TabBarFirst")
rest.setStyleName("gwt-TabBarRest")
first.setHeight("100%")
rest.setHeight("100%")
self.panel.add(first)
self.panel.add(rest)
first.setHeight("100%")
#self.panel.setCellHeight(first, "100%")
#self.panel.setCellWidth(rest, "100%")
Composite.__init__(self, self.panel, **kwargs)
self.sinkEvents(Event.ONCLICK)
def addTab(self, text, asHTML=False):
self.insertTab(text, asHTML, self.getTabCount())
def addTabListener(self, listener):
self.tabListeners.append(listener)
def getSelectedTab(self):
if self.selectedTab is None:
return -1
return self.panel.getWidgetIndex(self.selectedTab) - 1
def getTabCount(self):
return self.panel.getWidgetCount() - 2
def getTabHTML(self, index):
if index >= self.getTabCount():
return None
delPanel = self.panel.getWidget(index + 1)
focusablePanel = delPanel.getFocusablePanel()
widget = focusablePanel.getWidget()
if hasattr(widget, "getHTML"):
return widget.getHTML()
elif hasattr(widget,
"getText"): # assume it's a Label if it has getText
return widget.getText()
else:
fpe = DOM.getParent(self.focusablePanel.getElement())
return DOM.getInnerHTML(fpe)
def createTabTextWrapper(self):
return None
def insertTab(self, text, asHTML, beforeIndex=None):
""" 1st arg can, instead of being 'text', be a widget
"""
if beforeIndex is None:
beforeIndex = asHTML
asHTML = False
if (beforeIndex < 0) or (beforeIndex > self.getTabCount()):
#throw new IndexOutOfBoundsException();
pass
if isinstance(text, basestring):
if asHTML:
item = HTML(text)
else:
item = Label(text)
item.setWordWrap(False)
else:
# passing in a widget, it's expected to have its own style
item = text
self.insertTabWidget(item, beforeIndex)
def insertTabWidget(self, widget, beforeIndex):
delWidget = ClickDelegatePanel(self, widget, self, self)
delWidget.setStyleName(self.STYLENAME_DEFAULT)
focusablePanel = delWidget.getFocusablePanel()
self.panel.insert(delWidget, self.panel.getElement(), beforeIndex + 1)
parent = DOM.getParent(delWidget.getElement())
#DOM.setStyleAttribute(parent, "flow", "left")
#DOM.setStyleAttribute(parent, "display", "inline")
self.setStyleName(parent, self.STYLENAME_DEFAULT + "-wrapper", True)
#print "insertTabWidget", DOM.getParent(delWidget.getElement()), DOM.getAttribute(DOM.getParent(delWidget.getElement()), "className")
def onClick(self, sender=None):
for i in range(1, self.panel.getWidgetCount() - 1):
if DOM.isOrHasChild(
self.panel.getWidget(i).getElement(), sender.getElement()):
return self.selectTab(i - 1)
return False
def removeTab(self, index):
self.checkTabIndex(index)
toRemove = self.panel.getWidget(index + 1)
if toRemove == self.selectedTab:
self.selectedTab = None
self.panel.remove(toRemove)
def removeTabListener(self, listener):
self.tabListeners.remove(listener)
def selectTab(self, index):
self.checkTabIndex(index)
for listener in self.tabListeners:
if not listener.onBeforeTabSelected(self, index):
return False
self.setSelectionStyle(self.selectedTab, False)
if index == -1:
self.selectedTab = None
return True
self.selectedTab = self.panel.getWidget(index + 1)
self.setSelectionStyle(self.selectedTab, True)
for listener in self.tabListeners:
listener.onTabSelected(self, index)
return True
def checkTabIndex(self, index):
if (index < -1) or (index >= self.getTabCount()):
#throw new IndexOutOfBoundsException();
pass
def setSelectionStyle(self, item, selected):
if item is not None:
if selected:
item.addStyleName("gwt-TabBarItem-selected")
self.setStyleName(DOM.getParent(item.getElement()),
"gwt-TabBarItem-wrapper-selected", True)
else:
item.removeStyleName("gwt-TabBarItem-selected")
self.setStyleName(DOM.getParent(item.getElement()),
"gwt-TabBarItem-wrapper-selected", False)
def __init__(self, **kwargs):
if not kwargs.has_key('Element'):
kwargs['Element'] = DOM.createElement('fieldset')
self.fields = {}
FlowPanel.__init__(self, **kwargs)
def onRemoteResponse(self, response, request_info):
mname = request_info.method
if mname == "customize_message":
showCustomizationResult(self, response, request_info)
return
if mname == "get_messagesdata_for_cust":
locations_data = response["locations"]
selectionbox = VerticalPanel(Padding=3)
locations = ListBox()
for (loc_name, loc_id) in locations_data:
locations.addItem(loc_id, loc_name)
messages = ListBox()
messages.setName("locations")
messages.addItem(location_select_label)
for (name, d) in response["messages"].items():
messages.addItem(d['label'], name)
locations.addChangeListener(self)
messages.addChangeListener(self)
self.locations = locations
self.messages = messages
locationbox = HorizontalPanel()
locationbox.add(Label("Location: ", StyleName="text", Width=80))
locationbox.add(locations)
msgnamebox = HorizontalPanel()
msgnamebox.add(Label("Message: ", StyleName="text", Width=80))
msgnamebox.add(messages)
selectionbox.add(locationbox)
selectionbox.add(msgnamebox)
mainpanel = VerticalPanel(StyleName="dataBoxContent")
mainpanel.add(selectionbox)
self.mainpanel = mainpanel
root = RootPanel()
root.add(mainpanel)
if mname == "get_messagecustdata":
self.messages_data = response
buttonspanel = FlowPanel(Spacing=1, Padding=1, Width=600)
#buttonspanel.add(Label("Macros:", StyleName="text"))
for macro_d in self.messages_data['macros']:
macrobutton = Button(macro_d['label'], self, StyleName="buttonlikelink")#"nicebutton small")
macrobutton.name = macro_d['name']
buttonspanel.add(macrobutton)
msgpanel = VerticalPanel(Padding=1, Spacing=1)
messagebox = TextArea()
messagebox.setCharacterWidth(70)
height = len(self.messages_data["text"].split('\n')) + 1
messagebox.setVisibleLines(height)
messagebox.setText(self.messages_data["text"])
messagebox.setName("textBoxFormElement")
self.messagebox = messagebox
msgpanel.add(messagebox)
self.statusbar = Label(StyleName="errorMessage")
msgpanel.add(self.statusbar)
actionbuttons = HorizontalPanel(Spacing=2)
updatebutton = Button("Update", self, StyleName="nicebutton small yellow")
updatebutton.name = "update"
actionbuttons.add(updatebutton)
#actionbuttons.add(Button("Send me a preview mail"))
msgpanel.add(actionbuttons)
editorbox = VerticalPanel(Padding=1)
editorbox.add(buttonspanel)
editorbox.add(msgpanel)
editorpanel = CaptionPanel("Message editor", editorbox, Padding=1, StyleName="text")
editorpanel.name = "editorpanel"
self.editorpanel = editorpanel
self.mainpanel.add(editorpanel)
def onModuleLoad(self):
dlp = DockPanel(Width="100%", Height="100%")
self.m_rte = RichTextArea(Width="500px", Height="400px")
self.m_tb = RichTextToolbar(self.m_rte, self)
buts = FlowPanel()
self.m_getCurr = Button("Refresh v", self)
self.m_setHtml = Button("Set html ^", self)
self.m_setHtml.setTitle("Set html from the lower left text area")
self.m_toSCursor = Button("< To Cursor", self)
self.m_toSCursor.setTitle("Set the selection to be a cursor at the beginning of the current selection")
self.m_toECursor = Button("To Cursor >", self)
self.m_toECursor.setTitle("Set the selection to be a cursor at the end of the current selection")
self.m_surround1 = Button("Surround1", self)
self.m_surround2 = Button("Surround2", self)
self.m_font1 = Button("Times New Roman", self)
self.m_font2 = Button("Arial", self)
grid = Grid(2, 2)
self.m_startNode = self.createTextBox(1)
self.m_startOffset = self.createTextBox(3)
self.m_endNode = self.createTextBox(4)
self.m_endOffset = self.createTextBox(5)
self.m_select = Button("`>Select", self)
self.m_select.setTitle("Select the texts/offsets in the boxes above")
self.m_cursor = Button("`>Cursor", self)
self.m_cursor.setTitle("Set cursor to text/offset of top 2 boxes above")
grid.setWidget(0, 0, self.m_startNode)
grid.setWidget(0, 1, self.m_startOffset)
grid.setWidget(1, 0, self.m_endNode)
grid.setWidget(1, 1, self.m_endOffset)
self.m_deleteSel = Button("Delete", self)
self.m_reset = Button("Reset", self)
buts.add(self.m_getCurr)
buts.add(self.m_setHtml)
buts.add(self.m_toSCursor)
buts.add(self.m_toECursor)
buts.add(self.m_font1)
buts.add(self.m_font2)
buts.add(self.m_surround1)
buts.add(self.m_surround2)
buts.add(grid)
buts.add(self.m_select)
buts.add(self.m_cursor)
buts.add(self.m_deleteSel)
buts.add(self.m_reset)
dlp.add(buts, DockPanel.WEST)
textPanels = DockPanel()
self.m_html = TextArea()
self.m_html.setSize("100%", "100%")
self.m_sel = TextArea()
self.m_sel.setSize("100%", "100%")
textPanels.add(self.m_sel, DockPanel.EAST)
textPanels.add(self.m_html, DockPanel.WEST)
dlp.add(textPanels, DockPanel.SOUTH)
dlp.add(self.m_tb, DockPanel.NORTH)
dlp.add(self.m_rte, DockPanel.CENTER)
rp = RootPanel.get()
rp.add(dlp)
DeferredCommand.add(getattr(self, "set_html_focus"))
self.reset()
class UserListPanel(VerticalPanel):
def __init__(self, tabPanel, topPanel, **kwargs):
VerticalPanel.__init__(self, StyleName='user-list-panel', **kwargs)
self.tabPanel = tabPanel
self.topPanel = topPanel
self.iconAdder = None
self.iconPanel = None
self.nSelected = 0
self.leftPanelWidth = 340
self.widthFudgeFactor = 25
def clear(self):
VerticalPanel.clear(self)
self.nSelected = 0
def updateResultLink(self):
self.resultLink.setHTML('Results: <a href="%s">link</a>' %
self.tabPanel.resultsLink())
def setUsers(self, title, users, kwargs):
self.users = users
self.nUsers = len(users)
self.title = title
self.resultPanel = HorizontalPanel(StyleName='result-panel')
self.add(self.resultPanel)
self.leftPanel = VerticalPanel(StyleName='results-left-panel',
Width=self.leftPanelWidth)
self.resultPanel.add(self.leftPanel)
if not users:
self.iconPanel = None
self.leftPanel.add(HTML(title, StyleName='result-title'))
else:
# Set a display order that will show everything for now.
self.displayOrder = range(self.nUsers)
self.largeAvatar = LargeAvatar(self, self.tabPanel, self.topPanel)
self.leftPanel.add(self.largeAvatar)
resultPanelBottomLeft = VerticalPanel(
StyleName='results-left-panel-bottom-left')
self.resultLink = HTML(StyleName='result-detail')
self.updateResultLink()
resultPanelBottomLeft.add(self.resultLink)
self.iconSizePanel = HorizontalPanel()
self.iconSizePanel.add(
HTML('Icons: ', StyleName='result-detail'))
self.iconSizeLb = lb = ListBox()
i = 0
for text, key in _iconData:
lb.addItem(text, key)
if key == _iconSize:
lb.setSelectedIndex(i)
i += 1
lb.addChangeListener(IconSizeChanger(self))
self.iconSizePanel.add(lb)
resultPanelBottomLeft.add(self.iconSizePanel)
if self.nUsers > 1:
self.sortPanel = HorizontalPanel()
self.sortPanel.add(
HTML('Sort: ', StyleName='result-detail'))
self.lb = lb = ListBox()
i = 0
for text, key in _sortKeyData:
lb.addItem(text, key)
if key == _sortKey:
lb.setSelectedIndex(i)
i += 1
lb.addChangeListener(self)
self.sortPanel.add(lb)
resultPanelBottomLeft.add(self.sortPanel)
self.filterPanel = HorizontalPanel()
resultPanelBottomLeft.add(self.filterPanel)
self.addFilterWidgets()
if self.topPanel.loggedIn():
if 'screennames' in kwargs:
resultPanelBottomLeft.add(tweet.SimpleTweetPanel(
kwargs['screennames'], len(self.users), self.topPanel))
elif 'query' in kwargs:
resultPanelBottomLeft.add(tweet.PrepareTweetButton(
kwargs['query'], len(self.users),
self.tabPanel.tabName, self.topPanel))
self.leftPanel.add(resultPanelBottomLeft)
self.iconPanel = VerticalPanel(StyleName='icon-outer-panel')
self.resultPanel.add(self.iconPanel)
self.images = []
for u in users:
url = u['profile_image_url']
i = Image(url, StyleName='avatar-' + _iconSize)
# Does calling prefetch actually help?
i.prefetch(url)
i._user = u
i._selected = False
i.addMouseListener(self)
self.images.append(i)
self.showUsers()
def addFilterWidgets(self):
"""If we're logged in (and hence the friends list is available),
create a filter listbox. If not, tell the loginPanel that we exist
so it can call us when the login is complete."""
if self.topPanel.loggedIn():
# Window.alert('Logged in')
self.filterPanel.add(
HTML('Filter: ', StyleName='result-detail'))
self.filterChanger = FilterChanger(self, self.topPanel)
self.filterBox = ListBox()
self.filterBox.addItem('None', 0)
self.filterBox.addItem(
'Following (%d of %d)' %
(self.filterChanger.nFriends, self.nUsers), 1)
self.filterBox.addItem(
"Not following (%d of %d)" %
(self.nUsers - self.filterChanger.nFriends, self.nUsers), 2)
self.filterBox.addChangeListener(self.filterChanger)
self.filterPanel.add(self.filterBox)
else:
# Not yet logged in. Add ourselves to the list of UserListPanels
# that the loginPanel will call when it's ready.
self.topPanel.loginPanel.addUserListPanel(self)
def onChange(self, sender):
global _sortKey
_sortKey = self.lb.getValue(self.lb.getSelectedIndex())
self.updateResultLink()
self.showUsers()
def showUsers(self):
# Cancel any existing timed icon additions before changing
# self.displayOrder.
if self.iconAdder is not None:
self.iconAdder.cancel()
self.iconAdder = None
self.iconPanel.clear()
# Set a title above the icons.
if hasattr(self, 'filterChanger'):
order = self.filterChanger.currentOrder
if order == 0:
title = self.title
else:
if order == 1:
n = self.filterChanger.nFriends
detail = 'follow'
else:
n = self.nUsers - self.filterChanger.nFriends
detail = "don't follow"
if n == 0:
if detail == 'follow':
title = "You don't follow any of them!"
else:
title = "You already follow them all!"
else:
if n > 1:
plural = 's'
else:
plural = ''
title = 'The %d user%s you %s:' % (n, plural, detail)
else:
title = self.title
self.iconPanel.add(HTML(title, StyleName='result-title'))
if not self.displayOrder:
# There are no users to show.
return
decreasing = _sortKey in (
'friends_count', 'followers_count', 'statuses_count')
alpha = _sortKey in ('screen_name', 'name', 'location')
def _keyFunc(n):
value = self.users[n][_sortKey]
if decreasing:
return -1 * value
elif alpha:
if value:
return value.lower().strip()
else:
# Uh, put this towards the end (of ASCII at least)
return '~~~'
else:
return value
# Don't use sorted here, as it replaces the display order list
# (which is actually being maintained for us by our FilterChanger
# instance).
self.displayOrder.sort(key=_keyFunc)
self.icons = FlowPanel(StyleName='icon-panel')
self.adjustWidths()
self.iconPanel.add(self.icons)
self.iconAdder = IconAdder(self)
Timer.Timer(1, self.iconAdder)
if self.nSelected == 0:
self.largeAvatar.setUser(self.users[self.displayOrder[0]])
def onMouseEnter(self, img):
if not self.nSelected:
self.largeAvatar.setUser(img._user)
def onMouseMove(self, img, x, y):
pass
def onMouseLeave(self, img):
pass
def onMouseDown(self, img, x, y):
self.largeAvatar.setUser(img._user)
if not img._selected and self.nSelected:
self._unselectAll()
self._toggleSelect(img)
def onMouseUp(self, img, x, y):
pass
def _toggleSelect(self, img):
if img._selected:
self._unselect(img)
else:
self._select(img)
def _unselect(self, img):
if img._selected:
img.removeStyleDependentName('selected')
self.nSelected -= 1
img._selected = False
def _select(self, img):
if not img._selected:
img.addStyleDependentName('selected')
self.nSelected += 1
img._selected = True
def _unselectAll(self):
for img in self.images:
self._unselect(img)
def unselectNotFollowed(self):
for img in self.images:
if not img._user['following'] and img._selected:
self._unselect(img)
def unselectFollowed(self):
for img in self.images:
if img._user['following'] and img._selected:
self._unselect(img)
def setIconSizes(self):
for img in self.images:
selected = img._selected
if selected:
self._unselect(img)
img.setStyleName('avatar-' + _iconSize)
if selected:
self._select(img)
def adjustWidths(self, windowWidth=None):
if windowWidth is None:
windowWidth = Window.getClientWidth()
width = windowWidth - self.leftPanelWidth - self.widthFudgeFactor
if self.iconPanel is not None:
self.icons.setWidth(width)
def adjustSize(self, width, height):
self.adjustWidths(width)
def showUsers(self):
# Cancel any existing timed icon additions before changing
# self.displayOrder.
if self.iconAdder is not None:
self.iconAdder.cancel()
self.iconAdder = None
self.iconPanel.clear()
# Set a title above the icons.
if hasattr(self, 'filterChanger'):
order = self.filterChanger.currentOrder
if order == 0:
title = self.title
else:
if order == 1:
n = self.filterChanger.nFriends
detail = 'follow'
else:
n = self.nUsers - self.filterChanger.nFriends
detail = "don't follow"
if n == 0:
if detail == 'follow':
title = "You don't follow any of them!"
else:
title = "You already follow them all!"
else:
if n > 1:
plural = 's'
else:
plural = ''
title = 'The %d user%s you %s:' % (n, plural, detail)
else:
title = self.title
self.iconPanel.add(HTML(title, StyleName='result-title'))
if not self.displayOrder:
# There are no users to show.
return
decreasing = _sortKey in (
'friends_count', 'followers_count', 'statuses_count')
alpha = _sortKey in ('screen_name', 'name', 'location')
def _keyFunc(n):
value = self.users[n][_sortKey]
if decreasing:
return -1 * value
elif alpha:
if value:
return value.lower().strip()
else:
# Uh, put this towards the end (of ASCII at least)
return '~~~'
else:
return value
# Don't use sorted here, as it replaces the display order list
# (which is actually being maintained for us by our FilterChanger
# instance).
self.displayOrder.sort(key=_keyFunc)
self.icons = FlowPanel(StyleName='icon-panel')
self.adjustWidths()
self.iconPanel.add(self.icons)
self.iconAdder = IconAdder(self)
Timer.Timer(1, self.iconAdder)
if self.nSelected == 0:
self.largeAvatar.setUser(self.users[self.displayOrder[0]])
def __init__(self):
SimplePanel.__init__(self)
flow = FlowPanel(Width="400px")
flow.add(Button("Item 1"))
flow.add(Button("Item 2"))
flow.add(Button("Item 3"))
flow.add(Button("Item 4"))
flow.add(Button("Item 5"))
flow.add(Button("Item 6"))
flow.add(Button("Item 7"))
flow.add(Button("Item 8"))
flow.add(Button("Item 9"))
flow.add(Button("Item 10"))
self.add(flow)
class FlowTabBar(Composite):
STYLENAME_DEFAULT = "gwt-TabBarItem"
def __init__(self, **kwargs):
if not kwargs.has_key('StyleName'): kwargs['StyleName']="gwt-TabBar"
# this is awkward: FlowPanel is the composite,
# so we either the element here, and pass it in to FlowPanel.
element = None
if kwargs.has_key('Element'):
element = kwargs.pop('Element')
self.panel = FlowPanel(Element=element)
self.selectedTab = None
self.tabListeners = []
#self.panel.setVerticalAlignment(HasAlignment.ALIGN_BOTTOM)
first = HTML(" ", True)
rest = HTML(" ", True)
first.setStyleName("gwt-TabBarFirst")
rest.setStyleName("gwt-TabBarRest")
first.setHeight("100%")
rest.setHeight("100%")
self.panel.add(first)
self.panel.add(rest)
first.setHeight("100%")
#self.panel.setCellHeight(first, "100%")
#self.panel.setCellWidth(rest, "100%")
Composite.__init__(self, self.panel, **kwargs)
self.sinkEvents(Event.ONCLICK)
def addTab(self, text, asHTML=False):
self.insertTab(text, asHTML, self.getTabCount())
def addTabListener(self, listener):
self.tabListeners.append(listener)
def getSelectedTab(self):
if self.selectedTab is None:
return -1
return self.panel.getWidgetIndex(self.selectedTab) - 1
def getTabCount(self):
return self.panel.getWidgetCount() - 2
def getTabHTML(self, index):
if index >= self.getTabCount():
return None
delPanel = self.panel.getWidget(index + 1)
focusablePanel = delPanel.getFocusablePanel()
widget = focusablePanel.getWidget()
if hasattr(widget, "getHTML"):
return widget.getHTML()
elif hasattr(widget, "getText"): # assume it's a Label if it has getText
return widget.getText()
else:
fpe = DOM.getParent(self.focusablePanel.getElement())
return DOM.getInnerHTML(fpe)
def createTabTextWrapper(self):
return None
def insertTab(self, text, asHTML, beforeIndex=None):
""" 1st arg can, instead of being 'text', be a widget
"""
if beforeIndex is None:
beforeIndex = asHTML
asHTML = False
if (beforeIndex < 0) or (beforeIndex > self.getTabCount()):
#throw new IndexOutOfBoundsException();
pass
if isinstance(text, basestring):
if asHTML:
item = HTML(text)
else:
item = Label(text)
item.setWordWrap(False)
else:
# passing in a widget, it's expected to have its own style
item = text
self.insertTabWidget(item, beforeIndex)
def insertTabWidget(self, widget, beforeIndex):
delWidget = ClickDelegatePanel(self, widget, self, self)
delWidget.setStyleName(self.STYLENAME_DEFAULT)
focusablePanel = delWidget.getFocusablePanel()
self.panel.insert(delWidget, self.panel.getElement(), beforeIndex + 1)
parent = DOM.getParent(delWidget.getElement())
#DOM.setStyleAttribute(parent, "flow", "left")
#DOM.setStyleAttribute(parent, "display", "inline")
self.setStyleName(parent,
self.STYLENAME_DEFAULT + "-wrapper", True)
#print "insertTabWidget", DOM.getParent(delWidget.getElement()), DOM.getAttribute(DOM.getParent(delWidget.getElement()), "className")
def onClick(self, sender=None):
for i in range(1, self.panel.getWidgetCount() - 1):
if DOM.isOrHasChild(self.panel.getWidget(i).getElement(),
sender.getElement()):
return self.selectTab(i - 1)
return False
def removeTab(self, index):
self.checkTabIndex(index)
toRemove = self.panel.getWidget(index + 1)
if toRemove == self.selectedTab:
self.selectedTab = None
self.panel.remove(toRemove)
def removeTabListener(self, listener):
self.tabListeners.remove(listener)
def selectTab(self, index):
self.checkTabIndex(index)
for listener in self.tabListeners:
if not listener.onBeforeTabSelected(self, index):
return False
self.setSelectionStyle(self.selectedTab, False)
if index == -1:
self.selectedTab = None
return True
self.selectedTab = self.panel.getWidget(index + 1)
self.setSelectionStyle(self.selectedTab, True)
for listener in self.tabListeners:
listener.onTabSelected(self, index)
return True
def checkTabIndex(self, index):
if (index < -1) or (index >= self.getTabCount()):
#throw new IndexOutOfBoundsException();
pass
def setSelectionStyle(self, item, selected):
if item is not None:
if selected:
item.addStyleName("gwt-TabBarItem-selected")
self.setStyleName(DOM.getParent(item.getElement()),
"gwt-TabBarItem-wrapper-selected", True)
else:
item.removeStyleName("gwt-TabBarItem-selected")
self.setStyleName(DOM.getParent(item.getElement()),
"gwt-TabBarItem-wrapper-selected", False)
def showOutput(output, extra=None, nlHTML="<br>"):
"""Clear outputPanel and show newline-separated output in it.
The following types of lines will be parsed differently:
- A sequence of "-> term", "-> term" will get a DisclosurePanel.
- Definitions will be collapsed in a DisclosurePanel.
If extra is set, then append that widget."""
lines = splitlines(output.strip())
if lines:
outputPanel.clear()
fp = FlowPanel()
outputPanel.add(fp)
# Add content to the FlowPanel
# We distinguish a number of line groups:
#
# 0: no special handling.
# 1: definition group
# 2: reduction group
curgroup = 0
curgroupwidgets = []
curgrouphead = None
RARROW = chr(0x2192)
def fixarrow(line):
return line
def addline(line):
global curgroup, curgroupwidgets, curgrouphead, fp
line = line.strip()
line = line.replace("->", RARROW)
if line.startswith("Installing "):
# New group: 1
if curgroup != 1: finishgroup()
curgroup = 1
curgroupwidgets.append(Label(line))
elif line.startswith(RARROW):
# New group: 2.
if curgroup == 0:
# The last line is still stored in curgroupwidgets. We use
# it as the DisclosurePanel head.
assert curgrouphead == None
if curgroupwidgets == []:
curgrouphead = "unknown reduction"
else:
assert len(curgroupwidgets) == 1
curgrouphead = curgroupwidgets[0].getText()
curgroupwidgets = []
elif curgroup != 2:
finishgroup()
curgroup = 2
curgroupwidgets.append(Label(line))
# Window.alert(curgroupwidgets)
else:
# New group: 0
finishgroup()
curgroup = 0
curgroupwidgets = [Label(line)]
def finishgroup():
global curgroup, curgroupwidgets, curgrouphead, fp
if curgroup == 0:
for widget in curgroupwidgets:
fp.add(widget)
elif curgroup == 1:
dp = DisclosurePanel("Definitions")
dpflow = FlowPanel()
dp.add(dpflow)
for widget in curgroupwidgets:
dpflow.add(widget)
fp.add(dp)
elif curgroup == 2:
curgrouphead += " (%s steps)" % (len(curgroupwidgets), )
dp = DisclosurePanel(curgrouphead)
dpflow = FlowPanel()
dp.add(dpflow)
for widget in curgroupwidgets[:-1]:
dpflow.add(widget)
fp.add(dp)
fp.add(curgroupwidgets[-1])
curgroup = 0
curgroupwidgets = []
curgrouphead = None
for line in lines:
addline(line)
finishgroup()
# fp.add(InlineLabel(lines[0]))
# for line in lines[1:]:
# fp.add(InlineHTML(nlHTML))
# fp.add(InlineLabel(line))
if extra != None:
outputPanel.add(extra)
# outputPanel.add(Label(output))
outputPanel.setStyleName("proper")
else:
showOutputMeta("No output.")
def __init__(self, changeLanguage, **kwargs):
FlowPanel.__init__(self, **kwargs)
self.setID('header')
#---------------------------------------------------------------------------------------------------
div = Element(Element=DOM.createDiv(), StyleName='btn-group2')
self.buttonBlocks = Button(_('Blocks'),
self.showBlocks,
classIcon="icon-selected")
div.add(self.buttonBlocks)
self.buttonHarwares = Button(_('Components'),
self.showHardwares,
classIcon="icon-deselected")
div.add(self.buttonHarwares)
self.add(div)
#---------------------------------------------------------------------------------------------------
div = Element(Element=DOM.createDiv(),
StyleName='btn-group2 groupHidden')
self.buttonMakeBlock = Button(_('Building Block'),
self.makeBlock,
classIcon="icon-buildBlock")
div.add(self.buttonMakeBlock)
#self.dropdownMakeBlock = Dropdown('', None, self.makeBlockItemClick, StyleName='dropdown_btn', rootPanel=div)
#self.dropdownMakeBlock.addValue('Importar Bloco', 'icon-ImportBlock')
#self.dropdownMakeBlock.addValue('Exportar Bloco', 'icon-ExportBlock')
#div.add(self.dropdownMakeBlock)
self.add(div)
#---------------------------------------------------------------------------------------------------
#div = Element(Element=DOM.createDiv(), StyleName='btn-group2')
#self.buttonReload = Button(_('Reload'), self.reloadClick, classIcon="icon-repeat")
#div.add(self.buttonReload)
#self.add(div)
#---------------------------------------------------------------------------------------------------
div = Element(Element=DOM.createDiv(),
StyleName='btn-group2 groupHidden')
self.buttonUndo = Button(_('Undo'), undo, classIcon="icon-undo")
div.add(self.buttonUndo)
self.buttonRedo = Button(_('Redo'), redo, classIcon="icon-redo")
div.add(self.buttonRedo)
self.add(div)
#self.buttonUndo2 = Button("Desfazer2", self.undo2)
#self.add(self.buttonUndo2)
#self.buttonRedo2 = Button("Refazer2", self.redo2)
#self.add(self.buttonRedo2)
#---------------------------------------------------------------------------------------------------
div = Element(Element=DOM.createDiv(),
StyleName='btn-group2 groupHidden')
self.buttonOpen = Button(_('Open'), loadState, classIcon="icon-open")
div.add(self.buttonOpen)
self.buttonSave = Button(_('Save'),
saveState,
classIcon="icon-download")
self.buttonSave.setID("btnSave")
div.add(self.buttonSave)
self.add(div)
#---------------------------------------------------------------------------------------------------
div = Element(Element=DOM.createDiv(), StyleName='btn-group')
self.codeGenerator = GenerateCodeButtonListener(
getWorkspace().getCodePanel())
self.buttonTranslate = Button(_("Translate"), self.codeGenerator)
self.buttonTranslate.addMouseListener(self)
div.add(self.buttonTranslate)
self.dropdownTranslate = Dropdown('',
None,
self.translateItemClick,
StyleName='dropdown_btn',
rootPanel=div)
self.isAutomatic = False
self.dropdownTranslate.addValue(gettext_noop('Manual'),
'icon-selected')
self.dropdownTranslate.addValue(gettext_noop('Automatic'),
'icon-deselected')
div.add(self.dropdownTranslate)
self.add(div)
#---------------------------------------------------------------------------------------------------
div = Element(Element=DOM.createDiv(), StyleName='btn-group2')
self.changeLanguage = changeLanguage
self.dropdownFlag = Dropdown('',
None,
self.flagItemClick,
StyleName='dropdown_btn flag',
classIcon='icon-pt_BR')
self.dropdownFlag.addValue('Português', 'icon-pt_BR')
self.dropdownFlag.addValue('English', 'icon-en_US')
self.dropdownFlag.addValue('Español', 'icon-es_ES')
self.dropdownFlag.addValue('Italiano', 'icon-it_IT')
self.dropdownFlag.addMouseListener(TooltipListener("Idioma"))
div.add(self.dropdownFlag)
self.add(div)
#---------------------------------------------------------------------------------------------------
self.mainStack = []
def onModuleLoad(self):
dlp = DockPanel(Width="100%", Height="100%")
self.m_rte = RichTextArea(Width="500px", Height="400px")
self.m_tb = RichTextToolbar(self.m_rte, self)
buts = FlowPanel()
self.m_getCurr = Button("Refresh v", self)
self.m_setHtml = Button("Set html ^", self)
self.m_setHtml.setTitle("Set html from the lower left text area")
self.m_toSCursor = Button("< To Cursor", self)
self.m_toSCursor.setTitle(
"Set the selection to be a cursor at the beginning of the current selection"
)
self.m_toECursor = Button("To Cursor >", self)
self.m_toECursor.setTitle(
"Set the selection to be a cursor at the end of the current selection"
)
self.m_surround1 = Button("Surround1", self)
self.m_surround2 = Button("Surround2", self)
self.m_font1 = Button("Times New Roman", self)
self.m_font2 = Button("Arial", self)
grid = Grid(2, 2)
self.m_startNode = self.createTextBox(1)
self.m_startOffset = self.createTextBox(3)
self.m_endNode = self.createTextBox(4)
self.m_endOffset = self.createTextBox(5)
self.m_select = Button("`>Select", self)
self.m_select.setTitle("Select the texts/offsets in the boxes above")
self.m_cursor = Button("`>Cursor", self)
self.m_cursor.setTitle(
"Set cursor to text/offset of top 2 boxes above")
grid.setWidget(0, 0, self.m_startNode)
grid.setWidget(0, 1, self.m_startOffset)
grid.setWidget(1, 0, self.m_endNode)
grid.setWidget(1, 1, self.m_endOffset)
self.m_deleteSel = Button("Delete", self)
self.m_reset = Button("Reset", self)
buts.add(self.m_getCurr)
buts.add(self.m_setHtml)
buts.add(self.m_toSCursor)
buts.add(self.m_toECursor)
buts.add(self.m_font1)
buts.add(self.m_font2)
buts.add(self.m_surround1)
buts.add(self.m_surround2)
buts.add(grid)
buts.add(self.m_select)
buts.add(self.m_cursor)
buts.add(self.m_deleteSel)
buts.add(self.m_reset)
dlp.add(buts, DockPanel.WEST)
textPanels = DockPanel()
self.m_html = TextArea()
self.m_html.setSize("100%", "100%")
self.m_sel = TextArea()
self.m_sel.setSize("100%", "100%")
textPanels.add(self.m_sel, DockPanel.EAST)
textPanels.add(self.m_html, DockPanel.WEST)
dlp.add(textPanels, DockPanel.SOUTH)
dlp.add(self.m_tb, DockPanel.NORTH)
dlp.add(self.m_rte, DockPanel.CENTER)
rp = RootPanel.get()
rp.add(dlp)
DeferredCommand.add(getattr(self, "set_html_focus"))
self.reset()
def __init__(self):
SimplePanel.__init__(self)
flow = FlowPanel(Width="400px")
flow.add(Button("Item 1"))
flow.add(Button("Item 2"))
flow.add(Button("Item 3"))
flow.add(Button("Item 4"))
flow.add(Button("Item 5"))
flow.add(Button("Item 6"))
flow.add(Button("Item 7"))
flow.add(Button("Item 8"))
flow.add(Button("Item 9"))
flow.add(Button("Item 10"))
self.add(flow)
def __init__(self, worksheet, id):
SimplePanel.__init__(self)
MouseHandler.__init__(self)
self._id = id
self._worksheet = worksheet
insert_new_cell = HTML("", StyleName="insert_new_cell")
insert_new_cell.addClickListener(InsertListener(worksheet, self._id))
input_prompt = HTML("In [%d]:" % self._id, Element=DOM.createSpan(),
StyleName="input_prompt")
cell_input = InputArea(worksheet, self._id, StyleName='cell_input')
evaluate_button = HTML("evaluate", Element=DOM.createAnchor(),
StyleName="eval_button", Visible=False)
evaluate_button.getElement().setAttribute("href", "")
evaluate_button.addClickListener(EvaluateListener(self))
evaluate_button.addMouseListener(self)
output_delimiter = HTML("", StyleName="output_delimiter")
output_prompt = HTML("Out[%d]:" % self._id, Element=DOM.createSpan(),
StyleName="output_prompt")
cell_output = HTML("", Element=DOM.createSpan(),
StyleName="cell_output")
output_prompt.setVisible(False)
p = FlowPanel(StyleName="cell")
p.add(insert_new_cell)
p.add(input_prompt)
p.add(cell_input)
p.add(evaluate_button)
p.add(output_delimiter)
p.add(output_prompt)
p.add(cell_output)
self.add(p)
self._cell_input = cell_input
self._cell_output = cell_output
self._output_prompt = output_prompt
self._evaluate_button = evaluate_button
self._mouse_in = False
