Example #1
0
    def __init__(self, parent=None, width=800, height=800, background="white"):
        """
        Initialisation

        parent : le parent dans l'application
        width,height : dimension de l'ecran
        background : fond d'ecran

        signal_X, ... : identifiants des signaux 
        color_X, ... : couleur d'affichage des siganux
        """
        Canvas.__init__(self)
        self.parent = parent

        self.width = width
        self.height = height

        self.signal_X = None
        self.color_X = "red"
        self.signal_Y = None
        self.color_Y = "green"
        self.signal_XY = None
        self.color_XY = "#ff00ff"

        self.grid = []

        self.configure(bg=background, bd=2, relief="sunken")
        self.bind("<Configure>", self.resize)
Example #2
0
 def __init__(self, parent):
     Canvas.__init__(self, width=WIDTH, height=HEIGHT, 
         background="black", highlightthickness=0)
      
     self.parent = parent 
     self.initGame()
     self.pack()
Example #3
0
    def __init__(self, window,color, value, maxVal, name, gaugeScale, lineColor, bgColor, textFont):
        Canvas.__init__(self, window, bg=bgColor, height=100, width=100)
        xval = 20
        yval = 10
        self.maxVal = maxVal
        self.value = value

        self.gaugeValue = self.maxVal / float(value)  # calculate the GaugeValue

        self.hand = self.create_arc(xval, yval, (xval + 100 * gaugeScale),
                                      (yval + 100 * gaugeScale), start=0,
                                      extent=-(220 / self.gaugeValue), fill=color)  # Draw hand

        self.outline = self.create_arc(xval - 3, yval - 3, (xval + 100 * gaugeScale + 3),
                                         (yval + 100 * gaugeScale + 3), start=0, extent=-220, style="arc",
                                         outline=lineColor, width=2)  # draw outline

        self.valueBox = self.create_rectangle((xval + 50 * gaugeScale), yval + 20 * gaugeScale,
                                                xval + 100 * gaugeScale + 3, yval + 50 * gaugeScale,
                                                outline=lineColor,
                                                width=2)  # draw Value Box

        self.value1 = self.create_text(xval + 54 * gaugeScale, yval + 22 * gaugeScale, anchor="nw",
                                         text=self.value,
                                         fill=lineColor, font=(textFont, int(round(15 * gaugeScale))))

        self.value2 = self.create_text(xval-10, yval - 8, anchor="nw", text=name, fill=lineColor,
                                         font=(textFont, int(round(19 * gaugeScale))))
Example #4
0
    def __init__(self, parent, x_coord, y_coord, scale, max_x, max_y, bgcolor):
        Canvas.__init__(self,
                        parent,
                        relief=RAISED,
                        borderwidth=2,
                        bg=bgcolor,
                        width=x_coord * 2 + max_x * scale,
                        height=y_coord * 2 + max_y * scale)

        self.parent = parent
        self.scaled_max_x = max_x * scale
        self.scaled_max_y = max_y * scale
        self.scale = scale

        self.create_rectangle(x_coord,
                              y_coord,
                              x_coord + max_x * scale + 2,
                              x_coord + max_y * scale + 2,
                              outline="#f11",
                              width=2)

        self.font_5x7 = MyFont(self, x_coord, y_coord, "Courier", "normal", 8,
                               19, 5, 8, 7, scale, bgcolor)
        self.font_8x8 = MyFont(self, x_coord, y_coord, "Monospace", "bold", 8,
                               12, 8, 8, 7, scale, bgcolor)
        self.font_8x16 = MyFont(self, x_coord, y_coord, "Monospace", "normal",
                                4, 12, 8, 16, 15, scale, bgcolor)
        self.font = self.font_5x7
Example #5
0
    def __init__(self, root, data, horizontaljoin=False, ratiocallback=None, buttoncallback=None):
        """
        Create a new scopetube.

        :param root: is the main window
        :param data: is the data to display (or update if enabled)
        :param horizontaljoin: if true the points are joined through horizontal segments then vertica 
        (for waveditor) if it is false they are just joined as useful in the scope view
        :param buttoncallback: it is the function to provide if the user can manage the graphs 
        changing point (for wave editor)
        :returns: a new instance of scope

        """ 
        Canvas.__init__(self, root, background='white')

        self.bind('<Button-1>', self.bndbtnmovebegin)
        self.bind('<B1-Motion>', self.bndbtnmove)
        self.bind('<ButtonRelease-1>', self.bndbtnmoveend)

        self.bind('<Button-2>', self.bndbtnfit)

        self.bind('<Button-4>', self.bndbtnzoom)
        self.bind('<Button-5>', self.bndbtnzoom)
        root.bind('<MouseWheel>', self.bndbtnzoom)  # do not understand why if bind to this canvas does not catch the mousewheel

        self.bind('<ButtonRelease-3>', self.bndbtnpntins)

        self.horizontaljoin = horizontaljoin

        self.points = data
        self.dpsfile = Dpsfile(self.points)

        self.ratiocallback = ratiocallback

        self.buttoncallback = buttoncallback
Example #6
0
    def __init__(self, master, width, data_callback):
        """Construct a Meter.

        :param master
        :param width
        :param data_callback: function to retrieve meter data
        :param end_callback: function to call upon completion
        """
        Canvas.__init__(self, master, bg=COLOR_METER_BG, borderwidth=2, relief=Tkinter.GROOVE, width=width, height=METER_HEIGHT)

        self._data_callback = data_callback

        self._width = (int)(self.cget("width"))
        self._x0 = 0
        self._y0 = METER_HEIGHT - 25
        self._x1 = self._width + 5
        self._y1 = METER_HEIGHT

        self.create_text(10, 60, anchor=Tkinter.W, font=FONT_SMALL, text=TEXT_POSITION, fill=COLOR_METER_TEXT)
        self.create_text(140, 60, anchor=Tkinter.W, font=FONT_SMALL, text=TEXT_LENGTH, fill=COLOR_METER_TEXT)
        self.create_text(270, 60, anchor=Tkinter.W, font=FONT_SMALL, text=TEXT_CUE, fill=COLOR_METER_TEXT)

        self._position = self.create_text(10, 85, anchor=Tkinter.W, font=FONT_NUM, fill=COLOR_METER_TEXT)
        self._length = self.create_text(140, 85, anchor=Tkinter.W, font=FONT_NUM, fill=COLOR_METER_TEXT)
        self._cue = self.create_text(270, 85, anchor=Tkinter.W, font=FONT_NUM, fill=COLOR_METER_TEXT)
        self._title = self.create_text(10, 20, anchor=Tkinter.W, font=FONT_HEAD, fill=COLOR_METER_TEXT)
        self._artist = self.create_text(self._width, 20, anchor=Tkinter.E, font=FONT_HEAD, fill=COLOR_METER_TEXT)

        self._bar_bg = self.create_rectangle(self._x0, self._y0, self._x1, self._y1, fill=COLOR_BAR_BG)
        self._bar_fg = self.create_rectangle(self._x0, self._y0, self._x0, self._y1, fill=COLOR_BAR_FG)

        self.reset()
Example #7
0
 def __init__(self,
              master,
              width,
              height,
              n_classes=_N_CLASSES,
              fuel_color_map=DEFAULT_FUEL_COLOR_MAP,
              color_scheme_map=DEFAULT_GRADIENT_COLOR_SCHEMES,
              color_scheme=BLACK_SCHEME):
     """
     :param master:
     :param width:
     :param height:
     :param n_classes:
     :param fuel_color_map:
     :param color_scheme:
     """
     Canvas.__init__(self, master=master, width=width, height=height)
     self._height = height
     self._width = width
     self._n_classes = n_classes
     self._fuel_color_map = fuel_color_map
     self._color_schemes = color_scheme_map
     self._color_scheme = color_scheme
     self._elev_min, self._elev_max = None, None
     self._ign_min, self._ign_max = None, None
     self._active_part = View._FUEL_ACTIVE
     self._is_view_changed = False
Example #8
0
 def __init__(self, master, image):
     self.height_ratio = 1
     width, height = image.size
     pixels = image.load()
     RED, GREEN, BLUE = range(3)
     self.colors = [
         '#{0:02x}{1:02x}{2:02x}'.format(
             contrast(
                 sum(pixels[x, y][RED] for x in xrange(width)) / width),
             contrast(
                 sum(pixels[x, y][GREEN] for x in xrange(width)) / width),
             contrast(
                 sum(pixels[x, y][BLUE] for x in xrange(width)) / width))
         for y in xrange(height)
     ]
     if height / float(width) > 1.5:
         width *= 2
     elif width < 200:
         width *= 2
         height *= 2
         self.height_ratio = 2
     if (width, height) != image.size:
         image = image.resize((width, height))
     Canvas.__init__(self, master, width=width, height=height)
     self.tk_img = ImageTk.PhotoImage(image)
     self.update_image()
     self.pack()
Example #9
0
 def __init__(self, parent):
     Canvas.__init__(self, width=WIDTH, height=HEIGHT, 
         background="black", highlightthickness=0)
      
     self.parent = parent 
     self.initGame()
     self.pack()
Example #10
0
    def __init__(self, master=None, fps=20, *args, **kw):
        Canvas.__init__(self, master, *args, **kw)

        self.frame = Frame3D()
        self.items = {}

        self.w = float(self['width'])
        self.h = float(self['height'])

        self.axes_on = True
        self._xy_axes()

        self.bind('<Configure>', self.resize_callback)

        self.fps_ms = 1000 / fps # Frames per second in milliseconds.

        self.focal_distance = 2.2
        self.x_arc_of_view = 73.0
        self.y_arc_of_view = 73.0

        self.f = G(self.w, self.x_arc_of_view)
        self.u = G(self.h, self.y_arc_of_view)

        self._frustum = Frustum(
            self.w,
            self.h,
            self.x_arc_of_view,
            self.y_arc_of_view,
            self.focal_distance,
            )
Example #11
0
    def __init__(self, parent, graph):
        Canvas.__init__(self, parent, width=graph.width, height=graph.height)

        for e in graph.edges:
            self.create_line(*[i for j in e for i in graph.vertex[j]])

        self.vertex = {k: self.createCircle(v[0], v[1], 6, fill="black") for k, v in graph.vertex.items()}
        self.pack()
Example #12
0
    def __init__(self, window,color, value,name, lineColor, bgColor, textFont):
        Canvas.__init__(self, window, bg=bgColor, height=100, width=100)
        xval = 20
        yval = 10

        self.value = value

        self.value1 = self.create_text(xval + 54, yval + 22, anchor="nw", text=name + " " + str(self.value), fill=lineColor,
                                       font=(textFont, int(round(15))))
Example #13
0
 def __init__(self, parent, height=30, width=150, increments=15):
     self.increments = increments
     self.height = height
     self.increment_width = width/increments-2
     self.current_increment = 0
     Canvas.__init__(self, parent, height=height, width=width, bd=0)
     self.create_rectangle(1, 1, width-1, height-1, fill="")
     self.xview_moveto(0)
     self.yview_moveto(0)
Example #14
0
 def __init__(self,parent,**kwargs):
     Canvas.__init__(self,parent,**kwargs)
     self.bind("<Configure>", self._on_resize)
     self.height,self.original_height = 700,700
     self.width,self.original_width = 1300,1300
     self.fonts = FontContainer()
     self.animations = {}
     self.animation_queue = []
     self.children_original_dimensions = {}
Example #15
0
	def __init__(self,dim,**kwargs):
		self.dim=dim
		self.space=space
		self.wood_color=(.9*236,.9*206,.9*124)
		Canvas.__init__(self,**kwargs)
		self.prepare_mesh()
		self.no_redraw=[]
		
		self.anchor_x=0
		self.anchor_y=0
 def __init__(self, master, grid, w, h, *args, **kwargs):
     Canvas.__init__(self, master, *args, **kwargs)
     self.max_width = w
     self.max_height = h
     self.width = w
     self.height = h
     self._fill_color = 'black'
     self._bg_color = 'white'
     self._grid_line_width = 1
     self.draw_grid(grid)
Example #17
0
    def __init__(self, stats_gui=None, parent=None, run=None, column=None, row=None, sq_size=15, delay=20, *args,
                 **kwargs):
        Canvas.__init__(self, parent, bg='white', highlightthickness=0, borderwidth=0, *args, **kwargs)
        self.sqsize = sq_size
        self.run = run
        self.delay = delay
        self.stats = stats_gui

        self.column = column
        self.row = row
Example #18
0
    def __init__(self, dim, **kwargs):
        self.dim = dim
        self.space = space
        self.wood_color = (214, 174, 114)  #same as gogui
        Canvas.__init__(self, **kwargs)

        self.anchor_x = 0
        self.anchor_y = 0

        self.define_goban_style()
        self.create_goban()
        self.temporary_shapes = []
Example #19
0
    def __init__(self, dim, **kwargs):
        self.dim = dim
        self.space = space
        self.wood_color = (.9 * 236, .9 * 206, .9 * 124)
        Canvas.__init__(self, **kwargs)

        self.anchor_x = 0
        self.anchor_y = 0

        self.define_goban_style()
        self.create_goban()
        self.temporary_shapes = []
Example #20
0
    def __init__(self, parent, clf, mb, note_sample_window_size):
        Canvas.__init__(self, parent, bg="#FFFFFF", width = self.WIDTH, height = self.HEIGHT)

        self.tclef = PhotoImage(file="./images/tclef.gif", master=self)
        self.bclef = PhotoImage(file="./images/bclef.gif", master=self)

        print self.tclef
        self.last_note_set = ()
        self.notes = []
        self.clf = clf
        self.mb = mb
        self.note_sample_window_size = note_sample_window_size
        
        self.update_staff()
Example #21
0
    def __init__(self, master, **cnf):
        Canvas.__init__(self, master, highlightthickness=0)

        self.__model = RangeSliderModel()
        self.__controller = RangeSliderController(self.__model, self)

        self.configure(**cnf)

        self.__model.subscribe(self.__controller.update)
        self.bind("<Configure>", self.__resize)
        self.bind("<Key>", self.__controller.rangeSlider_onKeyPress)

        # critical to the focus subsystem!
        self.master.bind("<Button>", self.__focusCheck, add="+")
        self.master.bind("<Key>", self.__focusCheck, add="+")
Example #22
0
	def __init__(self, master, **cnf):
		Canvas.__init__(self, master, highlightthickness=0)

		self.__model = RangeSliderModel()
		self.__controller = RangeSliderController(self.__model, self)

		self.configure(**cnf)

		self.__model.subscribe(self.__controller.update)
		self.bind("<Configure>", self.__resize)
		self.bind("<Key>", self.__controller.rangeSlider_onKeyPress)

		# critical to the focus subsystem!
		self.master.bind("<Button>", self.__focusCheck, add="+")
		self.master.bind("<Key>", self.__focusCheck, add="+")
Example #23
0
    def __init__(self,
                 master,
                 filename=None,
                 data=None,
                 start_animation=True,
                 time=40,
                 **kwargs):

        if data is not None:
            self._image = Image.open(BytesIO(base64.b64decode(data)))
        elif filename is not None:
            self._image = Image.open(filename)
        elif hasattr(self, "data"):
            self._image = Image.open(BytesIO(base64.b64decode(self.data)))
        else:
            raise Exception("No image data or file")

        if self._image.format == "XBM":
            self._imagetk_class = ImageTk.BitmapImage
        else:
            self._imagetk_class = ImageTk.PhotoImage

        width, height = self._image.size

        self._time = time

        kwargs.setdefault("width", width)
        kwargs.setdefault("height", height)
        kwargs.setdefault("highlightthickness", 0)

        if "borderwidth" not in kwargs and "bd" not in kwargs:
            kwargs["borderwidth"] = 0

        Canvas.__init__(self, master, **kwargs)

        self._bind_tag = "icon_rotating%s" % RotatingIcon._bind_tag_ID
        RotatingIcon._bind_tag_ID += 1

        self.bind_class(self._bind_tag, "<Unmap>", self._on_unmap)
        self.bind_class(self._bind_tag, "<Map>", self._on_map)

        self._running = False
        self._is_mapped = False

        if start_animation:
            self.start_animation()
Example #24
0
    def __init__(self, parent=None, width=800, height=800, background="white"):
        """ initialisation

        parent : un Oscilloscope
        width,height : dimension de l'ecran
        background : fond d'ecran
        """
        Canvas.__init__(self)
        self.parent = parent

        self.width = width
        self.height = height
        self.signal_X = None
        self.color_X = "red"

        self.configure(bg=background, bd=2, relief="sunken")
        self.bind("<Configure>", self.resize)
Example #25
0
    def __init__(self, master, track, beat, is_stressed):

        Canvas.__init__(self,
                        master,
                        width=20,
                        height=20,
                        highlightthickness=0)

        self.bind('<Button-1>', lambda _: self.command())
        self.bind('<<Toggle-Visual>>', lambda _: self.toggle_visual())

        self.track = track
        self.beat = beat
        self.playing = False
        self.is_stressed = is_stressed
        self.toggle_visual()

        self.changed = True
    def __init__(self, preview_id, img_path = PATH_BLANK_PICTURE, img_id = -1, master=None, cnf={}, **kw):
        Canvas.__init__(self, master=master, cnf=cnf, **kw)
        self.master = master
        self.img_id = img_id
        self.preview_id = preview_id

        imgfile = Image.open(PATH_BLANK_PICTURE)
        resized = imgfile.resize(SIZE_PREVIEW, Image.ANTIALIAS)
        self.imgtk = ImageTk.PhotoImage(resized)
        imgfile.close()


        self.create_image(0, 0, image=self.imgtk, tags = "IMG")
        self.configure(scrollregion= (-(w//2), -(h//2), (w//2), (h//2)))

        self.id_viewer = Label(self, text=str(preview_id), font = ("serif", 20), fg='red', bg='white')
        self.id_viewer.pack()
        self.create_window(w//2 - 10, h//2 - 10, window=self.id_viewer)
Example #27
0
    def __init__(self, parent=None, width=200, height=200, background="pink"):
        """
        Initialisation
        parent : le parent dans l'application
        background : fond d'ecran
        """

        self.width = width
        self.height = height
        
        Canvas.__init__(self, width=self.width, height=self.height, background=background)
        self.parent = parent

        # Signal X-Y
        self.signal_XY = None
        self.signal_XY_liste = []
        self.color_XY = "green"
        self.signal_XY_allowed = 0;
Example #28
0
    def __init__(self, parent, top, lmap):
        """Constructor. Initialises class attributes, calls drawMap. parent = mapcontainer
           created in Gui. Ref to Gui (top) supplied in case needed for future use."""
        Canvas.__init__(self, parent, width=512, height=512)
        # Bind drag and drop events to canvas and pack it in mapcontainer
        self.bind('<ButtonPress-1>', self.grab)
        self.bind('<ButtonRelease-1>', self.drop)
        self.bind('<B1-Motion>', self.drag)
        self.pack(side='left', fill=BOTH, expand=1)

        self.xpos = 0  # X coord of mouse grab event
        self.ypos = 0  # Y coord of mouse grab event
        self.scale = 1  # Current zoom level
        self.im = None  # Ref to original image, on which zoom is based
        self.original = None  # image id, as first added to canvas
        self.zoomed = None  # image id, as zoomed on canvas

        self.lmap = lmap
        self.drawMap(lmap)
Example #29
0
    def __init__(self, master, tone_width=KEY_WIDTH):
        Canvas.__init__(self,
                        master,
                        background='gray',
                        height=SCALE_PLOT_HEIGHT,
                        highlightthickness=0)
        self.tone_width = tone_width
        self.offset = int(tone_width / 2)
        self.min_tone = MIN_TONE
        self.max_tone = MAX_TONE

        self.scales = {}
        for width in range(16, 1, -2):
            color = "gray%i" % (20 + 3 * width)
            self.draw_scale(scales.EvenTempered(528), color=color, width=width, add_to_scales=False)

        self.tones = {}
        self.events = []
        self.running = True
        self.consume()
 def __init__(self, parent):
     Canvas.__init__(self, parent)
     self.gpio_pins = CM.hardware.gpio_pins
     self.gpiolen = CM.hardware.gpio_len
     self.pwm_max = CM.hardware.pwm_range
     self.gpioactive = hc._GPIOACTIVE
     self.is_pin_pwm = hc.is_pin_pwm
     self.gpio = list()
     self.state = list()
     self.channels = [_ for _ in range(self.gpiolen)]
     self.channel_keys = CM.network.channels.keys()
     self.network = hc.network
     self.red = "#FF0000"
     self.green = "#00FF00"
     self.blue = "#0000FF"
     self.white = "#FFFFFF"
     self.black = "#000000"
     self.parent = parent
     self.init_ui()
     self.tkinter_function()
 def __init__(self, parent):
     Canvas.__init__(self, parent)
     self.gpio_pins = CM.hardware.gpio_pins
     self.gpio_len = CM.hardware.gpio_len
     self.pwm_max = CM.hardware.pwm_range
     self.gpio_active = hc._GPIOACTIVE
     self.is_pin_pwm = hc.is_pin_pwm
     self.gpio = list()
     self.state = list()
     self.channels = [_ for _ in range(self.gpio_len)]
     self.channel_keys = CM.network.channels.keys()
     self.network = hc.network
     self.red = "#FF0000"
     self.green = "#00FF00"
     self.blue = "#0000FF"
     self.white = "#FFFFFF"
     self.black = "#000000"
     self.parent = parent
     self.init_ui()
     self.tkinter_function()
Example #32
0
    def __init__(self, parent, x_coord, y_coord, radius, scale):
        Canvas.__init__(self,
                        parent,
                        relief=RAISED,
                        borderwidth=2,
                        bg="grey",
                        width=(radius + x_coord / 2) * scale * 2,
                        height=(radius + y_coord / 2) * scale * 2)
        self.parent = parent
        self.scale = scale
        self.radius = radius * scale
        self.xcenter = x_coord + self.radius
        self.ycenter = y_coord + self.radius
        self.ledradius = 2 * scale
        self.ledcolor = []
        self.ledxy = []
        self.led = []

        positions = [
            75, 45, 15, 270 + 75, 270 + 45, 270 + 15, 180 + 75, 180 + 45,
            180 + 15, 90 + 75, 90 + 45, 90 + 15
        ]
        colors = [
            "green", "green", "red", "red", "green", "green", "red", "red",
            "green", "green", "red", "red"
        ]
        idx = 0
        for i in positions:
            p = math.radians(i)
            xy = (math.cos(p) * self.radius + self.xcenter,
                  self.ycenter - math.sin(p) * self.radius)
            self.ledcolor.append(colors[idx])
            self.ledxy.append(xy)
            self.led.append(
                self.create_oval(xy[0] - self.ledradius,
                                 xy[1] - self.ledradius,
                                 xy[0] + self.ledradius,
                                 xy[1] + self.ledradius,
                                 outline="black",
                                 width=1))
            idx += 1
    def __init__(self,
                 master,
                 font,
                 row_height,
                 row_minwidth,
                 hover_background=None,
                 background=None,
                 anchor=None,
                 onclick=None):
        Canvas.__init__(self,
                        master,
                        bd=0,
                        highlightthickness=0,
                        yscrollincrement=row_height,
                        width=0)

        if background is not None:
            self.configure(background=background)

        self._frame_of_row_numbers = Frame(self, bd=0)

        self.create_window(0,
                           0,
                           window=self._frame_of_row_numbers,
                           anchor=N + W)
        self._width_of_row_numbers = 0

        self._labelrow_kwargs = labelrow_kwargs = {}

        labelrow_kwargs["font"] = font

        if anchor is not None:
            labelrow_kwargs["anchor"] = anchor

        self._row_minwidth = row_minwidth
        self._row_height = row_height
        self._hover_background = hover_background
        self._onclick = onclick

        self._number_of_labels = 0
Example #34
0
    def __init__(self, master, layout, margin=20, **kw):
        Canvas.__init__(self,
                        master,
                        width=layout.size.x + 2 * margin,
                        height=layout.size.y + 2 * margin,
                        **kw)

        self.__margin = margin

        self._vertex_label_mode = "auto"
        # map value -> Vertex object
        self._vertices = dict()
        self._layout = layout
        self._picked_vertex_state = PickedState()
        self._create_vertex_shape = (
            lambda vertex: shapes.create_default_shape(self, vertex))
        self.update()

        # self._translate = (0, 0)

        self._mouse_plugin = MousePlugin().apply(self)

        # makes vertex shape change appearing if it was picked
        # also sets layout lock for picked vertices
        def createListener():
            state = self._picked_vertex_state
            layout = self.layout

            def listener(vertex):
                picked = state.is_picked(vertex)
                vertex.shape.set_selection(picked)
                layout.set_lock(layout.graph.index(vertex.value), picked)

            return listener

        self._picked_vertex_state.add_listener(createListener())

        # handle resize
        self.bind("<Configure>", lambda event: self._update_layout_size())
Example #35
0
    def __init__(self, master, layout, margin=20, caption=None, **kw):
        Canvas.__init__(self, master,
                        width=int(layout.size.x + 2 * margin),
                        height=int(layout.size.y + 2 * margin), **kw)

        self.__margin = margin

        self._vertex_label_mode = "auto"
        # map value -> Vertex object
        self._vertices = dict()
        self._layout = layout
        self._picked_vertex_state = PickedState()
        self._create_vertex_shape = (lambda vertex:
                                     shapes.create_default_shape(self, vertex))
        self.update()

        self._caption = self.create_caption(caption) if caption else None

        # self._translate = (0, 0)

        self._mouse_plugin = MousePlugin().apply(self)

        # makes vertex shape change appearing if it was picked
        # also sets layout lock for picked vertices
        def createListener():
            state = self._picked_vertex_state
            layout = self.layout

            def listener(vertex):
                picked = state.is_picked(vertex)
                vertex.shape.set_selection(picked)
                layout.set_lock(layout.graph.index(vertex.value), picked)

            return listener

        self._picked_vertex_state.add_listener(createListener())

        # handle resize
        self.bind("<Configure>", lambda event: self._on_configure())
Example #36
0
 def __init__(self, master, image):
     self.height_ratio = 1
     width, height = image.size
     pixels = image.load()
     RED, GREEN, BLUE = range(3)
     self.colors = ['#{0:02x}{1:02x}{2:02x}'.format(
         contrast(sum(pixels[x, y][RED]   for x in xrange(width)) / width),
         contrast(sum(pixels[x, y][GREEN] for x in xrange(width)) / width),
         contrast(sum(pixels[x, y][BLUE]  for x in xrange(width)) / width))
         for y in xrange(height)]
     if height / float(width) > 1.5:
         width *= 2
     elif width < 200:
         width *= 2
         height *= 2
         self.height_ratio = 2
     if (width, height) != image.size:
         image = image.resize((width, height))
     Canvas.__init__(self, master, width=width, height=height)
     self.tk_img = ImageTk.PhotoImage(image)
     self.update_image()
     self.pack()
Example #37
0
    def __init__(self, *args, **kwargs):
        self.world = kwargs["world"]
        del kwargs["world"]

        Canvas.__init__(self, *args, **kwargs)

        #TODO: make the following dynamic
        self.anglespan = 260
        self.field_length = 6.0
        self.field_width = 4.0
        self.field_radius = 0.5
        self.field_margin = 1.0
        self.goal_depth = 0.2
        self.goal_width = 0.7
        self.thickness = 1
        self.has_field = False

        self['bg'] = FIELD_GREEN
        self['width'] = 100 * (self.field_length + 2 * self.field_margin)
        self['height'] = 100 * (self.field_width + 2 * self.field_margin)
        self.robots = {}
        self.balls = {}

        self.fps = self.create_text(50, 20, fill=BLACK)
Example #38
0
	def __init__(self,parent,**kwargs):
		Canvas.__init__(self,parent,**kwargs)
		self.pack()
		self.focus_set()
		self.parent = parent
#		self.height = self.winfo_reqheight()
#		self.width = self.winfo_reqwidth()

		self.bind('<Left>', self.parent.display_prev_image)
		self.bind('<Right>', self.parent.display_next_image)
		self.bind('<Up>', self.parent.display_first_image)
		self.bind('<Down>', self.parent.display_last_image)
		self.bind('q', self.parent.exit_mainloop)

		self.bind('<Button-1>',self.scroll_start)
		self.bind('<B1-Motion>',self.scroll_move)

		# shift image by 1 pixel
		self.bind('<Shift-Up>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate( 0,-1)))
		self.bind('<Shift-Down>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate( 0, 1)))
		self.bind('<Shift-Left>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate(-1, 0)))
		self.bind('<Shift-Right>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate( 1, 0)))

		# shift image by 8 pixels
		self.bind('<Control-Up>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate( 0,-8)))
		self.bind('<Control-Down>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate( 0, 8)))
		self.bind('<Control-Left>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate(-8, 0)))
		self.bind('<Control-Right>',
			func=lambda crd: self.scroll_from_keyboard(Coordinate( 8, 0)))
Example #39
0
    def __init__(self, master, font, row_height, row_minwidth, hover_background=None, background=None, anchor=None, onclick=None):
        Canvas.__init__(self, master, bd=0, highlightthickness=0, yscrollincrement=row_height, width=0)
        
        if background is not None:
            self.configure(background=background)

        self._frame_of_row_numbers = Frame(self, bd=0)

        self.create_window(0, 0, window=self._frame_of_row_numbers, anchor=N+W)
        self._width_of_row_numbers = 0

        self._labelrow_kwargs = labelrow_kwargs= {}

        labelrow_kwargs["font"] = font
        
        if anchor is not None:
            labelrow_kwargs["anchor"] = anchor

        self._row_minwidth= row_minwidth
        self._row_height = row_height
        self._hover_background = hover_background
        self._onclick = onclick
        
        self._number_of_labels = 0
Example #40
0
 def __init__(self,parent,dictionary,rootNode,buttonWidth,buttonHeight,buttonPadX,buttonPadY,font,fontSize):
     sr = self.calculateDimensions(dictionary,buttonWidth,buttonHeight,buttonPadX,buttonPadY)
     Canvas.__init__(self, parent,scrollregion=sr)
     self.addButtons(dictionary,rootNode,buttonWidth,buttonHeight,buttonPadX,buttonPadY,font,fontSize)
Example #41
0
 def __init__(self):
     Canvas.__init__(self, width=WIDTH, height=HEIGHT, background="white", highlightthickness=0)
     self.initInfoScreen()
     self.pack()
Example #42
0
 def __init__(self, master):
     Canvas.__init__(self, master, height=222, width=400, bg="black")
     self.create()
     self.pack(side=LEFT)
Example #43
0
 def __init__(self, graph):
     Canvas.__init__(self, graph)
     self.config(width=gconfig["info-area-width"],
                 height=gconfig["graph-height"],
                 background=gconfig["info-fill"])
     self._current_info_text = ''
Example #44
0
 def __init__(self, dim, **kwargs):
     self.dim = dim
     self.space = space
     Canvas.__init__(self, **kwargs)
     self.prepare_mesh()
Example #45
0
 def __init__(self):
     Canvas.__init__(self, width=WIDTH, height=HEIGHT, background="white", highlightthickness=0)
     self.initInfoScreen()
     self.pack()
Example #46
0
 def __init__(self, parent, **kwargs):
     Canvas.__init__(self, parent, **kwargs)
     self.raffle = list()
     self.items = list()
Example #47
0
    def __init__(self,
                 master,
                 from_color,
                 to_color,
                 width=None,
                 height=None,
                 orient=HORIZONTAL,
                 steps=None,
                 **kwargs):
        Canvas.__init__(self, master, **kwargs)
        if steps is None:
            if orient == HORIZONTAL:
                steps = height
            else:
                steps = width

        if isinstance(from_color, basestring):
            from_color = hex2rgb(from_color)

        if isinstance(to_color, basestring):
            to_color = hex2rgb(to_color)

        r, g, b = from_color
        dr = float(to_color[0] - r) / steps
        dg = float(to_color[1] - g) / steps
        db = float(to_color[2] - b) / steps

        if orient == HORIZONTAL:
            if height is None:
                raise ValueError("height can not be None")

            self.configure(height=height)

            if width is not None:
                self.configure(width=width)

            img_height = height
            img_width = self.winfo_screenwidth()

            image = Image.new("RGB", (img_width, img_height), "#FFFFFF")
            draw = ImageDraw.Draw(image)

            for i in range(steps):
                r, g, b = r + dr, g + dg, b + db
                y0 = int(float(img_height * i) / steps)
                y1 = int(float(img_height * (i + 1)) / steps)

                draw.rectangle((0, y0, img_width, y1),
                               fill=(int(r), int(g), int(b)))
        else:
            if width is None:
                raise ValueError("width can not be None")
            self.configure(width=width)

            if height is not None:
                self.configure(height=height)

            img_height = self.winfo_screenheight()
            img_width = width

            image = Image.new("RGB", (img_width, img_height), "#FFFFFF")
            draw = ImageDraw.Draw(image)

            for i in range(steps):
                r, g, b = r + dr, g + dg, b + db
                x0 = int(float(img_width * i) / steps)
                x1 = int(float(img_width * (i + 1)) / steps)

                draw.rectangle((x0, 0, x1, img_height),
                               fill=(int(r), int(g), int(b)))

        self._gradient_photoimage = ImageTk.PhotoImage(image)

        self.create_image(0, 0, anchor=NW, image=self._gradient_photoimage)
Example #48
0
    def __init__(self, master, from_color, to_color, width=None, height=None, orient=HORIZONTAL, steps=None, **kwargs):
        Canvas.__init__(self, master, **kwargs)
        if steps is None:
            if orient == HORIZONTAL:
                steps = height
            else:
                steps = width

        if isinstance(from_color, basestring):
            from_color = hex2rgb(from_color)
            
        if isinstance(to_color, basestring):
            to_color = hex2rgb(to_color)

        r,g,b = from_color
        dr = float(to_color[0] - r)/steps
        dg = float(to_color[1] - g)/steps
        db = float(to_color[2] - b)/steps

        if orient == HORIZONTAL:
            if height is None:
                raise ValueError("height can not be None")
            
            self.configure(height=height)
            
            if width is not None:
                self.configure(width=width)

            img_height = height
            img_width = self.winfo_screenwidth()

            image = Image.new("RGB", (img_width, img_height), "#FFFFFF")
            draw = ImageDraw.Draw(image)

            for i in range(steps):
                r,g,b = r+dr, g+dg, b+db
                y0 = int(float(img_height * i)/steps)
                y1 = int(float(img_height * (i+1))/steps)

                draw.rectangle((0, y0, img_width, y1), fill=(int(r),int(g),int(b)))
        else:
            if width is None:
                raise ValueError("width can not be None")
            self.configure(width=width)
            
            if height is not None:
                self.configure(height=height)

            img_height = self.winfo_screenheight()
            img_width = width
            
            image = Image.new("RGB", (img_width, img_height), "#FFFFFF")
            draw = ImageDraw.Draw(image)

            for i in range(steps):
                r,g,b = r+dr, g+dg, b+db
                x0 = int(float(img_width * i)/steps)
                x1 = int(float(img_width * (i+1))/steps)

                draw.rectangle((x0, 0, x1, img_height), fill=(int(r),int(g),int(b)))
        
        self._gradient_photoimage = ImageTk.PhotoImage(image)

        self.create_image(0, 0, anchor=NW, image=self._gradient_photoimage)
Example #49
0
 def __init__(self, *args, **kwargs):
     Canvas.__init__(self, *args, **kwargs)
     self.twidget = None
     self.config(bg='#000', highlightbackground='#000', height=3)
Example #50
0
 def __init__(self, parent, **kwargs):
     Canvas.__init__(self, parent, **kwargs)
     self.bind("<Configure>", self.on_resize)
     self.height = self.winfo_reqheight()
     self.width = self.winfo_reqwidth()
Example #51
0
 def __init__(self, master):
     Canvas.__init__(self, master, height=222, width=400, bg="black")
     self.create()
     self.pack(side=LEFT)
Example #52
0
 def __init__(self, parent, **kwargs):
     Canvas.__init__(self, parent, **kwargs)
     self.bind("<Configure>", self.on_resize)
     self.height = self.winfo_reqheight()
     self.width = self.winfo_reqwidth()
Example #53
0
    def __init__(self, parent):
        Canvas.__init__(self, parent)

        self.configure_()
        self.place_()
Example #54
0
 def __init__(self, master):
     Canvas.__init__(self, master, bg='gray', width=PIXELS, height=PIXELS)
     self.bind('<Button-1>', self.left_click)
     self.route = None
Example #55
0
	def __init__(self,parent):		
		Canvas.__init__(self, width = Display_width,height=Display_height,background = 'white', highlightthickness=0)
		self.parent = parent
		self.pack()
Example #56
0
    def __init__(self, master, width, data_callback):
        """Construct a Meter.

        :param master
        :param width
        :param data_callback: function to retrieve meter data
        :param end_callback: function to call upon completion
        """
        Canvas.__init__(self,
                        master,
                        bg=COLOR_METER_BG,
                        borderwidth=2,
                        relief=Tkinter.GROOVE,
                        width=width,
                        height=METER_HEIGHT)

        self._data_callback = data_callback

        self._width = (int)(self.cget("width"))
        self._x0 = 0
        self._y0 = METER_HEIGHT - 25
        self._x1 = self._width + 5
        self._y1 = METER_HEIGHT

        self.create_text(10,
                         60,
                         anchor=Tkinter.W,
                         font=FONT_SMALL,
                         text=TEXT_POSITION,
                         fill=COLOR_METER_TEXT)
        self.create_text(140,
                         60,
                         anchor=Tkinter.W,
                         font=FONT_SMALL,
                         text=TEXT_LENGTH,
                         fill=COLOR_METER_TEXT)
        self.create_text(270,
                         60,
                         anchor=Tkinter.W,
                         font=FONT_SMALL,
                         text=TEXT_CUE,
                         fill=COLOR_METER_TEXT)

        self._position = self.create_text(10,
                                          85,
                                          anchor=Tkinter.W,
                                          font=FONT_NUM,
                                          fill=COLOR_METER_TEXT)
        self._length = self.create_text(140,
                                        85,
                                        anchor=Tkinter.W,
                                        font=FONT_NUM,
                                        fill=COLOR_METER_TEXT)
        self._cue = self.create_text(270,
                                     85,
                                     anchor=Tkinter.W,
                                     font=FONT_NUM,
                                     fill=COLOR_METER_TEXT)
        self._title = self.create_text(10,
                                       20,
                                       anchor=Tkinter.W,
                                       font=FONT_HEAD,
                                       fill=COLOR_METER_TEXT)
        self._artist = self.create_text(self._width,
                                        20,
                                        anchor=Tkinter.E,
                                        font=FONT_HEAD,
                                        fill=COLOR_METER_TEXT)

        self._bar_bg = self.create_rectangle(self._x0,
                                             self._y0,
                                             self._x1,
                                             self._y1,
                                             fill=COLOR_BAR_BG)
        self._bar_fg = self.create_rectangle(self._x0,
                                             self._y0,
                                             self._x0,
                                             self._y1,
                                             fill=COLOR_BAR_FG)

        self.reset()
Example #57
0
 def __init__(self, parent, **kwargs):
     Canvas.__init__(self, parent, **kwargs)
     self.bind("<Configure>", self.on_resize)
Example #58
0
 def __init__(self, graph):
     Canvas.__init__(self, graph)
     self.config(width=gconfig["info-area-width"],
                 height=gconfig["graph-height"],
                 background=gconfig["info-fill"])
     self._current_info_text = ''