def circle_item_event(self, widget, target, event=None): if eval(self.config_dict['disable_line']): return False if event.type == gtk.gdk.BUTTON_PRESS: if event.button == 1: bounds = widget.get_bounds() self.pos_x = (bounds.x1+bounds.x2)/2 self.pos_y = (bounds.y1+bounds.y2)/2 if 'line 1' in self.canvasitems: self.canvasitems['line 1'].remove() self.canvasitems['line 1'] =goocanvas.Polyline( parent = self.rootitem, points = goocanvas.Points([(self.pos_x, self.pos_y), (event.x, event.y)]), fill_color_rgba = self.colors['line'], line_cap = cairo.LINE_CAP_ROUND, line_width = 6.0 ) self.movingline='line 1' print "Button press" return True if event.type == gtk.gdk.MOTION_NOTIFY: if event.state & gtk.gdk.BUTTON1_MASK: self.canvasitems[self.movingline].set_properties( points = goocanvas.Points([(self.pos_x, self.pos_y), (event.x, event.y)]) ) if event.type == gtk.gdk.BUTTON_RELEASE: if event.button == 1: self.movingline='line 1' print "Button release" return True return False
def setup_polygons(self, root): points = goocanvas.Points([(210.0, 320.0), (210.0, 380.0), (260.0, 350.0)]) pattern = self.create_stipple("blue") polyline1 = goocanvas.Polyline(parent=root, close_path=True, line_width=1.0, points=points, fill_pattern=pattern, stroke_color="black") self.setup_item_signals(polyline1) points = goocanvas.Points([(270.0, 330.0), (270.0, 430.0), (390.0, 430.0), (390.0, 330.0), (310.0, 330.0), (310.0, 390.0), (350.0, 390.0), (350.0, 370.0), (330.0, 370.0), (330.0, 350.0), (370.0, 350.0), (370.0, 410.0), (290.0, 410.0), (290.0, 330.0)]) polyline2 = goocanvas.Polyline(parent=root, close_path=True, line_width=1.0, points=points, fill_color="tan", stroke_color="black") self.setup_item_signals(polyline2)
def __init__(self, rootitem, game, x, y, planet_instance): self.game = game self.planet_instance = planet_instance self.height = 60 self.button_width = 20 self.x = x self.y = y self.rootitem = goocanvas.Group(parent=rootitem) line = goocanvas.Polyline(parent=self.rootitem, points=goocanvas.Points([ (x, y + self.button_width / 2.0), (x, y + self.button_width / 2.0 + self.height) ]), stroke_color="grey", width=2.0) # This is the relative position of the scale from 0 to 1 # 0 is the bottom self.scale_value = 0.5 slider_y = y + self.height / 2.0 self.sliding_bar( goocanvas.Points([(x - 5, slider_y), (x + 5, slider_y)])) self.button(self.x, self.y, self.button_width, '+', 0.1) self.button(self.x, self.y + self.height, self.button_width, '-', -0.1) self.planet_instance.set_scale(self.scale_value)
def setup_lines(self, root): self.polish_diamond(root) self.make_hilbert(root) ''' Arrow tests ''' p = goocanvas.Points([(340.0, 170.0), (340.0, 230.0), (390.0, 230.0), (390.0, 170.0)]) polyline1 = goocanvas.Polyline(parent=root, points=p, close_path=False, stroke_color="midnightblue", line_width=3.0, start_arrow=True, end_arrow=True, arrow_tip_length=3.0, arrow_length=4.0, arrow_width=3.5) self.setup_item_signals(polyline1) p = goocanvas.Points([(356.0, 180.0), (374.0, 220.0)]) polyline2 = goocanvas.Polyline(parent=root, points=p, close_path=False, stroke_color="blue", line_width=1.0, start_arrow=True, end_arrow=True, arrow_tip_length=5.0, arrow_length=6.0, arrow_width=6.5) self.setup_item_signals(polyline2) p = goocanvas.Points([(356.0, 220.0), (374.0, 180.0)]) polyline3 = goocanvas.Polyline(parent=root, points=p, close_path=False, stroke_color="blue", line_width=1.0, start_arrow=True, end_arrow=True, arrow_tip_length=5.0, arrow_length=6.0, arrow_width=6.5) self.setup_item_signals(polyline3) ''' Test polyline without any coords. ''' polyline4 = goocanvas.Polyline(parent=root) self.setup_item_signals(polyline4) ''' Test polyline with 1 coord and arrows. ''' p = goocanvas.Points([ (356.0, 220.0), ]) polyline5 = goocanvas.Polyline(parent=root, points=p, start_arrow=True, end_arrow=True) self.setup_item_signals(polyline5)
def calculate(self): if self.done: return False if self.game.board_paused: return True (x, y) = self.rootitem.get_canvas().\ convert_from_item_space( self.tux_spaceship, self.tux_spaceship.props.x, self.tux_spaceship.props.y) dist_planet_left = abs(x - self.planet_left.x) dist_planet_right = abs(self.planet_right.x - x) self.move += ((self.planet_right.scale / dist_planet_right**2) - (self.planet_left.scale / dist_planet_left**2)) * 200.0 * self.level self.tux_spaceship.translate(self.move, 0) force_l = (self.planet_left.scale / dist_planet_left**2) * 10**5 force_r = (self.planet_right.scale / dist_planet_right**2) * 10**5 # Manage force direction and intensity if force_r > force_l: if force_r < 3: right_force_intensity = force_r * 2 else: right_force_intensity = 6 p = goocanvas.Points([(450, 200), (490, 200)]) self.force_line.set_properties(points=p, line_width=right_force_intensity) else: if force_l < 3: left_force_intensity = force_l * 2 else: left_force_intensity = 6 p = goocanvas.Points([(350, 200), (310, 200)]) self.force_line.set_properties(points=p, line_width=left_force_intensity) self.force_line.translate(self.move, 0) # Manage the crash case if x - self.planet_left.x < 60: self.crash() elif self.planet_right.x - x < 60: self.crash() # Manage the success case self.trip_distance += abs(self.move) if self.trip_distance > 100: # Let's move to the next step in the tutorial self.game.tuto_event() return True
def set_bounds(self, p1, p2): (x1, y1, x2, y2) = self.snap_point_to_grid(p1, p2) points = self.item.get_property("points").coords # Create the new line based on p1 (x1, y1), the reference point if points[0][0] == x1 and points[0][1] == y1: self.item.set_properties(points = goocanvas.Points([(x1 , y1), (x2 , y2)])) elif points[1][0] == x1 and points[1][1] == y1: self.item.set_properties(points = goocanvas.Points([(x1 , y1), (x2 , y2)])) elif points[0][0] == x1 and points[1][1] == y1: self.item.set_properties(points = goocanvas.Points([(x1 , y2), (x2 , y1)])) elif points[1][0] == x1 and points[0][1] == y1: self.item.set_properties(points = goocanvas.Points([(x1 , y2), (x2 , y1)]))
def winner(self, player): self.gamewon = True self.cur_player = 0 # It's a draw, no line to draw if player == 0: gcompris.bonus.display(gcompris.bonus.DRAW, gcompris.bonus.FLOWER) return # Display the winner line self.scores[player - 1] += 1 self.update_scores() points = goocanvas.Points([ (self.winLine[0][0] * (self.boardSize / self.nbColumns) + self.stoneSize / 2, (self.boardSize / self.nbColumns) * (self.nbLines - 1 - self.winLine[0][1]) + self.stoneSize / 2), (self.winLine[1][0] * (self.boardSize / self.nbColumns) + self.stoneSize / 2, (self.boardSize / self.nbColumns) * (self.nbLines - 1 - self.winLine[1][1]) + self.stoneSize / 2) ]) self.redLine = \ goocanvas.Polyline( parent = self.boardItem, stroke_color_rgba=0xFF0000FFL, points = points, line_width = 8, line_cap = cairo.LINE_CAP_ROUND ) if player == 1 or self.mode == 2: gcompris.bonus.display(gcompris.bonus.WIN, gcompris.bonus.FLOWER) elif player == 2: gcompris.bonus.display(gcompris.bonus.LOOSE, gcompris.bonus.FLOWER)
def UpdateTracking(self, newEnd=None): #print 'newEnd=', newEnd p = [] p.append(self.fromPoint) p.append(newEnd) p = goocanvas.Points(p) self.widgets["Line"].set_properties(points=p)
def action(self, objet, target, truc, idpt): """Action to do at each step during normal execution of the game""" if truc.type == gtk.gdk.BUTTON_PRESS: if idpt == ( self.actu + 1 ): #Action to execute if the selected point is the following of previous one xd, yd, xa, ya = self.POINT[(idpt - 1)].x, self.POINT[( idpt - 1)].y, self.POINT[idpt].x, self.POINT[idpt].y item = goocanvas.Polyline(parent=self.ROOT, points=goocanvas.Points([(xd, yd), (xa, ya)]), stroke_color='black', line_cap=cairo.LINE_CAP_ROUND, line_width=1.5) if idpt == 2: # Always raise the first point self.POINT[self.MAX].raise_(None) self.TEXT[self.MAX].raise_(None) self.POINT[idpt].props.visibility = goocanvas.ITEM_INVISIBLE self.TEXT[idpt].props.visibility = goocanvas.ITEM_INVISIBLE if idpt == self.MAX: #Action to execute if all points have been selected in good way gcompris.set_background( self.ROOT, self.data[self.gcomprisBoard.sublevel - 1].img2) self.gamewon = 1 gcompris.bar_hide(True) self.timeout = gobject.timeout_add( 1500, self.lauch_bonus ) # The level is complete -> Bonus display else: #Action to execute if the selected point isn''t the last one of this level #Set color in blue to next point. Too easy ??? #self.POINT[(idpt+1)].set_properties(fill_color_rgba=0x003DF5F0) self.actu = self.actu + 1 #self.actu update to set it at actual value of selected point
def updateEndpoints(self): if self.src and self.sink: b = self.src.socket.get_bounds() start = (b.x1 + b.x2) / 2, (b.y1 + b.y2) / 2 b = self.sink.socket.get_bounds() end = (b.x1 + b.x2) / 2, (b.y1 + b.y2) / 2 self.props.points = goocanvas.Points([start, end])
def __init__(self,satellite_instance, rootitem): self.rootitem = rootitem self.satellite_instance = satellite_instance self.length = 130 self.button_width = 20 line = goocanvas.Polyline( parent = self.rootitem, points = goocanvas.Points( [(650, 500), (780, 500)] ), stroke_color = "grey", width = 2.0) text_speed = goocanvas.Text( parent = rootitem, x = (650 + 780)/2, y = 470, font = gcompris.skin.get_font("gcompris/board/small"), anchor = gtk.ANCHOR_CENTER, alignment = pango.ALIGN_CENTER, fill_color = "white", text = _("Speed")) back = goocanvas.Rect( parent = self.rootitem, radius_x = 6, radius_y = 6, x = 630, y = 460, width = 169, height = 59, stroke_color_rgba = 0xFFFFFFFFL, fill_color_rgba = 0x0000FF44L) slider_x = 650 + self.length / 2.0 self.bar = goocanvas.Polyline( parent = self.rootitem, points = goocanvas.Points([(slider_x, 495), (slider_x, 505)]), stroke_color = "grey", line_width = 5.0) # This is the relative position of the scale from 0 to 1 # 0 is the bottom self.scale_value = 0.5 self.speed_button(650, 500, self.button_width, '-', -0.01) self.speed_button(780, 500, self.button_width, '+', 0.01)
def start(self): self.lost = False gcompris.bar_set_level(self.gcomprisBoard) # Set the buttons we want in the bar gcompris.bar_set(gcompris.BAR_LEVEL) gcompris.bar_location(2, -1, 0.5) # Create our rootitem. We put each canvas item in it so at the end we # only have to kill it. The canvas deletes all the items it contains # automaticaly. self.rootitem = goocanvas.Group(parent = self.gcomprisBoard.canvas.get_root_item()) # Set a background image gcompris.set_background(self.gcomprisBoard.canvas.get_root_item(), 'color_mix/background.jpg') text = goocanvas.Text( parent = self.rootitem, x = 250, y = 80, fill_color = "black", font = gcompris.skin.get_font("gcompris/subtitle"), anchor = gtk.ANCHOR_CENTER, width = 150, alignment = pango.ALIGN_CENTER, text = _("Match the color")) # Set the points for the sliders c_points = goocanvas.Points( [(242, 210), (130, 175)] ) m_points = goocanvas.Points( [(390, 352), (390, 470)] ) y_points = goocanvas.Points( [(548, 208), (665, 175)] ) colors = Colors(self, self.rootitem, self.gcomprisBoard.level, 255) # Pass the points of the buttons and slider for the color tubes color1_tube = Color_tubes(self.rootitem, colors, 'cyan_tube.png', 1, 80, 120, c_points, 242, 210, 130, 175, self.gcomprisBoard.level, -1) color2_tube = Color_tubes(self.rootitem, colors, 'magenta_tube.png', 2, 350, 290, m_points, 390, 352, 390, 470, self.gcomprisBoard.level, -1) color3_tube = Color_tubes(self.rootitem, colors, 'yellow_tube.png', 3, 460, 120, y_points, 548, 208, 665, 175, self.gcomprisBoard.level, -1)
def update_points(self): if self.node2 is None: return pos1_x, pos1_y = self.node1.get_position() pos2_x, pos2_y = self.node2.get_position() points = goocanvas.Points([(pos1_x, pos1_y), (pos2_x, pos2_y)]) self.visible_line.set_property("points", points) self.invisible_line.set_property("points", points)
def set_pos(self, obj, pos): points = [self.__center, pos] self.arrow.props.points = goocanvas.Points(points) for pad in self.__prev_pads: pad.unhilight() self.__prev_pads = self.__pads_under_point(pos) for pad in self.__prev_pads: if pad.canLink(self._view): pad.hilight()
def test_polyline_points_property(self): p = goocanvas.Points ([(340.0, 170.0), (340.0, 230.0), (390.0, 230.0), (390.0, 170.0)]) item = self.make_polyline_item(points=p) pr = item.props.points self.failUnlessEqual(p.coords[0], pr.coords[0]) self.failUnlessEqual(p.coords[1], pr.coords[1]) self.failUnlessEqual(p.coords[2], pr.coords[2]) self.failUnlessEqual(p.coords[3], pr.coords[3])
def draw(self, cr): p_points = goocanvas.Points(self.points) line = goocanvas.Polyline( parent=cr.get_root_item(), points=p_points, close_path=True, line_width=self.pen.linewidth, stroke_color=self.pen.color.to_rgb_hex(), )
def update_link_indicator(item, target, event, canvas, widget): """Internal callback to an experimental feature""" if widget.get_data("linking"): start = widget.get_data("link_start") if start: end = event_coords(canvas, event) arrow = widget.get_data("link_arrow") points = goocanvas.Points([start, end]) arrow.props.points = points return True return False
def update_points(self): """! Update points function. @param self The object pointer. @return none """ if self.node2 is None: return pos1_x, pos1_y = self.node1.get_position() pos2_x, pos2_y = self.node2.get_position() points = goocanvas.Points([(pos1_x, pos1_y), (pos2_x, pos2_y)]) self.visible_line.set_property("points", points) self.invisible_line.set_property("points", points)
def draw_line(self, x, y, destx, desty, color): line =goocanvas.Polyline(parent = self.rootitem, points = goocanvas.Points([(x, y), (destx, desty)]), stroke_color = color, line_cap = cairo.LINE_CAP_ROUND, line_width = 4.0) self.drawitems.append(line) #to be able to draw by clicking on the new line line.connect("button_press_event", self.draw_item_event) line.connect("button_release_event", self.draw_item_event) line.connect("motion_notify_event", self.draw_item_event) return line
def process_motion(self, x, y, time): dx = x - self.item_orig_x dy = y - self.item_orig_y dt = time - self.prev_time if self.tool == 'circle': self.item.props.radius_x = abs(dx) self.item.props.radius_y = abs(dy) elif self.tool == 'rect': if dx < 0: self.item.props.x = x #self.item_orig_x = x if dy < 0: self.item.props.y = y #self.item_orig_y = y self.item.props.width = abs(dx) self.item.props.height = abs(dy) elif self.tool == 'pencil': #XXX: This is pretty ugly - we should try some curve fitting stuff dist = abs(math.sqrt(dx * dx + dy * dy)) self.line_points.append((x, y)) if dist > 10 or dt > 10: self.item.props.points = goocanvas.Points(self.line_points) self.item_orig_x = x self.item_orig_y = y elif self.tool == 'poly': #XXX: This is pretty ugly - we should try some curve fitting stuff dist = abs(math.sqrt(dx * dx + dy * dy)) self.line_points.append((x, y)) if dist > 10 or dt > 10: self.item.props.points = goocanvas.Points(self.line_points) self.item_orig_x = x self.item_orig_y = y elif self.tool == 'eraser': self.item = self.get_item_at(x, y, True) else: pass self.prev_time = time
def draw(self, cr): p_points = goocanvas.Points(self.points) polyline = goocanvas.Polyline( parent=cr.get_root_item(), points=p_points, close_path=True, stroke_color=self.pen.color.to_rgb_hex(), ) if self.filled: polyline.props.fill_color = self.pen.fill_color.to_rgb_hex() self.polyline = polyline
def link_objects(canvas, a, b): """Link canvas items a, b with goocanvas.Polyline arrow. If a or b move, the endpoints of the arrow are updated""" a.set_data("linked", b) b.set_data("linked", a) arrow = make_item(link_arrow) arrow.props.points = goocanvas.Points([center(a), center(b)]) canvas.get_root_item().add_child(arrow) a.set_data("link_arrow", arrow) b.set_data("link_arrow", arrow) pos_change(a, update_link_start) pos_change(b, update_link_end) return False
def __init__(self, anim, x, y, color_fill, color_stroke, line_width): AnimItem.__init__(self, anim) x, y = self.snap_to_grid(x, y) self.item = \ goocanvas.Polyline( parent = self.rootitem, stroke_color_rgba = color_stroke, points = goocanvas.Points([(x , y), (x , y)]), line_width = line_width, line_cap = cairo.LINE_CAP_ROUND) AnimItem.init_item(self)
def create_item(self, x, y): self.item_id = str(uuid.uuid4()) self.item_orig_x = x self.item_orig_y = y self.item_width = DEFAULT_WIDTH self.item_height = DEFAULT_HEIGHT if self.tool == 'circle': self.item = goocanvas.Ellipse(parent=self._root, center_x=x, \ center_y=y, radius_x = DEFAULT_WIDTH/2, \ radius_y = DEFAULT_HEIGHT/2, title=self.item_id, \ fill_color_rgba = self._fill_color, \ stroke_color_rgba = self._stroke_color) elif self.tool == 'rect': self.item = goocanvas.Rect(parent=self._root, x=x, y=y, \ width=DEFAULT_WIDTH, height=DEFAULT_HEIGHT, \ fill_color_rgba = self._fill_color, \ stroke_color_rgba = self._stroke_color, title=self.item_id) elif self.tool == 'pencil': self.line_points = [] #Reset self.line_points.append((x, y)) self.item = goocanvas.Polyline(parent=self._root, \ points=goocanvas.Points(self.line_points), \ stroke_color_rgba = self._stroke_color, title=self.item_id) elif self.tool == 'poly': self.line_points = [] #Reset self.line_points.append((x, y)) self.item = goocanvas.Polyline(parent=self._root, \ points=goocanvas.Points(self.line_points), \ stroke_color_rgba = self._stroke_color, \ fill_color_rgba = self._fill_color, title=self.item_id) elif self.tool == 'eraser': self.item = self.get_item_at(x, y, True) else: pass
def ruler_item_event(self, widget, target, event=None): (x, y)= self.gcomprisBoard.canvas.\ convert_from_item_space(widget, event.x, event.y) if event.type == gtk.gdk.BUTTON_PRESS: if event.button == 1: self.pos_x = x self.pos_y = y self.ruleritem = goocanvas.Polyline( parent=self.rootitem, points=goocanvas.Points([(self.pos_x, self.pos_y), (x, y)]), stroke_color_rgba=0xFF0000FFL, line_width=2.0) return True if event.type == gtk.gdk.MOTION_NOTIFY: if event.state & gtk.gdk.BUTTON1_MASK: # Calc the angle and distance and display them in the status bar distance = math.sqrt((self.pos_x - x) * (self.pos_x - x) + (self.pos_y - y) * (self.pos_y - y)) distance = int(distance / self.sea_ratio) angle = math.atan2(abs(self.pos_x - x), abs(self.pos_y - y)) angle = int(angle * 180 / math.pi) angle = abs(angle - 90) self.statusitem.props.text = \ _("Distance:") + " " + str(distance) + " " + _("Angle:") + " " + str(angle) self.ruleritem.props.points = \ goocanvas.Points([(self.pos_x, self.pos_y), (x, y)]) if event.type == gtk.gdk.BUTTON_RELEASE: if event.button == 1: self.ruleritem.remove() self.statusitem.props.text = "" return True return False
def UpdateConnector(self): self.fromPoint = self.ParentDiagram.m_oBlocks[ self.fromBlock].GetOutputPos( self.fromBlockOut ) #pegando o ponto verdadeiro de onde sai o conector self.toPoint = self.ParentDiagram.m_oBlocks[self.toBlock].GetInputPos( self.toBlockIn) #pegando o ponto verdadeiro de onde sai o conector p = [] p.append(self.fromPoint) p.append(self.toPoint) p = goocanvas.Points(p) self.widgets["Line"].set_properties(points=p)
def paint_hex(self, x, y, color=0x0099FFCCL): ax = 30+self.sqrt3*self.r*x ay = 30+1.5*self.r*y if y&1 : ax+=self.sqrt3/2*self.r pts = [] for i in range (len(self.cx)): pts.append ((ax+self.cx [i], ay+self.cy [i])) s = goocanvas.Polyline (parent = self.rootitem, points = goocanvas.Points(pts), close_path = True, stroke_color = "black", fill_color_rgba = color, line_width = 2.5) return s
def create_demo_table(root, x, y, width, height): table = goocanvas.Table(parent=root, row_spacing=4.0, column_spacing=4.0, width=width, height=height) table.translate(x, y) square = goocanvas.Rect(parent=table, x=0.0, y=0.0, width=50.0, height=50.0, fill_color="red") table.set_child_properties(square, row=0, column=0, x_shrink=True) square.set_data("id", "Red square") square.connect("button_press_event", on_button_press) circle = goocanvas.Ellipse(parent=table, center_x=0, center_y=0, radius_x=25, radius_y=25, fill_color="blue") table.set_child_properties(circle, row=0, column=1, x_shrink=True) circle.set_data("id", "Blue circle") circle.connect("button_press_event", on_button_press) p = goocanvas.Points([(25, 0), (0, 50), (50, 50)]) triangle = goocanvas.Polyline(parent=table, close_path=True, points=p, fill_color="yellow") table.set_child_properties(triangle, row=0, column=2, x_shrink=True) triangle.set_data("id", "Yellow triangle") triangle.connect("button_press_event", on_button_press)
def make_hilbert(self, root): SCALE = 7 hilbert = "urdrrulurulldluuruluurdrurddldrrruluurdrurddldrddlulldrdldrrurd" points = [ (340, 290), ] count = 0 for letter in hilbert: if letter == 'u': p = points[count][0] p1 = points[count][1] - SCALE points.append(tuple([p, p1])) if letter == 'd': p = points[count][0] p1 = points[count][1] + SCALE points.append(tuple([p, p1])) if letter == 'l': p = points[count][0] - SCALE p1 = points[count][1] points.append(tuple([p, p1])) if letter == 'r': p = points[count][0] + SCALE p1 = points[count][1] points.append(tuple([p, p1])) count += 1 points = goocanvas.Points(points) pattern = self.create_stipple("red") item = goocanvas.Polyline(parent=root, close_path=False, points=points, line_width=4.0, stroke_pattern=pattern, line_cap=cairo.LINE_CAP_SQUARE, line_join=cairo.LINE_JOIN_MITER) self.setup_item_signals(item)
def line(p1, p2): goocanvas.Polyline(parent=self.blobCanvasGroup, points=goocanvas.Points([p1, p2]), line_width=2, stroke_color='black', end_arrow=True) p1 = Vec2(*p1) p2 = Vec2(*p2) v = p1 - p2 ang = positiveAngle(-1 * atan2(v.getX(), v.getY()), pi) where = (p1 + p2).__div__(2.0) # truediv bug direction = where - center direction.normalize() where = where + direction * 10 goocanvas.Text(parent=self.blobCanvasGroup, x=where.getX(), y=where.getY(), anchor=gtk.ANCHOR_CENTER, fill_color="#cc4400", font="Sans 6", text="%d" % degrees(ang)).raise_(None)