def __createFrame(self):
line = GooCanvas.CanvasRect(fill_color = self.IMAGE_FRAME_COLOR, line_width = 0)
line.props.x = self.image.props.x + self.image.props.width
line.props.y = self.image.props.y
line.props.width = self.IMAGE_FRAME_THICKNESS
line.props.height = self.image.props.height + self.IMAGE_FRAME_THICKNESS
self.frame.append(line)
line = GooCanvas.CanvasRect(fill_color = self.IMAGE_FRAME_COLOR,
line_width = 0)
line.props.x = self.image.props.x
line.props.y = self.image.props.y + self.image.props.height
line.props.width = self.image.props.width + 1
line.props.height = self.IMAGE_FRAME_THICKNESS
self.frame.append(line)
def populate_invoices(self):
c = DB.cursor()
root = self.canvas.get_root_item()
previous_position = 25.0
c.execute(
"SELECT "
"'Invoice '||id::text||' '||format_date(dated_for)||' '||amount_due::money, "
"amount_due::float, "
"id "
"FROM invoices "
"WHERE (canceled, posted, customer_id) = (False, True, %s) "
"ORDER BY dated_for", (self.customer_id, ))
for row in c.fetchall():
amount = row[1]
parent1 = GooCanvas.CanvasGroup(parent=root)
GooCanvas.CanvasRect(parent=parent1,
x=50,
y=previous_position,
width=300,
height=amount,
stroke_color="black")
t = GooCanvas.CanvasText(parent=parent1,
text=row[0],
x=340,
y=previous_position + (amount / 2),
anchor=GooCanvas.CanvasAnchorType.EAST)
t.connect("button-release-event", self.invoice_clicked, row[2])
previous_position += amount
self.canvas.set_size_request(800, previous_position + 100)
c.close()
def __init__(self, tbox, x, y):
super(Rectangle, self).__init__(tbox)
self.origin = x, y
self.cuadranteNegX = False
self.cuadranteNegY = False
self.marker1 = Marker(self.tbox.layer,
x,
y,
color="Red",
callback=self.moveto)
self.rect = GooCanvas.CanvasRect( # TODO
parent=tbox.layer,
x=x,
y=y,
width=0,
height=0,
fill_color_rgba=self.fill_color,
stroke_color_rgba=self.stroke_color,
line_width=self.line_width)
self.id_release = tbox.layer.connect("button-release-event",
self.button_released)
self.id_motion = tbox.layer.connect("motion-notify-event",
self.button_moved)
def populate_payments (self):
c = self.db.cursor()
root = self.canvas.get_root_item()
previous_position = 25.0
c.execute("SELECT "
"'Payment '||payment_info(id)||' '||format_date(date_inserted)||' '||amount::money, "
"amount::float, "
"id "
"FROM payments_incoming "
"WHERE customer_id = %s "
"ORDER BY date_inserted", (self.customer_id,))
for row in c.fetchall():
amount = row[1]
parent1 = GooCanvas.CanvasGroup(parent = root)
GooCanvas.CanvasRect (parent = parent1,
x=350,
y = previous_position ,
width=400,
height=amount,
stroke_color="black")
t = GooCanvas.CanvasText (parent = parent1,
text = row[0],
x=360,
y=previous_position + (amount / 2),
anchor = GooCanvas.CanvasAnchorType.WEST)
t.connect("button-release-event", self.po_clicked, row[2])
previous_position += amount
if previous_position + 100 > self.canvas.get_size_request().height:
self.canvas.set_size_request(800, previous_position)
def __start_select(self):
if self.select_rect is None:
self.select_rect = GooCanvas.CanvasRect(
parent=self.get_root_item(),
x=self.last_clicked_point[0],
y=self.last_clicked_point[1],
width=0,
height=0,
stroke_color="black",
fill_color=None,
line_dash=GooCanvas.CanvasLineDash.newv((4.0, 2.0)))
def _BbRect(self):
self.SetBackColor()
#w1 = GooCanvas.CanvasPolyline(points=GooCanvas.CanvasPoints(pf), fill_color_rgba=ColorFromList(self.m_oBackColor), line_width=1)
w1 = GooCanvas.CanvasRect(width=self.width,
height=self.height,
fill_color_rgba=ColorFromList(
self.m_oBackColor),
line_width=1,
radius_x=self.m_nRadius,
radius_y=self.m_nRadius)
self.wGroup.add_child(w1, -1)
self.widgets["Rect"] = w1
def test_GooCanvas(self):
"""Just draw a rectangle in a canvas"""
canvas = goo.Canvas()
#self.vbox.add(canvas)
canvas.set_size_request(300, 300)
root = canvas.get_root_item()
rect = goo.CanvasRect(parent = root,
x = 100,
y = 50,
width = 100,
height = 200,
line_width = 1,
fill_color = 'pale green')
def __update_white_board(self):
width = self.main_window.get_size()[0]
height = self.main_window.get_size()[1]
self.white_board = GooCanvas.CanvasRect(parent=self.get_root_item(),
x=0,
y=0,
width=width,
height=height,
stroke_color="white",
fill_color="white")
self.__draw_grid()
self.white_board.connect("focus-in-event", self.__white_board_event)
def __draw_rect(self):
"""
This method draw a rectangle.
"""
rect = GooCanvas.CanvasRect(parent=self,
x=0,
y=10,
width=self.width,
height=self.height - 15,
radius_x=10,
radius_y=10,
stroke_color="black",
fill_color_rgba=self.get_color(),
tooltip=self.label)
self.__widgets["Rect"] = rect
def __draw_rect(self):
"""
This method draw a rectangle.
"""
rect = GooCanvas.CanvasRect(parent=self,
x=0,
y=0,
width=self.width,
height=self.height,
radius_x=10,
radius_y=10,
stroke_color="black",
fill_color_rgba=self.get_color())
rect.set_property("tooltip", str(self.id))
self.widgets["Rect"] = rect
def __init__(self):
GooCanvas.Canvas.__init__(self)
# canvas size
canvasWidth = 2000
canvasHeight = 1000
self.set_bounds(0, 0, canvasWidth, canvasHeight)
self.lastClickecPt = (None, None)
self.m_fPixels_per_unit = 1.0
self.reset()
self.savedXml = self.ToXml() # capture the current state
self.bIsUndoEnabled = False # undo enabled flag
self.initUndo()
self.show()
# canvas receives events before its children, so we need to use
# a group as root item, so that its receives events after blocks
# and connectors
self.wGroup = GooCanvas.CanvasGroup()
self.get_root_item().add_child(self.wGroup, -1)
self.wGroup.connect("button-press-event", self.group_event)
self.wGroup.connect("button-release-event", self.group_event)
self.wGroup.connect("motion-notify-event", self.group_event)
# add a rectangle as 'group background', else group will not
# receive interior events
self.root_add(
GooCanvas.CanvasRect(
width=canvasWidth,
height=canvasHeight,
pointer_events=GooCanvas.CanvasPointerEvents.ALL,
stroke_color='gray'))
self.m_sFilename = None
self.createWorkingDir()
self.m_sErrorLog = ""
# turn on tooltips
self.set_property('has-tooltip', True)
self.sessionManager = None
def setup_polyline(c):
group = c.get_root_item()
GooCanvas.CanvasRect (parent=group, x=0,y=0,width=600,height=450, line_width=4.0)
GooCanvas.CanvasPolyline.new_line(group, 0, 150, 600, 150, line_width=4.0)
GooCanvas.CanvasPolyline.new_line(group, 0, 300, 600, 300, line_width=4.0)
GooCanvas.CanvasPolyline.new_line(group, 200, 0, 200, 450, line_width=4.0)
GooCanvas.CanvasPolyline.new_line(group, 400, 0, 400, 450, line_width=4.0)
p_points = GooCanvas.CanvasPoints((
(340.0, 170.0),
(340.0, 230.0),
(390.0, 230.0),
(390.0, 170.0)))
GooCanvas.CanvasPolyline (parent=group, close_path=False,
points=p_points,
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)
p_points = GooCanvas.CanvasPoints((
(356.0, 180.0),
(374.0, 220.0)))
GooCanvas.CanvasPolyline (parent=group, close_path=False,
points=p_points,
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.0)
GooCanvas.CanvasPolyline (parent=group, close_path=False,
points=GooCanvas.CanvasPoints(((356.0, 220.0),)),
start_arrow=True,
end_arrow=True)
def main(args):
w = Gtk.Window()
w.connect('destroy', lambda x: Gtk.main_quit())
cv = GooCanvas.Canvas()
cv_root = cv.get_root_item()
rect = GooCanvas.CanvasRect(parent=cv_root,
stroke_color='red',
x=10,
y=20,
width=400,
height=30)
w.add(cv)
w.show_all()
Gtk.main()
return 0
def __init__(self, canvas):
self.canvas = canvas
self.canvas_root = canvas.get_root_item()
self.frame = GooCanvas.CanvasRect(parent=self.canvas_root,
x=-6,
y=-6,
width=12,
height=12,
stroke_color="gray",
line_width=1)
hide_item(self.frame)
self.vel = GooCanvas.CanvasText(parent=self.canvas_root,
x=0,
y=0,
fill_color="blue",
stroke_color="blue",
anchor=GooCanvas.CanvasAnchorType.S)
hide_item(self.vel)
self.rubberband = False
self.rubberband_origin = None
self.rubberband_current = None
def __on_button_press(self, item, target, event):
if event.button == 1 and not self.__cropping_box:
canvas = item.get_canvas()
self.__dragging = True
self.__start_x = event.x
self.__start_y = event.y
self.__rubberband = GooCanvas.CanvasRect(
x=event.x,
y=event.y,
width=0,
height=0,
stroke_color_rgba=0x66CCFF55,
fill_color_rgba=0xFFEECC66,
line_width=2.0)
canvas.get_root_item().add_child(self.__rubberband, next_index())
fleur = Gdk.Cursor(Gdk.CursorType.FLEUR)
canvas.pointer_grab(
item, Gdk.EventMask.POINTER_MOTION_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK, fleur, event.time)
return True
def update_grid(self):
for i in self.grid.items:
i.destroy()
bg = GooCanvas.CanvasRect(parent=self.grid,
x=0,
y=0,
width=self.pattern.get_length() *
self.zoom_in,
height=self.rows * self.row_height,
fill_color="white")
bar_fg = "blue"
beat_fg = "darkgray"
grid_fg = "lightgray"
row_grid_fg = "lightgray"
row_ext_fg = "black"
for i in range(0, self.rows + 1):
color = row_ext_fg if (i == 0 or i == self.rows) else row_grid_fg
GooCanvas.CanvasPath(
parent=self.grid,
data="M %s %s L %s %s" %
(0, i * self.row_height, self.pattern.get_length() *
self.zoom_in, i * self.row_height),
stroke_color=color,
line_width=1)
for i in range(0, self.pattern.get_length() + 1, int(self.grid_unit)):
color = grid_fg
if i % self.pattern.ppqn == 0:
color = beat_fg
if (i % (self.pattern.ppqn * self.pattern.beats)) == 0:
color = bar_fg
GooCanvas.CanvasPath(parent=self.grid,
data="M %s %s L %s %s" %
(i * self.zoom_in, 1, i * self.zoom_in,
self.rows * self.row_height - 1),
stroke_color=color,
line_width=1)
def __init__(self, parent, x, y, w, h, stroke=0x66CCFF55, fill=0xFFEECC66):
self.__dragging = False
self.__drag_x = None
self.__drag_y = None
GooCanvas.CanvasGroup.__init__(self, parent=parent)
self.__rect = GooCanvas.CanvasRect(parent=self,
x=x,
y=y,
width=w,
height=h,
stroke_color_rgba=stroke,
fill_color_rgba=fill,
line_width=2.0)
self.connect("motion_notify_event", self.__on_motion_notify)
self.connect("button_press_event", self.__on_button_press)
self.connect("button_release_event", self.__on_button_release)
self.__resizers = [
UResizer(self, self.__rect, x + w / 2.0, y),
RResizer(self, self.__rect, x + w, y + h / 2.0),
BResizer(self, self.__rect, x + w / 2.0, y + h),
LResizer(self, self.__rect, x, y + h / 2.0),
ULResizer(self, self.__rect, x, y),
URResizer(self, self.__rect, x + w, y),
BRResizer(self, self.__rect, x + w, y + h),
BLResizer(self, self.__rect, x, y + h),
]
self.__resizers[0].set_listeners(
dy_listeners=[self.__resizers[i] for i in (4, 5)],
dy2_listeners=[self.__resizers[i] for i in (1, 3)])
self.__resizers[1].set_listeners(
dx_listeners=[self.__resizers[i] for i in (5, 6)],
dx2_listeners=[self.__resizers[i] for i in (0, 2)])
self.__resizers[2].set_listeners(
dy_listeners=[self.__resizers[i] for i in (6, 7)],
dy2_listeners=[self.__resizers[i] for i in (1, 3)])
self.__resizers[3].set_listeners(
dx_listeners=[self.__resizers[i] for i in (4, 7)],
dx2_listeners=[self.__resizers[i] for i in (0, 2)])
self.__resizers[4].set_listeners(dx_listeners=[self.__resizers[7]],
dx2_listeners=[self.__resizers[2]],
dy_listeners=[self.__resizers[5]],
dy2_listeners=[self.__resizers[1]],
dx2dy_listeners=[self.__resizers[0]],
dxdy2_listeners=[self.__resizers[3]])
self.__resizers[5].set_listeners(dx_listeners=[self.__resizers[6]],
dx2_listeners=[self.__resizers[2]],
dy_listeners=[self.__resizers[4]],
dy2_listeners=[self.__resizers[3]],
dx2dy_listeners=[self.__resizers[0]],
dxdy2_listeners=[self.__resizers[1]])
self.__resizers[6].set_listeners(dx_listeners=[self.__resizers[5]],
dx2_listeners=[self.__resizers[0]],
dy_listeners=[self.__resizers[7]],
dy2_listeners=[self.__resizers[3]],
dx2dy_listeners=[self.__resizers[2]],
dxdy2_listeners=[self.__resizers[1]])
self.__resizers[7].set_listeners(dx_listeners=[self.__resizers[4]],
dx2_listeners=[self.__resizers[0]],
dy_listeners=[self.__resizers[6]],
dy2_listeners=[self.__resizers[1]],
dx2dy_listeners=[self.__resizers[2]],
dxdy2_listeners=[self.__resizers[3]])
def setup_scalability(c):
N_COLS = 5
N_ROWS = 20
PADDING = 10
vbox = Gtk.VBox (homogeneous=False, spacing=4)
vbox.set_border_width (4)
vbox.show()
table = Gtk.Table (2, 2, False)
table.set_row_spacings (4)
table.set_col_spacings (4)
vbox.pack_start (table, True, True, 0)
table.show ()
frame = Gtk.Frame ()
frame.set_shadow_type (Gtk.ShadowType.IN)
table.attach (frame,
0, 1, 0, 1,
Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK,
Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK,
0, 0);
frame.show()
if 1:
pb = GdkPixbuf.Pixbuf.new_from_file("../../demo/toroid.png")
width = pb.get_width()
height = pb.get_height()
else:
pb = None
width = 37
height = 19
c.set_bounds (
0, 0,
N_COLS * (width + PADDING),
N_ROWS * (height + PADDING))
c.show ();
scrolled_win = Gtk.ScrolledWindow ()
scrolled_win.show()
frame.add(scrolled_win)
scrolled_win.add(c)
root = c.get_root_item()
for i in range(N_COLS):
for j in range(N_ROWS):
if pb:
GooCanvas.CanvasImage (
parent=root,
pixbuf=pb,
x=i * (width + PADDING),
y=j * (height + PADDING))
else:
item = GooCanvas.CanvasRect (
parent=root,
x=i * (width + PADDING),
y=j * (height + PADDING),
width=width,
height=height)
item.props.fill_color = {True:"mediumseagreen",False:"steelblue"}[j % 2 == 0]
return vbox