def test_get_set_canvas(self):
c = goocanvas.Canvas()
r = c.get_root_item()
i = self.make_rect_item(parent=r, x=100, y=100, height=100, width=100)
res = i.get_canvas()
self.failUnlessEqual(res, c)
d = goocanvas.Canvas()
f = self.make_rect_item(x=100, y=100, height=100, width=100)
f.set_canvas(d)
res1 = f.get_canvas()
self.failUnlessEqual(res1, d)
def __init__(self, **kwargs):
gtk.Window.__init__(self, **kwargs)
vbox = gtk.VBox()
self.add(vbox)
self.controls = gtk.VBox()
vbox.add(self.controls)
hbox = gtk.HBox()
vbox.add(hbox)
label = gtk.Label("Volume")
hbox.add(label)
self.volume = gtk.Adjustment(0.04, 0.0, 10.0, 0.01)
spinbtn = gtk.SpinButton(self.volume, 0.01, 2)
hbox.add(spinbtn)
self.canvas = goocanvas.Canvas()
self.connect_after("realize", self.set_default_background, self.canvas)
self.canvas.set_property("has-tooltip", True)
vbox.add(self.canvas)
self.connect("delete-event", self.stop_playing)
def create_focus_page():
vbox = gtk.VBox(False, 4)
vbox.set_border_width(4)
label = gtk.Label(
"Odin: brought to you by the Berlin Open Wireless Lab (BOWL)")
vbox.pack_start(label, False, False, 0)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.set_shadow_type(gtk.SHADOW_IN)
vbox.add(scrolled_win)
canvas = goocanvas.Canvas()
canvas.set_flags(gtk.CAN_FOCUS)
canvas.set_size_request(CANVAS_WIDTH, 10000)
canvas.set_bounds(0, 0, CANVAS_WIDTH, 10000)
canvas.props.has_tooltip = False
scrolled_win.add(canvas)
setup_canvas(canvas)
# start canvas update thread
threading.Timer(1.0, update_canvas, [canvas]).start()
return vbox
def create_animation_page():
vbox = gtk.VBox(False, 4)
vbox.set_border_width(4)
hbox = gtk.HBox(False, 4)
vbox.pack_start(hbox, False, False, 0)
w = gtk.Button("Start Animation")
hbox.pack_start(w, False, False, 0)
w.connect(
"clicked",
start_animation_clicked,
)
w = gtk.Button("Stop Animation")
hbox.pack_start(w, False, False, 0)
w.connect(
"clicked",
stop_animation_clicked,
)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.set_shadow_type(gtk.SHADOW_IN)
vbox.add(scrolled_win)
canvas = goocanvas.Canvas()
canvas.set_size_request(600, 450)
canvas.set_bounds(0, 0, 1000, 1000)
scrolled_win.add(canvas)
setup_canvas(canvas)
return vbox
def create_canvas(units, units_name):
vbox = gtk.VBox(False, 4)
vbox.set_border_width(4)
hbox = gtk.HBox(False, 4)
vbox.pack_start(hbox, False, False, 0)
canvas = goocanvas.Canvas()
w = gtk.Label("Zoom:")
hbox.pack_start(w, False, False, 0)
adj = gtk.Adjustment(1.00, 0.05, 100.00, 0.05, 0.50, 0.50)
w = gtk.SpinButton(adj, 0.0, 2)
adj.connect("value_changed", zoom_changed, canvas)
w.set_size_request(50, -1)
hbox.pack_start(w, False, False, 0)
scrolled_win = gtk.ScrolledWindow()
vbox.pack_start(scrolled_win, True, True, 0)
# Create the canvas.
canvas.set_size_request(600, 450)
setup_canvas(canvas, units, units_name)
canvas.set_bounds(0, 0, 1000, 1000)
canvas.props.units = units
canvas.props.anchor = gtk.ANCHOR_CENTER
scrolled_win.add(canvas)
return vbox
def main(argv):
window = gtk.Window()
window.set_default_size(640, 600)
window.show()
window.connect("destroy", lambda w: gtk.main_quit())
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)
root = canvas.get_root_item()
CustomRectItem(x=100, y=100, width=400, height=400,
line_width=10, stroke_color="grey", parent=root)
goocanvas.Text(text="Hello World",
x=300, y=300,
anchor=gtk.ANCHOR_CENTER,
font="Sans 24", parent=root).rotate(45, 300, 300)
canvas.show()
scrolled_win.add(canvas)
gtk.main()
def create_events_page ():
vbox = gtk.VBox (False, 4)
vbox.set_border_width (4)
''' Instructions '''
label = gtk.Label ("Move the mouse over the items to check they receive the right motion events.\nThe first 2 items in each group are 1) invisible and 2) visible but unpainted.")
vbox.pack_start (label, False, False, 0)
''' Frame and canvas '''
alignment = gtk.Alignment (0.5, 0.5, 0.0, 0.0)
vbox.pack_start (alignment, False, False, 0)
frame = gtk.Frame ()
frame.set_shadow_type (gtk.SHADOW_IN)
alignment.add (frame)
canvas = goocanvas.Canvas ()
canvas.set_size_request (600, 450)
canvas.set_bounds (0, 0, 600, 450)
frame.add (canvas)
create_events_area (canvas, 0, goocanvas.EVENTS_NONE, "none");
create_events_area (canvas, 1, goocanvas.EVENTS_VISIBLE_PAINTED, "visible-painted");
create_events_area (canvas, 2, goocanvas.EVENTS_VISIBLE_FILL, "visible-fill");
create_events_area (canvas, 3, goocanvas.EVENTS_VISIBLE_STROKE, "visible-stroke");
create_events_area (canvas, 4, goocanvas.EVENTS_VISIBLE, "visible");
create_events_area (canvas, 5, goocanvas.EVENTS_PAINTED, "painted");
create_events_area (canvas, 6, goocanvas.EVENTS_FILL, "fill");
create_events_area (canvas, 7, goocanvas.EVENTS_STROKE, "stroke");
create_events_area (canvas, 8, goocanvas.EVENTS_ALL, "all");
return vbox
def main():
window = gtk.Window()
window.set_default_size(640, 600)
window.show()
window.connect("destroy", lambda w: gtk.main_quit())
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)
root = canvas.get_root_item()
handle = rsvg.Handle("../images/circle1.svg")
svgitem = CustomSvgItem(x=100, y=100, handle=handle, parent=root)
svgitem.connect("button_press_event", on_press, root)
r = goocanvas.Rect(parent=root, x=10, y=10, width=20, height=20)
r.connect("button_press_event", on_r_press)
r.props.fill_color = 'yellow'
canvas.show()
scrolled_win.add(canvas)
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 test_get_set_child_property(self):
c = goocanvas.Canvas()
r = c.get_root_item()
t = goocanvas.Table(parent=r)
i = self.make_rect_item(parent=t, x=100, y=100, height=100, width=100)
t.set_child_property(i, "bottom_padding", 3)
res = t.get_child_property(i, "bottom_padding")
self.failUnlessEqual(res, 3.0)
def test_get_set_child_properties(self):
c = goocanvas.Canvas()
r = c.get_root_item()
t = goocanvas.Table(parent=r)
i = self.make_rect_item(parent=t, x=100, y=100, height=100, width=100)
t.set_child_properties(i, bottom_padding=3, columns=2, x_align=0.4)
res = t.get_child_properties(i, "bottom_padding", "columns", "x_align")
self.failUnlessEqual(res, (3.0, 2, 0.4))
def test_get_requested_height(self):
c = goocanvas.Canvas()
c.show()
cr = c.create_cairo_context()
r = c.get_root_item()
i = self.make_text_item(parent=r, x=100, y=100, width=100, text="Test")
height = i.get_requested_height(cr, 100)
self.failUnlessEqual(height, 18.625)
def test_get_n_children(self):
c = goocanvas.Canvas()
c.show()
r = c.get_root_item()
i = self.make_rect_item(parent=r, x=100, y=100, height=100, width=100)
i2 = self.make_text_item(parent=r, x=100, y=400)
res = r.get_n_children()
self.failUnlessEqual(res, 2)
def test_get_items_at(self):
c = goocanvas.Canvas()
c.show()
r = c.get_root_item()
i = self.make_rect_item(parent=r, x=100, y=100, height=100, width=100)
cr = c.create_cairo_context()
res = r.get_items_at(150, 150, cr, False, False)
self.failUnlessEqual(res[0], i)
def make_canvas(pipeline, sel_changed_cb):
def element_added(bin, element):
x, y = coords[element]
w = make_element_widget(canvas, element)
set_pos(w, (x, y))
root.add_child(w)
def element_removed(bin, element):
widget = element.get_data("widget")
widget.remove()
def add_element(element, x, y):
el = gst.element_factory_make(element)
el.set_state(pipeline.get_state()[1])
coords[el] = (x, y)
pipeline.add(el)
return True
def dup_element(button):
for obj in canvas.get_data("selected_objects"):
factory = obj.get_data("element").get_factory().get_name()
element = gst.element_factory_make(factory)
coords[element] = point_sum(pos(obj), (30, 100))
pipeline.add(element)
def remove_element(button):
for obj in canvas.get_data("selected_objects"):
pipeline.remove(obj.get_data("element"))
set_selection(canvas, set())
def drag_data_received(w, context, x, y, data, info, time):
context.finish(True, False, time)
add_element(data.data, *canvas.convert_from_pixels(x, y))
def sel_cb(selected, deselected):
for obj in selected:
obj = obj.get_data("box")
obj.props.stroke_color = obj.get_data("selected_color")
for obj in deselected:
obj = obj.get_data("box")
obj.props.stroke_color = obj.get_data("deselected_color")
sel_changed_cb([obj.get_data("element") for obj in selected])
coords = {}
canvas = goocanvas.Canvas()
canvas.set_size_request(*WIN_SIZE)
canvas.drag_dest_set(gtk.DEST_DEFAULT_ALL, target, gtk.gdk.ACTION_COPY)
canvas.connect("drag_data_received", drag_data_received)
manage_selection(canvas, make_item(selection_box), True, sel_cb)
root = canvas.get_root_item()
pipeline.connect("element_added", element_added)
pipeline.connect("element_removed", element_removed)
return canvas, (
("Delete", remove_element, ()),
("Duplicate", dup_element, ()),
)
def test_find_child(self):
c = goocanvas.Canvas()
c.show()
r = c.get_root_item()
i = self.make_rect_item(parent=r, x=100, y=100, height=100, width=100)
t = self.make_text_item(parent=r, x=100, y=100, width=100)
res = r.find_child(t)
self.failUnlessEqual(res, 1)
res = r.find_child(i)
self.failUnlessEqual(res, 0)
def test_get_bounds(self):
c = goocanvas.Canvas()
r = c.get_root_item()
i = self.make_rect_item(parent=r, x=100, y=100, height=100, width=100)
c.show()
res = i.get_bounds()
self.failUnlessEqual(res.x1, 99)
self.failUnlessEqual(res.x2, 201)
self.failUnlessEqual(res.y1, 99)
self.failUnlessEqual(res.y2, 201)
def test_get_requested_area(self):
c = goocanvas.Canvas()
c.show()
cr = c.create_cairo_context()
r = c.get_root_item()
i = self.make_rect_item(parent=r, x=100, y=100, height=100, width=100)
bounds = i.get_requested_area(cr)
self.failUnlessEqual(bounds.x1, 99)
self.failUnlessEqual(bounds.x2, 201)
self.failUnlessEqual(bounds.y1, 99)
self.failUnlessEqual(bounds.y2, 201)
def __init__(self, frame):
self.dragging = False
self.lastPos = (0,0)
self.tool = FITSCanvas.CONTRAST
self.frame = frame
gtk.icon_theme_get_default().append_search_path(os.path.abspath(os.path.dirname(__file__)))
self.window = gtk.ScrolledWindow()
self.window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.canvas = goocanvas.Canvas()
self.canvas.set_property("automatic-bounds", True)
self.builder = gtk.Builder()
self.builder.add_from_file(os.path.join(os.path.dirname(__file__), "canvas.xml"))
self.builder.connect_signals({"contrast_activate_cb": self.contrast_activate_cb,
"zoom_activate_cb": self.zoom_activate_cb,
"pan_activate_cb": self.pan_activate_cb,
"_98_activate_cb": self._98_activate_cb,
"minmax_activate_cb": self.minmax_activate_cb,
"linear_activate_cb": self.linear_activate_cb,
"log_activate_cb": self.log_activate_cb,
"invert_activate_cb": self.invert_activate_cb,
"reset_contrast_activate_cb": self.reset_contrast_activate_cb})
w, h = self.frame.get_image().get_width(), self.frame.get_image().get_height()
self.canvas.set_bounds(0, 0, w, h)
canvasItem = goocanvas.Image(pixbuf=frame.get_pixbuf(), x=0, y=0)
self.canvas.get_root_item().add_child(canvasItem)
self.canvasImage = self.canvas.get_root_item().get_child(0)
# connect canvas events
self.canvas.connect("button-press-event", self.button_press_callback)
self.canvas.connect("button-release-event", self.button_release_callback)
self.canvas.connect("motion-notify-event", self.motion_notify_callback)
# create our accelerator maps
#gtk.accel_map_add_entry("<canvas>/Zoom", ord('z'), 0)
# connect accelerator
#accel_group = self.builder.get_object("canvasAcceleratorGroup")
#accel_group.connect_by_path("<canvas>/Zoom", self.zoom_activate_cb)
#self.window.get_parent().add_accel_group(accel_group)
# go!
self.window.add(self.canvas)
self.window.show_all()
def create_canvas(self, sx, sy):
self.canvas = goocanvas.Canvas()
self.canvas.props.automatic_bounds = True
self.canvas.set_size_request(sx, sy)
self.canvas.set_scale(1)
#self.canvas.connect("size-allocate", self.update_canvas_bounds)
self.canvas.props.background_color_rgb = 0
self.canvas.props.integer_layout = False
self.canvas.update()
self.canvas.connect("button-press-event",
self.canvas_button_press_handler)
self.canvas.connect("motion-notify-event", self.canvas_motion_notify)
self.canvas.connect("button-release-event", self.canvas_button_release)
def create_canvas_scalability ():
vbox = gtk.VBox (False, 4)
vbox.set_border_width (4)
table = gtk.Table (2, 2, False)
table.set_row_spacings (4)
table.set_col_spacings (4)
vbox.pack_start (table, True, True, 0)
frame = gtk.Frame ()
frame.set_shadow_type (gtk.SHADOW_IN)
table.attach (frame,
0, 1,
0, 1,
gtk.EXPAND | gtk.FILL | gtk.SHRINK,
gtk.EXPAND | gtk.FILL | gtk.SHRINK,
0, 0)
''' Create the canvas and board '''
pixbuf = gtk.gdk.pixbuf_new_from_file("../images/toroid.png")
width = pixbuf.get_width () + 3
height = pixbuf.get_height () +1
canvas = goocanvas.Canvas ()
root = canvas.get_root_item ()
canvas.set_size_request (600, 450)
canvas.set_bounds (0, 0,
N_COLS * (width + PADDING),
N_ROWS * (height + PADDING))
scrolled_win = gtk.ScrolledWindow ()
frame.add (scrolled_win)
scrolled_win.add (canvas)
for i in range (N_COLS):
for j in range (N_ROWS):
item = goocanvas.Image (parent =root,
pixbuf = pixbuf,
x = i * (width + PADDING),
y = j * (height + PADDING))
return vbox
def create_clipping_page ():
vbox = gtk.VBox (False, 4)
vbox.set_border_width (4)
scrolled_win = gtk.ScrolledWindow ()
scrolled_win.set_shadow_type (gtk.SHADOW_IN)
vbox.add (scrolled_win)
canvas = goocanvas.Canvas ()
canvas.set_size_request (600, 450)
canvas.set_bounds (0, 0, 1000, 1000)
scrolled_win.add (canvas)
setup_canvas (canvas)
return vbox
def create_canvas ():
global start
canvas = goocanvas.Canvas ()
canvas.set_size_request (600, 450)
start = clock()
setup_canvas (canvas)
print "Create Canvas Time Used: %g" % (clock() - start)
start = clock()
canvas.set_bounds (left_offset, top_offset, left_offset + total_width,
top_offset + total_height)
canvas.show ()
canvas.connect ("expose_event", on_expose_event)
return canvas
def preview_canvas(self):
vbox = gtk.VBox(False, 0)
canvas = goocanvas.Canvas()
canvas.set_size_request(185, 125)
canvas.set_bounds(0, 0, 185, 125)
canvas.show()
root = canvas.get_root_item()
# Create a Linear Patter with cairo
linear = cairo.LinearGradient(60, 0, 60, 120)
linear.add_color_stop_rgba(0.0, 1, 1, 1, 1)
#linear.add_color_stop_rgba(0.25, 0, 1, 0, 0.5)
#linear.add_color_stop_rgba(0.50, 1, 1, 1, 0)
linear.add_color_stop_rgba(0.5, 0, 0, 1, 1)
#linear.add_color_stop_rgba(1.0, 1, 1, 1, 0)
self.press_xy = [0, 0, 20, 20]
# Create a rect to be filled with the linear gradient
item = goocanvas.Rect(
x=0,
y=0,
width=120,
height=120,
line_width=0,
#radius_x=20.0,
#radius_y=10.0,
fill_pattern=linear)
item.connect("button-press-event", self.on_preview_press)
item.connect("button-release-event", self.on_preview_release)
canvas.connect("motion-notify-event", self.on_motion_notify)
item.set_simple_transform(0, 50, 0.5, 0)
root.add_child(item, 0)
vbox.pack_start(canvas, False, True, 1)
self.label_preview = gtk.Label("Preview")
self.label_preview.show()
vbox.pack_start(self.label_preview, False, True, 1)
canvas.connect("motion-notify-event",
self.on_motion_notify) #label_preview
self.sample_gradiant(canvas)
vbox.show()
return vbox
def main(argv):
window = gtk.Window()
window.set_default_size(640, 600)
window.show()
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)
root = goocanvas.GroupModel()
## Add a few simple items.
rect_model = goocanvas.RectModel(x=100,
y=100,
width=400,
height=400,
line_width=10.0,
radius_x=20.0,
radius_y=10.0,
stroke_color="yellow",
fill_color="red")
root.add_child(rect_model, 0)
text_model = goocanvas.TextModel(text="Hello World",
x=300,
y=300,
anchor=gtk.ANCHOR_CENTER,
font="Sans 24")
root.add_child(text_model, 1)
text_model.rotate(45, 300, 300)
canvas.set_root_item_model(root)
rect_item = canvas.get_item(rect_model)
rect_item.connect("button-press-event", on_rect_button_press)
gtk.main()
def create_canvas_table():
vbox = gtk.VBox(False, 4)
vbox.set_border_width(4)
hbox = gtk.HBox(False, 4)
vbox.pack_start(hbox, False, False, 0)
scrolled_win = gtk.ScrolledWindow()
scrolled_win.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(scrolled_win, True, True, 0)
canvas = goocanvas.Canvas()
canvas.flags() & gtk.CAN_FOCUS
canvas.set_size_request(600, 450)
canvas.set_bounds(0, 0, 1000, 2000)
scrolled_win.add(canvas)
root = canvas.get_root_item()
create_demo_table(root, 400, 200, -1, -1)
create_demo_table(root, 400, 260, 100, -1)
create_table(root, -1, -1, 0, 10, 10, 0, 1.0, DEMO_TEXT_ITEM)
create_table(root, -1, -1, 0, 180, 10, 30, 1.0, DEMO_TEXT_ITEM)
create_table(root, -1, -1, 0, 350, 10, 60, 1.0, DEMO_TEXT_ITEM)
create_table(root, -1, -1, 0, 500, 10, 90, 1.0, DEMO_TEXT_ITEM)
table = create_table(root, -1, -1, 0, 30, 150, 0, 1.0, DEMO_TEXT_ITEM)
table.props.width = 300.0
table.props.height = 100.0
create_table(root, -1, -1, 1, 200, 200, 30, 0.8, DEMO_TEXT_ITEM)
table = create_table(root, -1, -1, 0, 10, 700, 0, 1.0, DEMO_WIDGET_ITEM)
table.props.width = 300.0
table.props.height = 200.0
create_width_for_height_table(root, 100, 1000, 200, -1, 0)
create_width_for_height_table(root, 100, 1200, 300, -1, 0)
create_width_for_height_table(root, 500, 1000, 200, -1, 30)
create_width_for_height_table(root, 500, 1200, 300, -1, 30)
return vbox
def __init__(self, account, contact, session, plugin):
self.plugin = plugin
file_path = plugin.local_file_path('whiteboard_widget.ui')
xml = gtk.Builder()
xml.set_translation_domain('gajim_plugins')
xml.add_from_file(file_path)
self.hbox = xml.get_object('whiteboard_hbox')
self.canevas = goocanvas.Canvas()
self.hbox.pack_start(self.canevas)
self.hbox.reorder_child(self.canevas, 0)
self.canevas.set_flags(gtk.CAN_FOCUS)
self.fg_color_select_button = xml.get_object('fg_color_button')
self.root = self.canevas.get_root_item()
self.tool_buttons = []
for tool in ('brush', 'oval', 'line', 'delete'):
self.tool_buttons.append(xml.get_object(tool + '_button'))
xml.get_object('brush_button').set_active(True)
# Events
self.canevas.connect('button-press-event', self.button_press_event)
self.canevas.connect('button-release-event', self.button_release_event)
self.canevas.connect('motion-notify-event', self.motion_notify_event)
self.canevas.connect('item-created', self.item_created)
# Config
self.line_width = 2
xml.get_object('size_scale').set_value(2)
self.color = str(self.fg_color_select_button.get_color())
# SVG Storage
self.image = SVGObject(self.root, session)
xml.connect_signals(self)
# Temporary Variables for items
self.item_temp = None
self.item_temp_coords = (0, 0)
self.item_data = None
# Will be {ID: {type:'element', data:[node, goocanvas]}, ID2: {}} instance
self.recieving = {}
def create_canvas(table, row, text, id):
label = gtk.Label(text)
table.attach(label, 0, 1, row, row + 1, 0, 0, 0, 0)
canvas = goocanvas.Canvas()
canvas.set_size_request(200, 100)
canvas.set_bounds(0, 0, 200, 100)
table.attach(canvas, 1, 2, row, row + 1, 0, 0, 0, 0)
root = canvas.get_root_item()
rect = goocanvas.Rect(parent=root,
x=0,
y=0,
width=200,
height=100,
fill_color="yellow")
view_id = "%s-yellow" % id
rect.set_data("id", view_id)
setup_item_signals(rect)
rect = goocanvas.Rect(parent=root,
x=20,
y=20,
width=60,
height=60,
fill_color="blue")
view_id = "%s-blue" % id
rect.set_data("id", view_id)
setup_item_signals(rect)
rect = goocanvas.Rect(parent=root,
x=120,
y=20,
width=60,
height=60,
fill_color="red")
view_id = "%s-red" % id
rect.set_data("id", view_id)
setup_item_signals(rect)
def create_focus_page ():
vbox = gtk.VBox (False, 4)
vbox.set_border_width (4)
label = gtk.Label ("Use Tab, Shift+Tab or the arrow keys to move the keyboard focus between the canvas items.")
vbox.pack_start (label, False, False, 0)
scrolled_win = gtk.ScrolledWindow ()
scrolled_win.set_shadow_type (gtk.SHADOW_IN)
vbox.add (scrolled_win)
canvas = goocanvas.Canvas ()
canvas.set_flags (gtk.CAN_FOCUS)
canvas.set_size_request (600, 450)
canvas.set_bounds (0, 0, 1000, 1000)
scrolled_win.add (canvas)
setup_canvas (canvas)
return vbox
def main(argv):
window = gtk.Window()
window.set_default_size(640, 600)
window.show()
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)
root = canvas.get_root_item()
url = swfdec.URL(sys.argv[1])
p = swfdec.ui.Player(None)
p.set_url(url)
wdg = swfdec.ui.Widget(player=p)
p.set_playing(True)
## Add a few simple items.
item = goocanvas.Widget(x=100, y=100, height=-1, width=-1, widget=wdg)
root.add_child(item, 0)
wdg.connect("motion-notify-event", on_motion_notify, item)
wdg.connect("button-press-event", on_button_press)
wdg.connect("button-release-event", on_button_release)
gtk.main()
