def __init__(self, **kwargs): """ setMatchPattern - defaults to '' to match everything match pattern examples: '^[0-9]*$' is for digits only '^[0-9,A-Z]*$' is for digits and uppercase setMaxLength setText OB """ kwargs['MatchPattern'] = kwargs.pop('MatchPattern', '') cs = kwargs.pop('CursorStyle', "inputbox-cursor") gs = kwargs.pop('StyleName', 'gwt-inputbox') ap = AbsolutePanel(StyleName="inputbox") self.tp = Grid(StyleName=gs, Width="100%", Height="100%", CellPadding=0, CellSpacing=0) self.cursor = HTML(StyleName=cs) ap.add(self.tp) ap.add(self.cursor, 0, 0) self.cf = self.tp.getCellFormatter() FocusPanel.__init__(self, Widget=ap, **kwargs) self.addTableListener(self) self.addKeyboardListener(self) self.addFocusListener(self) self.word_selected_pos = 0 self.ctimer = Timer(notify=self.cursorFlash) self.focusset = False self.cstate = False self._keypressListeners = []
def __init__(self): # create the label and slider self.__label = Label('OFF') self.slider = slider = HorizontalSlider(0, 5, step=1, StyleName="slider") slider.setDragable(True) slider.addControlValueListener(self) # put them in a hpanel self.hpanel = hpanel = HorizontalPanel(Spacing=10) hpanel.add(slider) hpanel.add(self.__label) # create the color panel and give it color self.colorpanel = CaptionPanel('Color:', SimplePanel(StyleName='colorpanel')) self.randomcolor() # we're initially off self.value = 0 # create our timer self.timer = Timer(notify=self)
def __init__(self, widget, action, fps=50): self.widget = widget self.action = action self.fps = fps self.timer = Timer(0, self) self.timer.scheduleRepeating(int(1000.0 / fps))
def draw(self): colour = "#000000" beta = 2 * math.pi / self.numSectors pathParams = { 'stroke': colour, 'stroke-width': self.width, 'stroke-linecap': "round" } for i in range(self.numSectors): alpha = beta * i - math.pi / 2 cos = math.cos(alpha) sin = math.sin(alpha) data = ','.join([ 'M', str(self.cx + self.r1 * cos), str(self.cy + self.r1 * sin), 'L', str(self.cx + self.r2 * cos), str(self.cy + self.r2 * sin) ]) path = self.canvas.path(data=data, attrs=pathParams) self.opacity.append(1.0 * i / self.numSectors) self.sectors.append(path) period = 1000 / self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period)
def onClick(self, sender): self.check_adjusts(sender) if sender == self.reset_constants: self.TD_CONSTS = self.ONES_CONSTS self.sync_consts() if sender == self.increase_depth: self.depth_limit += 1 self.depth_label.setText("Current depth is " + str(self.depth_limit) + ".") if sender == self.decrease_depth: self.depth_limit -= 1 self.depth_label.setText("Current depth is " + str(self.depth_limit) + ".") if sender == self.train_td: self.state = State() self.static_ai_str = '2' self.td_ai_str = '1' self.state.next_piece = [1, 1, 1] Timer(250, notify=self.td_ai_turn) if sender == self.train_static: self.state = State() self.static_ai_str = '1' self.td_ai_str = '2' self.state.next_piece = [1, 1, 1] Timer(250, notify=self.static_ai_turn)
class Feed: def __init__(self, url, callback): global frameId frame = DOM.createElement("iframe") frameid = "__pygwt_feedFrame%d" % frameId frameId += 1 DOM.setAttribute(frame, "id", frameid) DOM.setAttribute(frame, "src", url) #DOM.setStyleAttribute(frame, 'width', '0') #DOM.setStyleAttribute(frame, 'height', '0') #DOM.setStyleAttribute(frame, 'border', '0') #DOM.setStyleAttribute(frame, 'position', 'absolute') self.frameId = frameId self.frame = frame self.timer = Timer(notify=self) doc().parent.body.appendChild(frame) self.callback = callback self.timer.scheduleRepeating(100) def getFrameTxt(self): return str(self.frame.contentWindow.document.body.innerHTML) def onTimer(self, *args): txt = self.getFrameTxt() if txt == '': return self.callback(self, txt) self.timer.cancel()
def __init__(self, max_tries = 10, interval = 500): Timer.__init__(self) self.interval = interval self.max_tries = max_tries self.tries = 0 self.func = func self.params = params self.scheduleRepeating(self.interval)
def __init__(self, symbol_shape, message_symbol_coder, symbol_signal_coder): self.timer = Timer(notify=self) self.setTimer(self.timer) self.symbol_shape = symbol_shape self.message_symbol_coder = message_symbol_coder self.symbol_signal_coder = symbol_signal_coder self.decoded = {}
def __init__(self, countdown=1000): Timer.__init__(self) Label.__init__(self) self.countdown = countdown self.task_id = None self.wait_cnt = 0 self.remote_py = \ EchoServicePython(server="flask", flask_view_type="celery")
def start_game(self, view): self.view = view self.model.start_game(view) self.model.reset() #setup a timer self.timer = Timer(notify=self.update) self.timer.scheduleRepeating(1000 / FPS)
class Spinner(SimplePanel): """ Our testing panel. """ def __init__(self, width=600, height=300): """ Standard initialiser. """ SimplePanel.__init__(self) # Taken from the "spinner" Raphael demo: self.width = 15 self.r1 = 35 self.r2 = 60 self.cx = self.r2 + self.width self.cy = self.r2 + self.width self.numSectors = 12 self.canvas = Raphael(self.r2 * 2 + self.width * 2, self.r2 * 2 + self.width * 2) self.sectors = [] self.opacity = [] self.add(self.canvas) def draw(self): colour = "#000000" beta = 2 * math.pi / self.numSectors pathParams = { 'stroke': colour, 'stroke-width': self.width, 'stroke-linecap': "round" } for i in range(self.numSectors): alpha = beta * i - math.pi / 2 cos = math.cos(alpha) sin = math.sin(alpha) data = ','.join([ 'M', str(self.cx + self.r1 * cos), str(self.cy + self.r1 * sin), 'L', str(self.cx + self.r2 * cos), str(self.cy + self.r2 * sin) ]) path = self.canvas.path(data=data, attrs=pathParams) self.opacity.append(1.0 * i / self.numSectors) self.sectors.append(path) period = 1000 / self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period) def onTimer(self, timerID): """ Respond to our timer firing. """ self.opacity.insert(0, self.opacity.pop()) for i in range(self.numSectors): self.sectors[i].setAttr("opacity", self.opacity[i])
class Spinner(PopupPanel): def __init__(self, text=''): PopupPanel.__init__(self) self.width = 15 self.r1 = 35 self.r2 = 60 self.cx = self.r2 + self.width self.cy = self.r2 + self.width self.numSectors = 12 self.size = self.r2*2 + self.width*2 self.speed = 1.5 # seconds per rotation self._timer = None self.canvas = Raphael(self.size, self.size) self.sectors = [] self.opacity = [] vp = VerticalPanel() vp.add(self.canvas) blurb = HTML(text) blurb.setStyleAttribute('text-align', 'center') vp.add(blurb) self.add(vp) def draw(self): colour = "#000000" beta = 2 * math.pi / self.numSectors pathParams = {'stroke' : colour, 'stroke-width' : self.width, 'stroke-linecap' : "round"} for i in range(self.numSectors): alpha = beta * i - math.pi/2 cos = math.cos(alpha) sin = math.sin(alpha) data = ','.join(['M', str(self.cx + self.r1 * cos), str(self.cy + self.r1 * sin), 'L', str(self.cx + self.r2 * cos), str(self.cy + self.r2 * sin)]) path = self.canvas.path(data=data, attrs=pathParams) self.opacity.append(1.0 * i / self.numSectors ) self.sectors.append(path) period = (self.speed * 1000) / self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period) def onTimer(self, _): self.opacity.insert(0, self.opacity.pop()) for i in range(self.numSectors): self.sectors[i].setAttr("opacity", self.opacity[i])
def delay(s): if STATMODE: return # NO TIME FOR SLEEP IN STATMODE if USING_PYGAME: from time import sleep sleep(s) else: from pyjamas.Timer import Timer timer = Timer(notify=update) timer.schedule(s * 1000)
def __init__(self): # the button self.button = Button(listener=self) # set an attr on the button to keep track of its state self.button.stop = False # date label self.datelabel = Label(StyleName='clock') # the timer self.timer = Timer(notify=self.updateclock) # kick start self.onClick(self.button)
def __init__(self, countdown): # It's a Timer, no it's a Button, WAIT! It's BOTH!! Timer.__init__(self) Button.__init__(self) # save the countdown value self.countdown_save = countdown # this instance handles the clicks self.addClickListener(self) # the box the popups go into self.box = SimplePanel(StyleName='popupbox') # kickstart self.reset()
class TestPanel(SimplePanel): """ Our testing panel. """ def __init__(self): """ Standard initialiser. """ SimplePanel.__init__(self) # Taken from the "spinner" Raphael demo: colour = "#000000" width = 15 r1 = 35 r2 = 60 cx = r2 + width cy = r2 + width self.numSectors = 12 self.canvas = Raphael(r2 * 2 + width * 2, r2 * 2 + width * 2) self.sectors = [] self.opacity = [] beta = 2 * math.pi / self.numSectors pathParams = { 'stroke': colour, 'stroke-width': width, 'stroke-linecap': "round" } for i in range(self.numSectors): alpha = beta * i - math.pi / 2 cos = math.cos(alpha) sin = math.sin(alpha) path = self.canvas.path(data=None, attrs=pathParams) path.moveTo(cx + r1 * cos, cy + r1 * sin) path.lineTo(cx + r2 * cos, cy + r2 * sin) self.opacity.append(1 / self.numSectors * i) self.sectors.append(path) period = 1000 / self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period) self.add(self.canvas) def onTimer(self, timer): """ Respond to our timer firing. """ self.opacity.insert(0, self.opacity.pop()) for i in range(self.numSectors): self.sectors[i].setAttr("opacity", self.opacity[i])
class TestPanel(SimplePanel): """ Our testing panel. """ def __init__(self): """ Standard initialiser. """ SimplePanel.__init__(self) # Taken from the "spinner" Raphael demo: colour = "#000000" width = 15 r1 = 35 r2 = 60 cx = r2 + width cy = r2 + width self.numSectors = 12 self.canvas = Raphael(r2*2 + width*2, r2*2 + width*2) self.sectors = [] self.opacity = [] beta = 2 * math.pi / self.numSectors pathParams = {'stroke' : colour, 'stroke-width' : width, 'stroke-linecap' : "round"} for i in range(self.numSectors): alpha = beta * i - math.pi/2 cos = math.cos(alpha) sin = math.sin(alpha) path = self.canvas.path(data=None, attrs=pathParams) path.moveTo(cx + r1 * cos, cy + r1 * sin) path.lineTo(cx + r2 * cos, cy + r2 * sin) self.opacity.append(1 / self.numSectors * i) self.sectors.append(path) period = 1000/self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period) self.add(self.canvas) def onTimer(self, timer): """ Respond to our timer firing. """ self.opacity.insert(0, self.opacity.pop()) for i in range(self.numSectors): self.sectors[i].setAttr("opacity", self.opacity[i])
def queuereduce(sender, maxlines=1000): showOutputMeta("Reducing...") outputPanel.add(HTML(" ")) outputPanel.add(HTML(" ")) outputPanel.add( HTML(""" <p>Takes too long? Try the <a href="https://bitbucket.org/bgeron </continuation-calculus-paper/">Python evaluator.</a>.</p> """.strip())) # Schedule reduceterm(maxlines) really soon. timer = Timer(notify=functools.partial(reduceterm, maxlines=maxlines)) timer.schedule(50) # after 50 milliseconds
class Animate(object): def __init__(self, widget, action, fps=50): self.widget = widget self.action = action self.fps = fps self.timer = Timer(0, self) self.timer.scheduleRepeating(int(1000.0 / fps)) def onTimer(self, sender): params = self.action(self.widget) if not params: self.timer.cancel() return
def __init__(self): self.dropTargets = [] self.dragging = NOT_DRAGGING self.dragBusy = False self._currentTargetElement = None self.previousDropTarget = None self.draggingImage = None self.origMouseX = 0 self.origMouseY = 0 self.currentDragOperation = 'none' self.data = None self.returnTimer = Timer(notify=self.onReturningWidget) self.mouseEvent = None self.dragDataStore = None
class Animate(object): def __init__(self, widget, action, fps=50): self.widget = widget self.action = action self.fps = fps self.timer = Timer(0, self) self.timer.scheduleRepeating(int(1000.0/fps)) def onTimer(self, sender): params = self.action(self.widget) if not params: self.timer.cancel() return
class Clock: # pyjamas doesn't generate __doc__ __doc__ = '''This demonstrates using Timer instantiated with the notify keyword, as in:<pre> timer = Timer(notify=func) </pre>When the timer fires it will call func() with no arguments (or <code>self</code> if it is a bound method as in this example). This timer is scheduled with the <code>scheduleRepeating()</code> method, so after func() is called, it is automatically rescheduled to fire again after the specified period. The timer can be cancelled by calling the <code>cancel()</code> method; this happens when you click on the button. ''' start_txt = 'Click to start the clock' stop_txt = 'Click to stop the clock' def __init__(self): # the button self.button = Button(listener=self) # set an attr on the button to keep track of its state self.button.stop = False # date label self.datelabel = Label(StyleName='clock') # the timer self.timer = Timer(notify=self.updateclock) # kick start self.onClick(self.button) def onClick(self, button): if self.button.stop: # we're stopping the clock self.button.stop = False self.timer.cancel() self.button.setText(self.start_txt) else: # we're starting the clock self.button.stop = True self.timer.scheduleRepeating(1000) self.button.setText(self.stop_txt) def updateclock(self, timer): # the callable attached to the timer with notify dt = datetime.now().replace(microsecond=0) self.datelabel.setText(dt.isoformat(' '))
def initElement(self): # Most browsers don't like setting designMode until slightly _after_ # the iframe becomes attached to the DOM. Any non-zero timeout will do # just fine. print "initElement" self.onElementInitializing() Timer(50, self)
def __init__(self, widget, action, fps=50): self.widget = widget self.action = action self.fps = fps self.timer = Timer(0, self) self.timer.scheduleRepeating(int(1000.0/fps))
def td_ai_turn(self): print "\n\nTD AI player starting turn. TD AI places the piece:", self.state.next_piece[ 2] print "TD_CONSTS after being adjusted are: ", self.TD_CONSTS # print, alpha-beta search etc.: (expectedUtility, state) = ab(self.state, self.TD_CONSTS, depth_limit=self.depth_limit) terminal_state = expectedUtility.terminal self.TD_CONSTS = td_learning(terminal_state, self.TD_CONSTS, self.state) self.sync_consts() # reflect the new TD_CONSTS in the game. last_position = find_last_move(self.state, state) self.state = state state.printInfo() print "TD_CONSTS after being adjusted are: ", self.TD_CONSTS over = self.check_is_win(last_position) print "back in td" print "Is over ", over if not over: return Timer(250, notify=self.static_ai_turn) else: return True
def draw(self): colour = "#000000" beta = 2 * math.pi / self.numSectors pathParams = {'stroke' : colour, 'stroke-width' : self.width, 'stroke-linecap' : "round"} for i in range(self.numSectors): alpha = beta * i - math.pi/2 cos = math.cos(alpha) sin = math.sin(alpha) data = ','.join(['M', str(self.cx + self.r1 * cos), str(self.cy + self.r1 * sin), 'L', str(self.cx + self.r2 * cos), str(self.cy + self.r2 * sin)]) path = self.canvas.path(data=data, attrs=pathParams) self.opacity.append(1.0 * i / self.numSectors ) self.sectors.append(path) period = (self.speed * 1000) / self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period)
def onDrop(self, event): dt = event.dataTransfer item = dt.getData("Text") data = json.decode(item) if 'name' in data and 'age' in data: age = data['age'] name = data['name'] self.removeStyleName('dragover') if self.age_is_ok(age): self.addStudent(name, age) dt.dropEffect = 'copy' self.addStyleName('flash') def removeFlash(timer): self.removeStyleName('flash') Timer(250, notify=removeFlash) else: dt.dropEffect = 'none' self.addMessage('student could not be added') # setting dropEffect to 'none' should be sufficient to notify # that the drop failed, but # we need to cheat a bit for now... # this is the only reason for parent id in data item_parent_id = data['parent'] item_parent = self.parent.containerFromId(item_parent_id) item_parent.addStyleName('drop_fail') # prevent default allows onDragEnd to see the dropEffect we set here DOM.eventPreventDefault(event)
class Spinner(SimplePanel): """ Our testing panel. """ def __init__(self,width=600,height=300): """ Standard initialiser. """ SimplePanel.__init__(self) # Taken from the "spinner" Raphael demo: self.width = 15 self.r1 = 35 self.r2 = 60 self.cx = self.r2 + self.width self.cy = self.r2 + self.width self.numSectors = 12 self.canvas = Raphael(self.r2*2 + self.width*2, self.r2*2 + self.width*2) self.sectors = [] self.opacity = [] self.add(self.canvas) def draw(self): colour = "#000000" beta = 2 * math.pi / self.numSectors pathParams = {'stroke' : colour, 'stroke-width' : self.width, 'stroke-linecap' : "round"} for i in range(self.numSectors): alpha = beta * i - math.pi/2 cos = math.cos(alpha) sin = math.sin(alpha) data=','.join(['M',str(self.cx + self.r1 * cos),str(self.cy + self.r1 * sin),'L',str(self.cx + self.r2 * cos),str(self.cy + self.r2 * sin)]) path = self.canvas.path(data=data,attrs=pathParams) self.opacity.append(1.0 * i / self.numSectors ) self.sectors.append(path) period = 1000/self.numSectors self._timer = Timer(notify=self) self._timer.scheduleRepeating(period) def onTimer(self, timerID): """ Respond to our timer firing. """ self.opacity.insert(0, self.opacity.pop()) for i in range(self.numSectors): self.sectors[i].setAttr("opacity", self.opacity[i])
def queuereduce(sender, maxlines=1000): showOutputMeta("Reducing...") outputPanel.add(HTML(" ")) outputPanel.add(HTML(" ")) outputPanel.add( HTML( """ <p>Takes too long? Try the <a href="https://bitbucket.org/bgeron </continuation-calculus-paper/">Python evaluator.</a>.</p> """.strip() ) ) # Schedule reduceterm(maxlines) really soon. timer = Timer(notify=functools.partial(reduceterm, maxlines=maxlines)) timer.schedule(50) # after 50 milliseconds
class Tooltip(PopupPanel): def __init__(self, sender, offsetX, offsetY, contents, show_delay, hide_delay, styleName, **kwargs): """ contents may be a text string or it may be a widget """ PopupPanel.__init__(self, True, **kwargs) self.show_delay = show_delay self.hide_delay = hide_delay if isinstance(contents, basestring): contents = HTML(contents) self.add(contents) left = sender.getAbsoluteLeft() + offsetX top = sender.getAbsoluteTop() + offsetY self.setPopupPosition(left, top) self.setStyleName(styleName) if tooltip_hide_timer: self.tooltip_show_timer = Timer(1, self) else: self.tooltip_show_timer = Timer(self.show_delay, self) def show(self): global tooltip_hide_timer # activate fast tooltips tooltip_hide_timer = Timer(self.hide_delay, self) PopupPanel.show(self) def hide(self, autoClosed=False): self.tooltip_show_timer.cancel() PopupPanel.hide(self, autoClosed) def onTimer(self, timer): global tooltip_hide_timer # deactivate fast tooltips on last timer if timer is tooltip_hide_timer: tooltip_hide_timer = None if timer is self.tooltip_show_timer: self.show() else: self.hide()
def onTimer(self, t): count = 0 while count < 10 and self.index < len(self.items): self._add_items(self.index) self.index += 1 count += 1 if self.index < len(self.items): Timer(1, self)
def __init__(self, url, callback): global frameId frame = DOM.createElement("iframe") frameid = "__pygwt_feedFrame%d" % frameId frameId += 1 DOM.setAttribute(frame, "id", frameid) DOM.setAttribute(frame, "src", url) #DOM.setStyleAttribute(frame, 'width', '0') #DOM.setStyleAttribute(frame, 'height', '0') #DOM.setStyleAttribute(frame, 'border', '0') #DOM.setStyleAttribute(frame, 'position', 'absolute') self.frameId = frameId self.frame = frame self.timer = Timer(notify=self) doc().parent.body.appendChild(frame) self.callback = callback self.timer.scheduleRepeating(100)
def start_game(self, view): self.view = view self.model.start_game(view) self.model.reset() #setup a timer self.timer = Timer(notify=self.update) self.timer.scheduleRepeating(1000/FPS)
def __init__(self): Composite.__init__(self) self.albums = [] self.photos = [] self.grid = Grid(4, 4, CellPadding=4, CellSpacing=4) self.grid.addTableListener(self) self.drill = 0 self.pos = 0 self.up = Button("Up", self) self.next = Button("Next", self) self.prev = Button("Prev", self) self.timer = Timer(notify=self) self.userid = "jameskhedley" self.album_url = "http://picasaweb.google.com/data/feed/base/user/" + self.userid + "?alt=json-in-script&kind=album&hl=en_US&callback=restCb" self.doRESTQuery(self.album_url, self.timer) self.vp = VerticalPanel() self.disclosure = DisclosurePanel( "Click for boring technical details.") self.disclosure.add( HTML( '''<p>OK so you want to write client JS to do a RESTful HTTP query from picasa right? Well you can't because of the Same Origin Policy. Basically this means that because the domain of the query and the domain of the hosted site are different, then that could well be a cross-site scripting (XSS) attack. So, the workaround is to do the call from a script tag so the JSON we get back is part of the document. But since we don't know what URL to hit yet, once we find out then we have to inject a new script tag dynamically which the browser will run as soon as we append it. To be honest I'm not 100% why Google use RESTful services and not JSON-RPC or somesuch, which would be easier. Well, easier for me.''')) self.IDPanel = HorizontalPanel() self.IDPanel.add(Label("Enter google account:")) self.IDButton = Button("Go", self) self.IDBox = TextBox() self.IDBox.setText(self.userid) self.IDPanel.add(self.IDBox) self.IDPanel.add(self.IDButton) self.vp.add(self.IDPanel) self.vp.add(self.disclosure) self.vp.add(self.grid) self.initWidget(self.vp)
def transfer_tinymce(self): new_script = DOM.createElement("script") new_script.innerHTML = """ var ed = tinyMCE.get('%s'); var data = ed.getContent({'format': 'raw'}); frame = document.getElementById('__edit_%s'); frame.innerText = data; ed.save(); ed.remove(); """ % (self.editor_id, self.editor_id) self.editor_created = False DOM.setElemAttribute(new_script, "type","text/javascript") doc().body.appendChild(new_script) self.hide() t = Timer(notify=self) t.scheduleRepeating(1000)
def transfer_tinymce(self): new_script = DOM.createElement("script") new_script.innerHTML = """ var ed = tinyMCE.get('%s'); var data = ed.getContent({'format': 'raw'}); frame = document.getElementById('__edit_%s'); frame.innerText = data; ed.save(); ed.remove(); """ % (self.editor_id, self.editor_id) self.editor_created = False DOM.setElemAttribute(new_script, "type", "text/javascript") doc().body.appendChild(new_script) self.hide() t = Timer(notify=self) t.scheduleRepeating(1000)
def onTimer(self, tid): for i in range(10): if self.test_idx >= len(self.test_methods): self.displayStats() self.test_idx = 'DONE' self.start_next_test() return self._run_test(self.test_methods[self.test_idx]) self.test_idx += 1 Timer(1, self)
def check_start_next_test(self): if self.tests_outstanding is None: return if self.tests_outstanding == 0: if hasattr(self, 'lastTestsCheck'): self.lastTestsCheck() self.displayStats() self.start_next_test() return # do it again. Timer(100, self)
def run(self): self.getTestMethods() if not IN_BROWSER: for test_method_name in self.test_methods: self._run_test(test_method_name) self.displayStats() if hasattr(self, "start_next_test"): self.start_next_test() return self.test_idx = 0 Timer(10, self)
def onDragEnd(self, event): dt = event.dataTransfer self.addMessage('Drop effect is "%s"' % dt.dropEffect) if dt.dropEffect != 'none': self.remove(self.movingWidget) else: # Restore widget visibility. Allow 0.5 seconds for the fly-back. def ontimer(timer): self.movingWidget.removeStyleName('invisible') Timer(500, notify=ontimer)
def onSplitterResize(self, px): """ IE6/7 has event priority issues that will prevent the repaints from happening quickly enough causing the interaction to seem unresponsive. The following is simply a poor man's mouse event coalescing. """ resizeUpdatePeriod = 20 # ms if not self.isResizeInProgress: self.isResizeInProgress = True Timer(resizeUpdatePeriod, self) self.splitPosition = px
class Controller: def __init__(self, model): self.model = model self.key_up = False self.key_down = False self.key_left = False self.key_right = False self.key_fire = False def start_game(self, view): self.view = view self.model.start_game(view) self.model.reset() #setup a timer self.timer = Timer(notify=self.update) self.timer.scheduleRepeating(1000/FPS) def update(self): self.keyboard_updates() self.model.update() def keyboard_updates(self): ship = self.model.ship drot = 0 if self.key_left: drot -= ROTATE_SPEED if self.key_right: drot += ROTATE_SPEED if drot: ship.rotate_ship(drot) if self.key_up: ship.thrust() else: ship.friction() if self.key_fire: self.model.trigger_fire()
def __init__(self, sender, offsetX, offsetY, contents, show_delay, hide_delay, styleName, **kwargs): """ contents may be a text string or it may be a widget """ PopupPanel.__init__(self, True, **kwargs) self.show_delay = show_delay self.hide_delay = hide_delay if isinstance(contents, basestring): contents = HTML(contents) self.add(contents) left = sender.getAbsoluteLeft() + offsetX top = sender.getAbsoluteTop() + offsetY self.setPopupPosition(left, top) self.setStyleName(styleName) if tooltip_hide_timer: self.tooltip_show_timer = Timer(1, self) else: self.tooltip_show_timer = Timer(self.show_delay, self)
def __init__(self) : # Since this is a singleton, throw an exception if the constructor is called # explicitly. if DataRunManager._onlyInstance!=None : raise Exception( "DataRunManager is a singleton class. Call 'DataRunManager.instance()' to get the only running instance" ) self.rpcService=GlibRPCService.instance() self.pollingTimer=Timer( notify=self.pollRPCService ) self.eventHandlers = [] self.fractionComplete = 1 self.statusString = "Not taking data" self.firstRun = True # I'll poll once immediately on startup just in case the user is connecting to an # already running service. The code that handles the response to this starts the # timer running. self.pollRPCService()
def __init__(self): Composite.__init__(self) self.albums = [] self.photos = [] self.grid = Grid(4, 4, CellPadding=4, CellSpacing=4) self.grid.addTableListener(self) self.drill = 0 self.pos = 0 self.up = Button("Up", self) self.next = Button("Next", self) self.prev = Button("Prev", self) self.timer = Timer(notify=self) self.userid = "jameskhedley" self.album_url = "http://picasaweb.google.com/data/feed/base/user/" + self.userid + "?alt=json-in-script&kind=album&hl=en_US&callback=restCb" self.doRESTQuery(self.album_url, self.timer) self.vp = VerticalPanel() self.disclosure = DisclosurePanel("Click for boring technical details.") self.disclosure.add(HTML('''<p>OK so you want to write client JS to do a RESTful HTTP query from picasa right? Well you can't because of the Same Origin Policy. Basically this means that because the domain of the query and the domain of the hosted site are different, then that could well be a cross-site scripting (XSS) attack. So, the workaround is to do the call from a script tag so the JSON we get back is part of the document. But since we don't know what URL to hit yet, once we find out then we have to inject a new script tag dynamically which the browser will run as soon as we append it. To be honest I'm not 100% why Google use RESTful services and not JSON-RPC or somesuch, which would be easier. Well, easier for me.''')) self.IDPanel = HorizontalPanel() self.IDPanel.add(Label("Enter google account:")) self.IDButton = Button("Go", self) self.IDBox = TextBox() self.IDBox.setText(self.userid) self.IDPanel.add(self.IDBox) self.IDPanel.add(self.IDButton) self.vp.add(self.IDPanel) self.vp.add(self.disclosure) self.vp.add(self.grid) self.initWidget(self.vp)
def __init__(self): """ Standard initialiser. """ SimplePanel.__init__(self) # Taken from the "spinner" Raphael demo: colour = "#000000" width = 15 r1 = 35 r2 = 60 cx = r2 + width cy = r2 + width self.numSectors = 12 self.canvas = Raphael(r2*2 + width*2, r2*2 + width*2) self.sectors = [] self.opacity = [] beta = 2 * math.pi / self.numSectors pathParams = {'stroke' : colour, 'stroke-width' : width, 'stroke-linecap' : "round"} for i in range(self.numSectors): alpha = beta * i - math.pi/2 cos = math.cos(alpha) sin = math.sin(alpha) path = self.canvas.path(pathParams) path.moveTo(cx + r1 * cos, cy + r1 * sin) path.lineTo(cx + r2 * cos, cy + r2 * sin) self.opacity.append(1 / self.numSectors * i) self.sectors.append(path) period = 1000/self.numSectors self._timer = Timer(listener=self) self._timer.scheduleRepeating(period) self.add(self.canvas)
class RandomColor: __doc__ = '''This last example demonstrates what most pyjamas programmers currently do with timers: create a Timer instance specifying <code>notify</code> with an object that has an <code>onTimer</code> attribute that is callable. The slider on the left will adjust how often the middle panel changes color; it is either OFF or a value of seconds from 1 to 5. Changing the slider immediately cancels the current timer and starts a new timer to change the color in the newly specified time. Like the previous example, this timer reschedules itself (if it wasn't turned off) at the end of the call to <code>onTimer()</code>. ''' def __init__(self): # create the label and slider self.__label = Label('OFF') self.slider = slider = HorizontalSlider(0, 5, step=1, StyleName="slider") slider.setDragable(True) slider.addControlValueListener(self) # put them in a hpanel self.hpanel = hpanel = HorizontalPanel(Spacing=10) hpanel.add(slider) hpanel.add(self.__label) # create the color panel and give it color self.colorpanel = CaptionPanel('Color:', SimplePanel(StyleName='colorpanel')) self.randomcolor() # we're initially off self.value = 0 # create our timer self.timer = Timer(notify=self) def initialize(self): # this method solves an apparent bug with the slider: the # slider doesn't draw its handle if the position is set before # showing, so instead of doing this in __init__ (where I # originally had it), this method gets called after it is # shown on the root panel. See below when it gets called. self.slider.setValue(self.value) self.slider.setControlPos(self.value) def onTimer(self, timer): # when the timer fires we randomize the color and (maybe) # reschedule ourselves. self.randomcolor() v = self.value * 1000 if v: self.timer.schedule(v) def onControlValueChanged(self, sender, old, new): # event handler for when the slider is moved. if new == self.value: return self.value = new # is it being turned off? if new == 0: self.__label.setText('OFF') self.timer.cancel() else: # no it's being reset self.__label.setText(str(new) + ' sec') self.onTimer(self.timer) def randomcolor(self): # randomize the color and set the panel accordingly r = random()*256 g = random()*256 b = random()*256 e = self.colorpanel.getWidget().getElement() color = '#%02x%02x%02x' % (r, g, b) self.colorpanel.setCaption('Color: %s' % color) DOM.setStyleAttribute(e, "background", color)
class Photos(Composite): def __init__(self): Composite.__init__(self) self.albums = [] self.photos = [] self.grid = Grid(4, 4, CellPadding=4, CellSpacing=4) self.grid.addTableListener(self) self.drill = 0 self.pos = 0 self.up = Button("Up", self) self.next = Button("Next", self) self.prev = Button("Prev", self) self.timer = Timer(notify=self) self.userid = "jameskhedley" self.album_url = "http://picasaweb.google.com/data/feed/base/user/" + self.userid + "?alt=json-in-script&kind=album&hl=en_US&callback=restCb" self.doRESTQuery(self.album_url, self.timer) self.vp = VerticalPanel() self.disclosure = DisclosurePanel("Click for boring technical details.") self.disclosure.add(HTML('''<p>OK so you want to write client JS to do a RESTful HTTP query from picasa right? Well you can't because of the Same Origin Policy. Basically this means that because the domain of the query and the domain of the hosted site are different, then that could well be a cross-site scripting (XSS) attack. So, the workaround is to do the call from a script tag so the JSON we get back is part of the document. But since we don't know what URL to hit yet, once we find out then we have to inject a new script tag dynamically which the browser will run as soon as we append it. To be honest I'm not 100% why Google use RESTful services and not JSON-RPC or somesuch, which would be easier. Well, easier for me.''')) self.IDPanel = HorizontalPanel() self.IDPanel.add(Label("Enter google account:")) self.IDButton = Button("Go", self) self.IDBox = TextBox() self.IDBox.setText(self.userid) self.IDPanel.add(self.IDBox) self.IDPanel.add(self.IDButton) self.vp.add(self.IDPanel) self.vp.add(self.disclosure) self.vp.add(self.grid) self.initWidget(self.vp) def doRESTQuery(self, url, timer): """this is a totally different from an RPC call in that we have to dynamically add script tags to the DOM when we want to query the REST API. These rely on callbacks in the DOM so we can either add them dynamically or pre-define them in public/Main.html. Once we've done that have to wait for the response. Which means we need to provide a listener for the timer""" JS("$wnd.receiver = 'wait'") new_script = DOM.createElement("script") DOM.setElemAttribute(new_script, "src", url) DOM.setElemAttribute(new_script, "type","text/javascript") JS("$wnd.document.body.appendChild(@{{new_script}})") self.timer.schedule(100) def onCellClicked(self, sender, row, col): if self.drill==0: self.drill += 1 self.vp.clear() self.grid.clear() self.vp.add(self.up) self.vp.add(self.grid) gridcols = self.grid.getColumnCount() album = self.albums[row+col+(row*(gridcols-1))] url = "http://picasaweb.google.com/data/feed/base/user/" + self.userid + "/albumid/" + album["id"] + "?alt=json-in-script&kind=photo&hl=en_US&callback=restCb" self.doRESTQuery(url, self.timer) elif self.drill==1: self.drill += 1 gridcols = self.grid.getColumnCount() self.pos =row+col+(row*(gridcols-1)) photo = self.photos[self.pos] self.vp.clear() self.fullsize = HTML('<img src="' + photo["full"] + '"/>') hp = HorizontalPanel() hp.add(self.up) hp.add(self.prev) hp.add(self.next) hp.setSpacing(8) self.vp.add(hp) self.vp.add(self.fullsize) def onClick(self, sender): if sender == self.IDButton: self.userid = self.IDBox.getText() if self.userid == "" or self.userid.isdigit(): return self.drill = 0 self.album_url = "http://picasaweb.google.com/data/feed/base/user/" + self.userid + "?alt=json-in-script&kind=album&hl=en_US&callback=restCb" self.grid.clear() self.doRESTQuery(self.album_url, self.timer) else: if self.drill == 2: if sender == self.up: self.drill=1 self.vp.clear() self.vp.add(self.up) self.vp.add(self.grid) self.fillGrid(self.photos, "photos") else: if sender == self.next: if self.pos >= len(self.photos): return self.pos +=1 elif sender == self.prev: if self.pos < 1: return self.pos -=1 photo = self.photos[self.pos] self.fullsize.setHTML('<img src="' + photo["full"] + '"/>') elif self.drill == 1: self.drill=0 self.vp.clear() self.vp.add(self.IDPanel) self.vp.add(self.disclosure) self.vp.add(self.grid) self.fillGrid(self.albums, "albums") def onTimer(self, timer): receiver = JS("$wnd.receiver") if receiver == 'wait': self.timer.schedule(1000) return JS("$wnd.receiver = 'wait'") if self.drill == 0: self.parseAlbums(receiver) self.fillGrid(self.albums, "albums") elif self.drill == 1: self.parsePhotos(receiver) self.fillGrid(self.photos, "photos") def fillGrid(self, items, type): self.grid.clear() cols = self.grid.getColumnCount() self.grid.resizeRows((len(items)/cols)+1) rows = self.grid.getRowCount() for i in range(len(items)): vp = VerticalPanel() if type == 'photos': vp.add(items[i]['thumb']) else: vp.add(items[i]['thumb']) vp.add(items[i]['title']) self.grid.setWidget(int(i/cols), i%cols, vp) def parsePhotos(self, items): photo_list = JSONParser().jsObjectToPyObject(items) self.photos = [] for i in range(len(photo_list)): index = "%s" % i aphoto = {} aphoto['thumb'] = HTML('<img src="' + photo_list[index]["media$group"]["media$thumbnail"]["1"]["url"] + '"/>') aphoto['full'] = photo_list[index]["media$group"]["media$content"]["0"]["url"] self.photos.append(aphoto) def parseAlbums(self, items): album_list = JSONParser().jsObjectToPyObject(items) self.albums = [] for i in range(len(album_list)): index = "%s" % i analbum = {} analbum['title'] = HTML(album_list[index]["title"]["$t"]) analbum['thumb'] = HTML('<img src="' + album_list[index]["media$group"]["media$thumbnail"]["0"]["url"] + '"/>') url = album_list[index]["id"]["$t"] analbum['id'] = url.split('albumid/')[1].split('?alt')[0] self.albums.append(analbum)
class DataRunManager(object) : """ @brief Class to take care of all the data taking runs. Starts them and polls the RPC service to see when it's finished. Implemented as a singleton. Call the DataRunManager.instance() static method to get the only running instance. """ pollingTime=1000 idlePollingTime=4000 # Longer polling time when I don't think I'm taking data. _onlyInstance=None # The following members are used as an enum to describe what the event is DataTakingStartedEvent=0 DataTakingFinishedEvent=1 DataTakingStatusEvent=3 @staticmethod def instance() : # static method so no "self" parameter if DataRunManager._onlyInstance==None : DataRunManager._onlyInstance=DataRunManager() return DataRunManager._onlyInstance def __init__(self) : # Since this is a singleton, throw an exception if the constructor is called # explicitly. if DataRunManager._onlyInstance!=None : raise Exception( "DataRunManager is a singleton class. Call 'DataRunManager.instance()' to get the only running instance" ) self.rpcService=GlibRPCService.instance() self.pollingTimer=Timer( notify=self.pollRPCService ) self.eventHandlers = [] self.fractionComplete = 1 self.statusString = "Not taking data" self.firstRun = True # I'll poll once immediately on startup just in case the user is connecting to an # already running service. The code that handles the response to this starts the # timer running. self.pollRPCService() def onRemoteResponse(self, response, request_info): """ The method that gets called after a successful RPC call. """ #ErrorMessage( "Response to method '"+request_info.method+"'='"+str(response)+"'" ) if request_info.method=="getDataTakingStatus" : self._onGetDataTakingStatusResponse(response) elif request_info.method=="startSCurveRun" : self._startRunResponse(response,"S-curve run") elif request_info.method=="startOccupancyCheck" : self._startRunResponse(response,"Occupancy check") elif request_info.method=="startTrimCalibration" : self._startRunResponse(response,"Trim calibration") elif request_info.method=="stopTakingData" : pass else : ErrorMessage( "Received an unexpected response for method "+request_info.method ) def onRemoteError(self, code, message, request_info): """ The method that gets called after an unsuccessful RPC call. """ ErrorMessage( "Unable to contact server: "+str(message) ) def _onGetDataTakingStatusResponse( self, response ) : """ Handles the response to a getDataTakingStatus RPC call. Separate method for code layout only. """ newFraction=response["fractionComplete"] newStatus=response["statusString"] statusHasChanged=False if (self.fractionComplete!=newFraction) or (self.statusString!=newStatus) : statusHasChanged=True if self.firstRun : # If something is already running on initialisation, tell everything for handler in self.eventHandlers : handler.onDataTakingEvent( DataRunManager.DataTakingStartedEvent, None ) self.firstRun=False self.fractionComplete=newFraction self.statusString=newStatus # only want to inform the listening classes if there is a change in the status if statusHasChanged : if self.fractionComplete>=1 : eventCode=DataRunManager.DataTakingFinishedEvent details=None else : eventCode=DataRunManager.DataTakingStatusEvent details={"fractionComplete":self.fractionComplete,"statusString":self.statusString} # Inform all the registered handlers what is going on for handler in self.eventHandlers : handler.onDataTakingEvent( eventCode, details ) if self.fractionComplete<1 : # If data hasn't finished then set the timer to fire again. self.pollingTimer.schedule( DataRunManager.pollingTime ) else : # I'll constantly poll to make sure it's not taking data, in case something/someone # else connects and tells the RPC service to do something. I'll use a longer time # though. if self.idlePollingTime>0 : self.pollingTimer.schedule( DataRunManager.idlePollingTime ) def _startRunResponse( self, reponse, runType ) : """ Handles the response to a RPC call. Separate method for code layout only. """ self.statusString=runType+" started" # Start polling the RPC service to see how the run is going self.pollingTimer.schedule( DataRunManager.pollingTime ) # inform all registered handlers that data taking has started for handler in self.eventHandlers : handler.onDataTakingEvent( DataRunManager.DataTakingStartedEvent, None ) def pollRPCService( self ) : """ Method that polls the RPC service to see what the state of data taking is. This method is bound to a Timer so that it will periodically be called. """ self.rpcService.getDataTakingStatus( None, self ) def registerEventHandler( self, handler ) : """ Registers an event handler that will be notified when certain things happen, e.g. data taking started, data taking finished. """ self.eventHandlers.append( handler ) def startSCurveRun( self, thresholds ) : if self.fractionComplete!=1 : raise AlreadyTakingDataError() self.fractionComplete=0 self.statusString="Initiating s-curve run" self.rpcService.startSCurveRun( thresholds, self ) def startOccupancyCheck( self ) : if self.fractionComplete!=1 : raise AlreadyTakingDataError() self.fractionComplete=0 self.statusString="Initiating occupancy check" self.rpcService.startOccupancyCheck( None, self ) def startTrimCalibration( self, midPointTarget, maxLoops ) : if self.fractionComplete!=1 : raise AlreadyTakingDataError() self.fractionComplete=0 self.statusString="Initiating trim calibration" self.rpcService.startTrimCalibration( {'midPointTarget':midPointTarget,'maxLoops':maxLoops}, self ) def stopTakingData( self ) : self.rpcService.stopTakingData( None, self )