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)
