def construct(self, posx, posy):
# fretboard
for string in xrange(len(self.strings)):
semitone = self.strings[string]
for fret in xrange(self.frets + 1):
x = posx + fret * self.rectwidth
y = posy + self.rectheight * string
rect = Semitone(self.control,
semitone=semitone + fret,
method=self.method,
parent=self,
x=x,
y=y,
width=self.rectwidth,
height=self.rectheight)
rect.connect("button_press_event", self.press_semitone, string,
fret)
rect.connect("button_release_event", self.release_semitone)
y = posy + self.rectheight * (len(self.strings) + 0.5)
for fret in self.markers:
x = posx + self.rectwidth * (fret + 0.5)
circle = goocanvas.Ellipse(parent=self,
center_x=x,
center_y=y,
radius_x=self.markers_radius,
radius_y=self.markers_radius)
circle.props.fill_color_rgba = 0x333333ff
circle.props.line_width = 0
if self.capo:
x = posx + self.rectwidth * (self.capo + .3)
y1 = posy
y2 = posy + self.rectheight * len(self.strings)
width = self.rectwidth / 3
goocanvas.polyline_new_line(self,
x,
y1,
x,
y2,
width=line_width,
stroke_color_rgba=0x660000cc,
pointer_events=0)
# draw nut
x = posx + self.rectwidth * .3
y1 = posy
y2 = posy + self.rectheight * len(self.strings)
width = self.rectwidth / 3
goocanvas.polyline_new_line(self,
x,
y1,
x,
y2,
line_width=width,
stroke_color_rgba=0xcc0000cc,
pointer_events=0)
def setup_static_items(self, canvas):
static_root = canvas.get_static_root_item()
""" All static items in one place in the canvas should be placed in the
same group. """
group = goocanvas.Group(parent=static_root)
item = goocanvas.polyline_new_line(
group,
40.0,
410.0,
40.0,
330.0,
stroke_color="midnightblue",
line_width=3.0,
end_arrow=True,
arrow_tip_length=3.0,
arrow_length=4.0,
arrow_width=3.5,
)
self.setup_item_signals(item)
item = goocanvas.polyline_new_line(group, 32.0, 370.0, 48.0, 370.0, stroke_color="midnightblue", line_width=3.0)
self.setup_item_signals(item)
item = goocanvas.Text(parent=group, text="N", x=40, y=320, width=-1, anchor=gtk.ANCHOR_S, font="Sans 12")
self.setup_item_signals(item)
def add_skyline(self, lines):
"""Adds a skyline to the current canvas, in a new color.
The canvas will be rescaled, if necessary, to make room for the
new skyline."""
# Flip vertically, because goocanvas thinks higher numbers are
# further down, while lilypond thinks they're further up.
lines = [(x1, -y1, x2, -y2) for (x1, y1, x2, y2) in lines]
color = self.colors[self.cur_color_index]
self.cur_color_index = (self.cur_color_index + 1) % len(self.colors)
# Update the bounding box of the skylines.
x_vals = [s[0] for s in lines] + [s[2] for s in lines]
y_vals = [s[1] for s in lines] + [s[3] for s in lines]
self.x_min = min([self.x_min] + x_vals)
self.x_max = max([self.x_max] + x_vals)
self.y_min = min([self.y_min] + y_vals)
self.y_max = max([self.y_max] + y_vals)
# Add the lines to the canvas.
root = self.get_root_item()
for (x1, y1, x2, y2) in lines:
goocanvas.polyline_new_line(root,
x1,
y1,
x2,
y2,
stroke_color=color,
line_width=0.05)
self.rescale(self.get_allocation())
def __init__(self, **args):
GooCanvas.__init__(self, **args)
# infinite world should replace scroll_region
self.set_properties(
automatic_bounds=True,
integer_layout=False,
bounds_from_origin=False,
bounds_padding=100,
)
self.root = self.get_root_item()
self.root.set_properties(fill_color="white")
polyline_new_line(self.root, -5, 0, 5, 0, stroke_color="red")
polyline_new_line(self.root, 0, -5, 0, 5, stroke_color="red")
self.zoom = False
# GooCanvas will transmit all keyboard events to
# its parent unless one of its item has focus.
self.parent.connect_object("key_press_event", Canvas.eventhandler,
self)
self.parent.connect_object("key_release_event", Canvas.eventhandler,
self)
self.connect("event", Canvas.eventhandler)
def add_skyline (self, lines):
"""Adds a skyline to the current canvas, in a new color.
The canvas will be rescaled, if necessary, to make room for the
new skyline."""
# Flip vertically, because goocanvas thinks higher numbers are
# further down, while lilypond thinks they're further up.
lines = [(x1, -y1, x2, -y2) for (x1, y1, x2, y2) in lines]
color = self.colors[self.cur_color_index]
self.cur_color_index = (self.cur_color_index + 1) % len (self.colors)
# Update the bounding box of the skylines.
x_vals = [s[0] for s in lines] + [s[2] for s in lines]
y_vals = [s[1] for s in lines] + [s[3] for s in lines]
self.x_min = min ([self.x_min] + x_vals)
self.x_max = max ([self.x_max] + x_vals)
self.y_min = min ([self.y_min] + y_vals)
self.y_max = max ([self.y_max] + y_vals)
# Add the lines to the canvas.
root = self.get_root_item ()
for (x1, y1, x2, y2) in lines:
goocanvas.polyline_new_line (root, x1, y1, x2, y2,
stroke_color=color,
line_width=0.05)
self.rescale (self.get_allocation ())
def _drawLines(self, x, y, length):
'''
draw one set of five staff lines
'''
x1 = x
lineLength = length
x2 = x1 + lineLength
y = y
yWidth = self.staffLineSpacing
t = self.staffLineThickness
goocanvas.polyline_new_line(self.rootitem, x1, y, x2, y,
stroke_color="black", line_width=t)
y += yWidth
goocanvas.polyline_new_line(self.rootitem, x1, y, x2, y,
stroke_color="black", line_width=t)
y += yWidth
goocanvas.polyline_new_line(self.rootitem, x1, y, x2, y,
stroke_color="black", line_width=t)
y += yWidth
goocanvas.polyline_new_line(self.rootitem, x1, y, x2, y,
stroke_color="black", line_width=t)
y += yWidth
goocanvas.polyline_new_line(self.rootitem, x1, y, x2, y,
stroke_color="black", line_width=t)
self.bottomYLine = y
def construct(self, posx, posy):
# fretboard
for string in xrange(len(self.strings)):
semitone = self.strings[string]
for fret in xrange(self.frets+1):
x = posx + fret*self.rectwidth
y = posy + self.rectheight*string
rect = Semitone(self.control, semitone=semitone+fret, method=self.method,
parent=self, x=x, y=y, width=self.rectwidth, height=self.rectheight)
rect.connect("button_press_event", self.press_semitone, string, fret)
rect.connect("button_release_event", self.release_semitone)
y = posy + self.rectheight*(len(self.strings) + 0.5)
for fret in self.markers:
x = posx + self.rectwidth*(fret+0.5)
circle = goocanvas.Ellipse(parent=self, center_x=x, center_y=y, radius_x=self.markers_radius, radius_y=self.markers_radius)
circle.props.fill_color_rgba=0x333333ff
circle.props.line_width=0
if self.capo:
x = posx + self.rectwidth*(self.capo+.3)
y1 = posy
y2 = posy + self.rectheight*len(self.strings)
width = self.rectwidth/3
goocanvas.polyline_new_line(self, x,y1,x,y2, width=line_width, stroke_color_rgba=0x660000cc, pointer_events=0)
# draw nut
x = posx + self.rectwidth*.3
y1 = posy
y2 = posy + self.rectheight*len(self.strings)
width = self.rectwidth/3
goocanvas.polyline_new_line(self, x,y1,x,y2, line_width=width, stroke_color_rgba=0xcc0000cc, pointer_events=0)
def setup_divisions (self, root):
group = goocanvas.Group (parent = root)
group.translate (2, 2)
item = goocanvas.Rect (parent = group,
x = 0,
y = 0,
width = 600,
height = 450,
line_width = 4.0)
item = goocanvas.polyline_new_line (group, 0, 150, 600, 150,
line_width = 4.0)
item = goocanvas.polyline_new_line (group, 0, 300, 600, 300,
line_width = 4.0)
item = goocanvas.polyline_new_line (group, 200, 0, 200, 450,
line_width = 4.0)
item = goocanvas.polyline_new_line (group, 400, 0, 400, 450,
line_width = 4.0)
self.setup_heading(group, "Rectangles", 0)
self.setup_heading(group, "Ellipses", 1)
self.setup_heading(group, "Texts", 2)
self.setup_heading(group, "Images", 3)
self.setup_heading(group, "Lines", 4)
self.setup_heading(group, "Polygons", 7)
def __init__(self,tabulature,tuning,**kwargs): kwargs["parent"] = tabulature goocanvas.Group.__init__(self,**kwargs) self.tuning = tuning self.tabulature = tabulature height = tabulature.timeline.get_pts(tabulature.timeline.project.pipeline.duration) goocanvas.polyline_new_line(self, 0,0, 0,height) self.markers = []
def __init__(self, tabulature, tuning, **kwargs):
kwargs["parent"] = tabulature
goocanvas.Group.__init__(self, **kwargs)
self.tuning = tuning
self.tabulature = tabulature
height = tabulature.timeline.get_pts(
tabulature.timeline.project.pipeline.duration)
goocanvas.polyline_new_line(self, 0, 0, 0, height)
self.markers = []
def draw_line(self, start, end, color = [255,255,255]):
import threading
print 'TurtleDrawerGTK.draw_line in thread "%s" from %s to %s' % (threading.current_thread().name, start, end)
start = self.__convert_position(start)
end = self.__convert_position(end)
goocanvas.polyline_new_line(
self.root,
*start+end
)
return False # should raise NotImplementedError()
def _drawEndBars(self):
'''
draw the vertical end bars on each line, two for line 3
'''
if self.numStaves >= 1:
goocanvas.polyline_new_line(self.rootitem, self.endx,
self.line1Y - 1, self.endx, self.line1Y + 53,
stroke_color="black", line_width=3.0)
if self.numStaves >= 2:
goocanvas.polyline_new_line(self.rootitem, self.endx,
self.line2Y - 1, self.endx, self.line2Y + 53,
stroke_color="black", line_width=3.0)
if self.numStaves >= 3:
#doublebar
goocanvas.polyline_new_line(self.rootitem, self.endx - 7,
self.line3Y - 1, self.endx - 7, self.line3Y + 53,
stroke_color="black", line_width=3.0)
#final barline, dark
goocanvas.polyline_new_line(self.rootitem, self.endx,
self.line3Y - 1, self.endx, self.line3Y + 53,
stroke_color="black", line_width=4.0)
def main(argv):
window = gtk.Window()
window.set_default_size(640, 600)
window.show_all()
window.connect("delete_event", on_delete_event)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.set_shadow_type(gtk.SHADOW_IN)
scrolled_win.show()
window.add(scrolled_win)
canvas = goocanvas.Canvas()
canvas.set_size_request(600, 450)
canvas.set_bounds(0, 0, 1000, 1000)
canvas.show()
scrolled_win.add(canvas)
canvas.connect("button_press_event", on_arrow_button_press)
root = canvas.get_root_item()
## Add a few simple items.
global item
item = goocanvas.polyline_new_line(root, 300, 200, 200, 200)
item.props.end_arrow = True
item.props.line_width = 10
gtk.main()
def main(argv):
window = gtk.Window()
window.set_default_size(640, 600)
window.show_all()
window.connect("delete_event", on_delete_event)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.set_shadow_type(gtk.SHADOW_IN)
scrolled_win.show()
window.add(scrolled_win)
canvas = goocanvas.Canvas()
canvas.set_size_request(600, 450)
canvas.set_bounds(0, 0, 1000, 1000)
canvas.show()
scrolled_win.add(canvas)
canvas.connect("button_press_event", on_arrow_button_press)
root = canvas.get_root_item()
## Add a few simple items.
global item
item = goocanvas.polyline_new_line(root, 300, 200, 200, 200)
item.props.end_arrow = True
item.props.line_width = 10
gtk.main()
def _draw_one_marker(self,t,label):
x = self.screen_from_world((t,0))[0]
ht = self.size.height
if not 0 <= x < self.size.width:
return
x = max(5, x) # cheat left-edge stuff onscreen
goocanvas.polyline_new_line(self.curveGroup,
x, ht,
x, ht - 20,
line_width=.5,
stroke_color='gray70')
goocanvas.Text(parent=self.curveGroup,
fill_color="white",
anchor=gtk.ANCHOR_SOUTH,
font="ubuntu 7",
x=x+3, y=ht-20,
text=label)
def setup_divisions(self, root):
group = goocanvas.Group(parent=root)
group.translate(2, 2)
item = goocanvas.Rect(parent=group,
x=0,
y=0,
width=600,
height=450,
line_width=4.0)
item = goocanvas.polyline_new_line(group,
0,
150,
600,
150,
line_width=4.0)
item = goocanvas.polyline_new_line(group,
0,
300,
600,
300,
line_width=4.0)
item = goocanvas.polyline_new_line(group,
200,
0,
200,
450,
line_width=4.0)
item = goocanvas.polyline_new_line(group,
400,
0,
400,
450,
line_width=4.0)
self.setup_heading(group, "Rectangles", 0)
self.setup_heading(group, "Ellipses", 1)
self.setup_heading(group, "Texts", 2)
self.setup_heading(group, "Images", 3)
self.setup_heading(group, "Lines", 4)
self.setup_heading(group, "Polygons", 7)
def create_canvas_model():
canvas_model = goocanvas.CanvasModelSimple()
root = canvas_model.get_root_item()
## Add a few simple items.
global item
item = goocanvas.polyline_new_line(root, 300, 200, 200, 200)
item.props.end_arrow = True
item.props.line_width = 10
return canvas_model
def __init__(self,rhythm,weight=1,**kwargs): kwargs["parent"] = rhythm if "time" in kwargs: kwargs["y"] = rhythm.timeline.get_pts(kwargs["time"]) del kwargs["time"] goocanvas.Group.__init__(self,**kwargs) self.rhythm = rhythm self.line = goocanvas.polyline_new_line(self, 0, 0, 10, 0) self.time_sum = self.get_time()*weight self.weight = weight self.text = goocanvas.Text(parent=self, text=str(self.weight), x=10, anchor=gtk.ANCHOR_W)
def setup_static_items(self, canvas):
static_root = canvas.get_static_root_item()
''' All static items in one place in the canvas should be placed in the
same group. '''
group = goocanvas.Group(parent=static_root)
item = goocanvas.polyline_new_line(group,
40.0,
410.0,
40.0,
330.0,
stroke_color="midnightblue",
line_width=3.0,
end_arrow=True,
arrow_tip_length=3.0,
arrow_length=4.0,
arrow_width=3.5)
self.setup_item_signals(item)
item = goocanvas.polyline_new_line(group,
32.0,
370.0,
48.0,
370.0,
stroke_color="midnightblue",
line_width=3.0)
self.setup_item_signals(item)
item = goocanvas.Text(parent=group,
text="N",
x=40,
y=320,
width=-1,
anchor=gtk.ANCHOR_S,
font="Sans 12")
self.setup_item_signals(item)
def __init__(self, rhythm, weight=1, **kwargs):
kwargs["parent"] = rhythm
if "time" in kwargs:
kwargs["y"] = rhythm.timeline.get_pts(kwargs["time"])
del kwargs["time"]
goocanvas.Group.__init__(self, **kwargs)
self.rhythm = rhythm
self.line = goocanvas.polyline_new_line(self, 0, 0, 10, 0)
self.time_sum = self.get_time() * weight
self.weight = weight
self.text = goocanvas.Text(parent=self,
text=str(self.weight),
x=10,
anchor=gtk.ANCHOR_W)
def polish_diamond(self, root):
group = goocanvas.Group(parent=root, line_width=1.0, line_cap=cairo.LINE_CAP_ROUND)
group.translate(270, 230)
self.setup_item_signals(group)
i = 0
while i < self.VERTICES:
a = 2.0 * math.pi * i / self.VERTICES
x1 = self.RADIUS * math.cos(a)
y1 = self.RADIUS * math.sin(a)
i += 1
j = i + 1
while j < self.VERTICES:
a = 2.0 * math.pi * j / self.VERTICES
x2 = self.RADIUS * math.cos(a)
y2 = self.RADIUS * math.sin(a)
item = goocanvas.polyline_new_line(group, x1, y1, x2, y2)
j += 1
def __init__(self, project, strings, **kwargs):
goocanvas.Canvas.__gobject_init__(self)
self.project = project
if "scale" in kwargs: self.scale = kwargs["scale"]
else: self.scale = 100
if "width" in kwargs: self.width = kwargs["width"]
else: self.width = 500
# mode
self.mode = MODE_DEFAULT
# configure canvas
height = self.get_pts(self.project.pipeline.duration)
self.set_bounds(0, 0, self.width, height)
self.set_size_request(self.width, int(height))
self.connect("button_press_event", self.canvas_button_press)
root = self.get_root_item()
# add ruler
self.ruler = Ruler(self)
# add rhythm marker space
self.rhythm = Rhythm(self)
self.rhythm.props.x = self.ruler.get_width()
# position marker
self.posmarker = goocanvas.polyline_new_line(root, 0, 0, self.width, 0)
# items
self.annotations = []
self.markers = []
self.tabulature = Tabulature(self, strings)
self.tabulature.props.x = self.rhythm.props.x + self.rhythm.get_width(
) + 20
# setup space
self.space = goocanvas.Group(parent=root)
self.space.props.x = self.tabulature.props.x + self.tabulature.get_width(
) + 20
def polish_diamond(self, root):
group = goocanvas.Group(parent=root,
line_width=1.0,
line_cap=cairo.LINE_CAP_ROUND)
group.translate(270, 230)
self.setup_item_signals(group)
i = 0
while i < self.VERTICES:
a = 2.0 * math.pi * i / self.VERTICES
x1 = self.RADIUS * math.cos(a)
y1 = self.RADIUS * math.sin(a)
i += 1
j = i + 1
while j < self.VERTICES:
a = 2.0 * math.pi * j / self.VERTICES
x2 = self.RADIUS * math.cos(a)
y2 = self.RADIUS * math.sin(a)
item = goocanvas.polyline_new_line(group, x1, y1, x2, y2)
j += 1
def __init__(self, project, strings, **kwargs):
goocanvas.Canvas.__gobject_init__(self)
self.project = project
if "scale" in kwargs: self.scale = kwargs["scale"]
else: self.scale = 100
if "width" in kwargs: self.width = kwargs["width"]
else: self.width = 500
# mode
self.mode = MODE_DEFAULT
# configure canvas
height = self.get_pts(self.project.pipeline.duration)
self.set_bounds(0,0,self.width,height)
self.set_size_request(self.width,int(height))
self.connect("button_press_event",self.canvas_button_press)
root = self.get_root_item()
# add ruler
self.ruler = Ruler(self)
# add rhythm marker space
self.rhythm = Rhythm(self)
self.rhythm.props.x = self.ruler.get_width()
# position marker
self.posmarker = goocanvas.polyline_new_line(root, 0, 0, self.width, 0)
# items
self.annotations = []
self.markers = []
self.tabulature = Tabulature(self, strings)
self.tabulature.props.x = self.rhythm.props.x + self.rhythm.get_width() + 20
# setup space
self.space = goocanvas.Group(parent=root)
self.space.props.x = self.tabulature.props.x + self.tabulature.get_width()+20
def create_canvas_arrowhead ():
v = gtk.VBox(False, 4)
v.set_border_width(4)
l = gtk.Label("This demo allows you to edit arrowhead shapes. Drag the little boxes\n"
"to change the shape of the line and its arrowhead. You can see the\n"
"arrows at their normal scale on the right hand side of the window.")
a = gtk.Alignment(0.5, 0.5, 0.0, 0.0)
v.pack_start(l, False, False, 0)
v.pack_start(a, True, True, 0)
f = gtk.Frame()
f.set_shadow_type(gtk.SHADOW_IN)
a.add(f)
canvas = goocanvas.Canvas()
canvas.set_size_request(500, 350)
canvas.set_bounds(0, 0, 500, 350)
f.add(canvas)
root = canvas.get_root_item()
canvas.set_data("width", DEFAULT_WIDTH)
canvas.set_data("shape_a", DEFAULT_SHAPE_A)
canvas.set_data("shape_b", DEFAULT_SHAPE_B)
canvas.set_data("shape_c", DEFAULT_SHAPE_C)
p1 = goocanvas.polyline_new_line(root, LEFT, MIDDLE, RIGHT, MIDDLE,
stroke_color="mediumseagreen",
end_arrow=True)
canvas.set_data("big_arrow", p1)
p2 = goocanvas.Polyline(parent = root,
close_path=True,
stroke_color="black",
line_width=2.0,
line_cap=cairo.LINE_CAP_ROUND,
line_join=cairo.LINE_JOIN_ROUND)
canvas.set_data("outline", p2)
create_drag_box (canvas, root, "width_drag_box")
create_drag_box (canvas, root, "shape_a_drag_box")
create_drag_box (canvas, root, "shape_b_c_drag_box")
create_dimension (canvas, root, "width_arrow", "width_text", gtk.ANCHOR_E)
create_dimension (canvas, root, "shape_a_arrow", "shape_a_text", gtk.ANCHOR_N)
create_dimension (canvas, root, "shape_b_arrow", "shape_b_text", gtk.ANCHOR_N)
create_dimension (canvas, root, "shape_c_arrow", "shape_c_text", gtk.ANCHOR_W)
create_info (canvas, root, "width_info", LEFT, 260)
create_info (canvas, root, "shape_a_info", LEFT, 280)
create_info (canvas, root, "shape_b_info", LEFT, 300)
create_info (canvas, root, "shape_c_info", LEFT, 320)
p_div = goocanvas.polyline_new_line(root, RIGHT + 50, 0, RIGHT + 50, 1000,
fill_color="black", line_width=2.0)
create_sample_arrow (canvas, root, "sample_1",
RIGHT + 100, 30, RIGHT + 100, MIDDLE - 30)
create_sample_arrow (canvas, root, "sample_2",
RIGHT + 70, MIDDLE, RIGHT + 130, MIDDLE)
create_sample_arrow (canvas, root, "sample_3",
RIGHT + 70, MIDDLE + 30, RIGHT + 130, MIDDLE + 120)
set_arrow_shape(canvas)
return v
def create_sample_arrow(canvas, root, sample_name, x1, x2, y1, y2):
p4 = goocanvas.polyline_new_line(root, x1, x2, y1, y2,
start_arrow=True,
end_arrow=True)
canvas.set_data(sample_name, p4)
def on_print(self, data=None, filename=None):
canvas=goocanvas.Canvas()
rt=canvas.get_root_item()
'''pix = gtk.gdk.pixbuf_new_from_file("logo.jpg")
logo=pix.scale_simple(50,70,gtk.gdk.INTERP_BILINEAR)
item = goocanvas.Image (parent=rt,pixbuf = pix,x=0,y=0)'''
self.text = goocanvas.Text(text='Retrival Tool',
x=30,y=0,font="Sans 12")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Registry',x=0,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Location',x=70,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Box',x=120,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Reference',x=150,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='subject',x=240,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Volume',x=420,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Opened',x=460,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Retn. ',x=520,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Action',x=550,y=30,font="Sans 6")
rt.add_child(self.text)
self.pi = goocanvas.polyline_new_line(rt,0,44,600,44,
line_width=1,end_arrow=False)
#n=str(os.sep.join((os.path.expanduser('~'),'Desktop')))+str('/')+filename
surface = cairo.PDFSurface (filename, 9 * 72, 10 * 72)
dat=data
l=32
for i in range(len(dat)):
l=l+15
if l<650:
self.text = goocanvas.Text(text=str((dat[i][0])[:13]),x=0,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=str((dat[i][1])[:8]),x=70,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=(str(dat[i][3])[:5]),x=120,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=(str(dat[i][4])[:15]),x=150,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=str((dat[i][5])[:37]),x=240,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=str((dat[i][6])[:5]),x=420,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=str((dat[i][7])[:10]),x=460,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=str((dat[i][8])[:4]),x=520,y=l,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text=str((dat[i][9])[:12]),x=550,y=l,font="Sans 6")
rt.add_child(self.text)
elif l>=650 or i==(len(dat)-1):
cr = cairo.Context (surface)
# Place it in the middle of our 9x10 page.
cr.translate (20, 0)
canvas.render (cr, None, 1.0)
cr.show_page ()
l=30
canvas.destroy()
canvas=goocanvas.Canvas()
rt=canvas.get_root_item()
self.text = goocanvas.Text(text='Generate 4 Generations',
x=5,y=5,font="Sans 18")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Woman',x=0,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Product',x=70,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Number',x=150,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Done',x=180,y=30,font="Sans 6")
rt.add_child(self.text)
self.text = goocanvas.Text(text='Date',x=210,y=30,font="Sans 6")
rt.add_child(self.text)
self.pi = goocanvas.polyline_new_line(rt,0,40,275,40,
line_width=1,end_arrow=False)
cr = cairo.Context (surface)
cr.translate (10, 0)
canvas.render (cr, None, 1.0)
cr.show_page ()
canvas.connect("item_view_created", on_item_view_created)
canvas.set_model(canvas_model)
canvas.set_size_request(500, 350)
canvas.set_bounds(0, 0, 500, 350)
f.add(canvas)
root = canvas_model.get_root_item()
canvas.set_data("width", DEFAULT_WIDTH)
canvas.set_data("shape_a", DEFAULT_SHAPE_A)
canvas.set_data("shape_b", DEFAULT_SHAPE_B)
canvas.set_data("shape_c", DEFAULT_SHAPE_C)
p1 = goocanvas.polyline_new_line(root, LEFT, MIDDLE, RIGHT, MIDDLE,
stroke_color="mediumseagreen",
end_arrow=True)
canvas.set_data("big_arrow", p1)
p2 = goocanvas.Polyline(close_path=True, stroke_color="black",
line_width=2.0,
line_cap=cairo.LINE_CAP_ROUND,
line_join=cairo.LINE_JOIN_ROUND)
root.add_child(p2)
canvas.set_data("outline", p2)
create_drag_box (canvas, root, "width_drag_box")
create_drag_box (canvas, root, "shape_a_drag_box")
create_drag_box (canvas, root, "shape_b_c_drag_box")
def _drawMidLine(self, x, y):
if self.staffType == 'trebleClef' and self.noteName == 'C' or \
self.staffType == 'bassClef' and self.noteName == 'C2' or \
self.staffType == 'trebleClef' and self.noteName == 'C sharp':
self.midLine = goocanvas.polyline_new_line(self.rootitem, x - 12, y, x + 12, y ,
stroke_color_rgba=0x121212D0, line_width=1)
