示例#1
0
    def show_video_modes(self):
        self.events.add(Event.KEYUP_Event(key=K_f, callback=self.toggle_fullscreen))
        self.events.add(Event.KEYUP_Event(key=K_PAGEUP, callback=self.grow))
        self.events.add(Event.KEYUP_Event(key=K_PAGEDOWN, callback=self.shrink))
        self.events.add(Event.KEYUP_Event(key=K_RETURN, callback=self._quit))

        s = Drawable.String(w=self, message='video',
                                fontSize=40)
        s.center(y=85)
        s = Drawable.Stationary(w=self, sprite=s)
        s.draw()

        b1 = Widget.SpriteTextButton(self, '640 x 480', callback=self.resize640x480,
                                        group=self.events)
        b1.center(y=125, dx=-100)
        self.sprites.add(b1)

        b2 = Widget.SpriteTextButton(self, '800 x 600', callback=self.resize800x600,
                                        group=self.events)
        b2.center(y=125)
        self.sprites.add(b2)

        b3 = Widget.SpriteTextButton(self, '1024 x 768', callback=self.resize1024x768,
                                        group=self.events)
        b3.center(y=125, dx=100)
        self.sprites.add(b3)

        b4 = Widget.SpriteTextButton(self, 'Full/Window', callback=self.toggle_fullscreen,
                                        group=self.events)
        b4.center(y=165)
        self.sprites.add(b4)

        self.pause()
示例#2
0
    def subselect(self, changes=True):
        self.save_mem()  # maybe 'can' modify children ...

        # poñer dentro de changes ?
        self.struct.apply_to_all_plots(self.window.panelB.update)
        if changes:
            self.struct.call_influences(
                self.window.panelB.update_from_dependency
            )  # 'punteiros inversos'

        offset = self.combobox.GetSelection()
        children = self.struct.get_children()

        # event
        if not self.is_leaf:
            if (offset != wx.NOT_FOUND and offset >= 0
                    and offset < len(children)):
                evt = Widget.EventStructChange(self.GetId(),
                                               index=self.index + 1,
                                               struct=children[offset])
                wx.PostEvent(self, evt)
            else:
                evt = Widget.EventStructChange(self.GetId(),
                                               index=self.index + 1,
                                               struct=None)
                wx.PostEvent(self, evt)
示例#3
0
 def panelbar(self):
     handle = self.server.get(self.handle, 'panelbar')
     if handle:
         try:
             return self.getWidget(handle)
         except KeyError:
             return Widget.Widget(self.server, handle, self)
示例#4
0
 def instantiate(self, importList=[]):
     h = self.app.server.dup(self.handle)
     w = Widget.Widget(self.app.server, h, self.app)
     self.instances.append(w)
     for name in importList:
         attrName = name.replace(' ','_')
         setattr(w,attrName,w.find(name))
     w.importList = importList
     return w
示例#5
0
 def link(self, handler, widget=None, evname=None):
     if type(widget) == type(''):
         evname = widget
         widget = None
     if type(widget) in (type(0), type(0L)):
         try:
             widget = self.getWidget(widget)
         except KeyError:
             widget = Widget.Widget(self.server, widget, self)
def create_tree():
    #initialize start state and widgets
    w1 = Widget.Widget('AEDCA')
    w2 = Widget.Widget('BEACD')
    w3 = Widget.Widget('BABCE')
    w4 = Widget.Widget('DADBD')
    w5 = Widget.Widget('BECBD')
    start_state = Planning.State('start', start_dist, {1:w1, 2:w2,3:w3, 4:w4,5:w5 })
    #create root
    root = PlanTree(start_state)
    #create children
    root.A = create_child(root.data.vars,distances_A,'A')
    root.B = create_child(root.data.vars,distances_B,'B')
    root.C = create_child(root.data.vars,distances_C,'C')
    root.D = create_child(root.data.vars,distances_D,'D')
    root.E = create_child(root.data.vars,distances_E,'E')
    # return the root
    return root
      def startSlide(e):
          self._isMouseDown=True
          self._upperBound = self._div_shell.offsetWidth - self._handle.offsetWidth

          pos = Widget.getMousePosition(e)
          self._startMouseX=pos['x']

          self._lastElementLeft = parseInt(self._handle.elt.style.left) #- parseInt(self._div_shell.elt.style.left)
          #print(self._upperBound)
          updatePosition(e)
      def updatePosition(e):
          pos = Widget.getMousePosition(e)
          _newPos = self._lastElementLeft + pos['x'] - self._startMouseX
          
          _newPos = max(0, _newPos)
          _newPos = min(_newPos, self._upperBound)

          #print(_newPos)
          self._handle.elt.style.left = '%spx' % _newPos
          self._lastElementLeft = _newPos
示例#9
0
        def updatePosition(e):
            pos = Widget.getMousePosition(e)
            _newPos = self._lastElementLeft + pos['x'] - self._startMouseX

            _newPos = max(0, _newPos)
            _newPos = min(_newPos, self._upperBound)

            #print(_newPos)
            self._handle.elt.style.left = '%spx' % _newPos
            self._lastElementLeft = _newPos
示例#10
0
 def add_widget(self,
                widget_type,
                name,
                x,
                y,
                width,
                height,
                z=0,
                transparent=False):
     if width > 0 and height > 0:
         if widget_type in ('rect', 'Rect'):
             self.widgets[name] = Widget.Rect(name, x, y, width, height, z,
                                              transparent)
         elif widget_type in ('text', 'Text'):
             self.widgets[name] = Widget.Text(name, x, y, width, height, z,
                                              transparent)
         elif widget_type in ('textbox', 'Textbox'):
             self.widgets[name] = Widget.Textbox(name, x, y, width, height,
                                                 z, transparent)
         elif widget_type in ('gradient', 'Gradient'):
             self.widgets[name] = Widget.Gradient(name, x, y, width, height,
                                                  z, transparent)
         elif widget_type in ('variable', 'Variable'):
             self.widgets[name] = Widget.Variable(name, x, y, width, height,
                                                  z, transparent)
         elif widget_type in ('diagram', 'Diagram'):
             self.widgets[name] = Widget.Diagram(name, x, y, width, height,
                                                 z, transparent)
         elif widget_type in ('bar', 'Bar'):
             self.widgets[name] = Widget.Bar(name, x, y, width, height, z,
                                             transparent)
         elif widget_type in ('ellipse', 'Ellipse'):
             self.widgets[name] = Widget.Ellipse(name, x, y, width, height,
                                                 z, transparent)
         elif widget_type in ('container', 'Container'):
             self.widgets[name] = Container(name, x, y, width, height, z,
                                            transparent)
         elif widget_type in ('table', 'Table'):
             self.widgets[name] = Widget.Table(name, x, y, width, height, z,
                                               transparent)
         else:
             raise ValueError(
                 "add_widget() called from Container with unknown widget_type: widget_type = "
                 + widget_type)
     else:
         raise ValueError(
             "[Warning] add_widget() called from Container with illegal width and height: ("
             + str(width) + ", " + str(height) + ")")
示例#11
0
        def startSlide(e):
            self._isMouseDown = True
            self._upperBound = self._div_shell.offsetWidth - self._handle.offsetWidth

            pos = Widget.getMousePosition(e)
            self._startMouseX = pos['x']

            self._lastElementLeft = parseInt(
                self._handle.elt.style.left
            )  #- parseInt(self._div_shell.elt.style.left)
            #print(self._upperBound)
            updatePosition(e)
示例#12
0
    def __init__(self, game):
        self.game = game
        w, h = conf.WINSIZE
        w = int(0.5 * w)
        h = int(0.8 * h)
        Drawable.Layer.__init__(self, size=(w, h))
        GameLooper.__init__(self)

        self.sprites = self.addGroup(layer=self)

        self.events.add(Event.KEYUP_Event(key=K_ESCAPE, callback=self._stop))

        self.set_background(color=BLACK)
        self.border(width=3, color=RED)
        s = Drawable.String(w=self, message='configuration',
                                fontSize=40)
        s.center(y=15)
        #print 1, s.get_position()
        s = Drawable.Stationary(w=self, sprite=s)
        s.draw()
        self.center()
        #print 2, self.get_position()

        q = Widget.SpriteTextButton(self, 'QUIT', callback=self._quit,
                                        group=self.events)
        q.center(y=50)
        self.sprites.add(q)

        cl = Widget.CloseButton(self, callback=self._stop,
                                        group=self.events)

        self.events.add(Event.KEYUP_Event(key=K_s, callback=self.save_config))
        save = Widget.SpriteTextButton(self, 'Save', callback=self.save_config,
                                        group=self.events)
        save.center(y=-50)
        self.sprites.add(save)

        self.show_video_modes()
示例#13
0
 def poll_next_event(self, timeout=None):
     ev = self.server.wait(timeout)
     if ev is None:
         return
     if ev.widget_id is None:
         if ev.name == 'infilter':
             ev = ev.trigger
             try:
                 ev.widget = self._infilter_registry[ev.sender]
             except KeyError:
                 ev.widget = self
         else:
             ev.widget = None
     else:
         try:
             ev.widget = self._widget_registry[ev.widget_id]
         except KeyError:
             ev.widget = Widget.Widget(self.server, ev.widget_id)
     self._event_stack.append(ev)
示例#14
0
class WidgetTestCase(unittest.TestCase):
    def setUp(self):
        self.widget = Widget()

    def tearDown(self):
        self.widget.dispose()
        self.widget = None

    def testSize(self):
        self.assertEqual(self.widget.getSize(), (40, 40))

    def testResize(self):
        self.widget.resize(100, 100)
        self.assertEqual(self.widget.getSize(), (100, 100))
示例#15
0
 def setUp(self):
     self.widget = Widget.Widget()
示例#16
0
    #
    try:
        # Execute start-up procedures and receive Device instance and label str
        label = startup_screen(dev, HEADER)
    except:
        log.exception("Start-up procedures failed!")
        print("Program execution terminated abnormally. See 'pbbes.log'")
        os._exit(-1)


    #
    # Create Main UI and start executing
    #
    try:
        # Initialize curses
        stdscr = Widget.init()

        # Setup event scheduler (IntervalWidget needs it)
        event = IntervalScheduler(
            Config.Heartbeat,
            Config.Interval,
            Config.Timewindow
        )

        # Create (and draw) Widgets
        with \
        Widget.TableWidget(device = dev) as tbl, \
        Widget.PWMLabelWidget() as lbl, \
        Widget.PWMWidget(device = dev, channel = 1) as pwm1, \
        Widget.PWMWidget(device = dev, channel = 2) as pwm2, \
        Widget.PWMWidget(device = dev, channel = 3) as pwm3, \
示例#17
0
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
import Widget
import test_rc

app = QtWidgets.QApplication(sys.argv)

window = Widget.QmyWidget()

window.show()
sys.exit(app.exec())
示例#18
0
# along with pygsear; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
"""Objects used for network communication using Twisted

More information available at http://twistedmatrix.com/

"""

try:
    import twisted
except ImportError:
    import Widget

    msg = """Game requires Twisted Python for networking
    see  http://twistedmatrix.com/  for information"""
    dlg = Widget.Dialog_OK(message=msg)
    dlg.modal()
    raise ImportError, "Error importing twisted modules"

from twisted.internet import reactor
from twisted.spread import pb


class TwoPlayerConnection(pb.Root, pb.Referenceable):
    """Simple two player network connector

    First tries to connect to an existing server, and if none is
    found, will then wait for an incoming connection.

    """
    def __init__(self, game):
示例#19
0
try:
	from PySide import QtCore, QtGui
except ImportError:
	from PyQt4 import QtCore, QtGui

if __name__ == "__main__":

	App = QtGui.QApplication(sys.argv)

	Midi.startup()

	globals = GlobalSettings()

	TPlayer = Player(globals)
	TWidget = Widget(TPlayer,globals)
	TPanel = TWidget.panel

	TPlayer.set_panel(TPanel)

	if len(TPlayer.behaviournames) <= 0:
		print "Hey!?  No behaviours in %s !?" % globals.settings_dir(settingsname)
		sys.exit(1)

	bn = TPlayer.behaviournames[0]
	TPanel.change_behaviour(bn, True)

	TPanel.write_file_onchange = True

	oscmon = OscMonitor("127.0.0.1", globals.tuioport)
	oscmon.setcallback(TPlayer.mycallback, "")
 def test_default_widget_size(self):
     widget = w.Widget('The widget')
     self.assertEqual(widget.size(), (50, 50))te
#! /usr/bin/env python
# -*- coding:utf-8 -*-

#
# Camera calibration application
#

# External dependencies
import sys
from PyQt5 import QtWidgets
import Widget

# Main application
if __name__ == '__main__':
    application = QtWidgets.QApplication(sys.argv)
    widget = Widget.CameraCalibrationWidget()
    widget.show()
    sys.exit(application.exec_())
import Planning
import Widget
import PlanTree
import graph

#part 1 Q1
w1 = Widget.Widget('AEDCA')
w2 = Widget.Widget('BEACD')
w3 = Widget.Widget('BABCE')
w4 = Widget.Widget('DADBD')
w5 = Widget.Widget('BECBD')
short_graph = graph.Graph()
short_graph.edges = {
    'start': ['A', 'B', 'C', 'D', 'E'],
    'A': ['B', 'C', 'D', 'E'],
    'B': ['A', 'C', 'D', 'E'],
    'C': ['A', 'B', 'D', 'E'],
    'D': ['A', 'B', 'C', 'E'],
    'E': ['A', 'B', 'C', 'D']
}
short_graph.weights = {
    'start': {
        'A': 1,
        'B': 1,
        'C': 1,
        'D': 1,
        'E': 1
    },
    'A': {
        'B': 1,
        'C': 1,