def __init__(self, flask, bundle_id, activity_id, verbose_messages):
gtk.Window.__init__(self)
self.props.type_hint = gtk.gdk.WINDOW_TYPE_HINT_NORMAL
self.props.decorated = False
canvas = hippo.Canvas()
canvas.modify_bg(gtk.STATE_NORMAL, style.COLOR_WHITE.get_gdk_color())
self.add(canvas)
canvas.show()
box = hippo.CanvasBox(
padding=style.GRID_CELL_SIZE * 2,
spacing=style.GRID_CELL_SIZE)
canvas.set_root(box)
header = hippo.CanvasBox()
box.append(header, hippo.PACK_EXPAND)
self._footer = Probe(flask, verbose_messages)
self._footer.connect('stop',
lambda sender: self.emit('stop'))
box.append(self._footer, hippo.PACK_EXPAND)
flask.connect('finished',
lambda sender: self._footer.switch_to_complete())
flask.connect('cancelled', self.__cancelled_cb)
self.connect('realize', self.__realize_cb, bundle_id, activity_id)
def build_canvas(self):
"""Construct the PyGame or PyGameCairo canvas for drawing"""
assert self.game_handler or self.game_name, 'You must specify a game_handler or game_name on your Activity (%r)' % (
self.game_handler or self.game_name)
if self.pygame_mode != 'Cairo':
self._pgc = self.PYGAME_CANVAS_CLASS(*self.game_size)
self.set_canvas(self._pgc)
self._pgc.grab_focus()
self._pgc.connect_game(self.game_handler or self.game_name)
gtk.gdk.threads_init()
return self._pgc
else:
import hippo
self._drawarea = gtk.DrawingArea()
canvas = hippo.Canvas()
canvas.grab_focus()
self.set_canvas(canvas)
self.show_all()
import pygamecairo
pygamecairo.install()
pygamecairo.display.init(canvas)
app = self.game_handler or self.game_name
if ':' not in app:
app += ':main'
mod_name, fn_name = app.split(':')
mod = __import__(mod_name, globals(), locals(), [])
fn = getattr(mod, fn_name)
fn()
def build_canvas( self ):
"""Construct the Pygame or PygameCairo canvas for drawing"""
assert self.game_handler or self.game_name, 'You must specify a game_handler or game_name on your Activity (%r)'%(
self.game_handler or self.game_name
)
if self.pygame_mode != 'Cairo':
size = max(gtk.gdk.screen_width(), gtk.gdk.screen_height())
self._pgc = self.PYGAME_CANVAS_CLASS(*(size, size))
self.set_canvas(self._pgc)
self._pgc.grab_focus()
self._pgc.connect_game(self.game_handler or self.game_name)
# XXX Bad coder, do not hide in a widely subclassed operation
# map signal does not appear to show up on socket instances
gtk.gdk.threads_init()
return self._pgc
else:
import hippo
self._drawarea = gtk.DrawingArea()
canvas = hippo.Canvas()
canvas.grab_focus()
self.set_canvas(canvas)
self.show_all()
import pygamecairo
pygamecairo.install()
pygamecairo.display.init(canvas)
app = self.game_handler or self.game_name
if ':' not in app:
app += ':main'
mod_name, fn_name = app.split(':')
mod = __import__(mod_name, globals(), locals(), [])
fn = getattr(mod, fn_name)
fn()
def make_root(self):
conversation = hippo.CanvasBox(spacing=0,
background_color=COLOR_WHITE.get_int())
self.conversation = conversation
entry = gtk.Entry()
entry.modify_bg(gtk.STATE_INSENSITIVE, COLOR_WHITE.get_gdk_color())
entry.modify_base(gtk.STATE_INSENSITIVE, COLOR_WHITE.get_gdk_color())
entry.set_sensitive(False)
entry.connect('activate', self.entry_activate_cb)
self.entry = entry
hbox = gtk.HBox()
hbox.add(entry)
sw = hippo.CanvasScrollbars()
sw.set_policy(hippo.ORIENTATION_HORIZONTAL, hippo.SCROLLBAR_NEVER)
sw.set_root(conversation)
self.scrolled_window = sw
vadj = self.scrolled_window.props.widget.get_vadjustment()
vadj.connect('changed', self.rescroll)
vadj.connect('value-changed', self.scroll_value_changed_cb)
canvas = hippo.Canvas()
canvas.set_root(sw)
box = gtk.VBox(homogeneous=False)
box.pack_start(hbox, expand=False)
box.pack_start(canvas)
return box
def __init__(self):
self._entries_div = hippo.CanvasBox()
# props not set properly in constructor
self._entries_div.props.background_color=theme.COLOR_PAGE.get_int()
self._entries_div.props.spacing=style.DEFAULT_SPACING
self._entries_div.props.padding=10
self._entries_div.props.orientation=hippo.ORIENTATION_VERTICAL
# Munge it all up into something we can stick into a gtk.ScrolledWindow
canvas = hippo.Canvas()
canvas.set_root(self._entries_div)
canvas.show()
hbox = gtk.HBox()
hbox.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS)
hbox.pack_start(canvas)
hbox.show()
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(hbox)
viewport.show()
scroller.add(viewport)
scroller.show()
hippo.CanvasWidget.__init__(self,
widget=scroller,
padding=0,
spacing=0,
border=1,
border_color=theme.COLOR_DARK_GREEN.get_int())
def _show_message(self, message, show_clear_query=False):
canvas = hippo.Canvas()
self.remove(self.child)
self.add(canvas)
canvas.show()
box = hippo.CanvasBox(orientation=hippo.ORIENTATION_VERTICAL,
background_color=style.COLOR_WHITE.get_int(),
yalign=hippo.ALIGNMENT_CENTER,
spacing=style.DEFAULT_SPACING,
padding_bottom=style.GRID_CELL_SIZE)
canvas.set_root(box)
icon = CanvasIcon(size=style.LARGE_ICON_SIZE,
icon_name='activity-journal',
stroke_color=style.COLOR_BUTTON_GREY.get_svg(),
fill_color=style.COLOR_TRANSPARENT.get_svg())
box.append(icon)
text = hippo.CanvasText(text=message,
xalign=hippo.ALIGNMENT_CENTER,
font_desc=style.FONT_BOLD.get_pango_desc(),
color=style.COLOR_BUTTON_GREY.get_int())
box.append(text)
if show_clear_query:
button = gtk.Button(label=_('Clear search'))
button.connect('clicked', self.__clear_button_clicked_cb)
button.props.image = Icon(icon_name='dialog-cancel',
icon_size=gtk.ICON_SIZE_BUTTON)
canvas_button = hippo.CanvasWidget(widget=button,
xalign=hippo.ALIGNMENT_CENTER)
box.append(canvas_button)
def __init__(self, handle):
super(PyGameActivity, self).__init__(handle)
self.set_title(self.game_title)
toolbar = activity.ActivityToolbar(self)
toolbar.show()
self.set_toolbox(toolbar)
def shared_cb(*args, **kwargs):
mesh.activity_shared(self)
def joined_cb(*args, **kwargs):
mesh.activity_joined(self)
self.connect("shared", shared_cb)
self.connect("joined", joined_cb)
if self.get_shared():
# if set at this point, it means we've already joined (i.e.,
# launched from Neighborhood)
joined_cb()
toolbar.title.unset_flags(gtk.CAN_FOCUS)
assert self.game_handler or self.game_name, 'You must specify a handler module (%r)' % (
self.game_handler or self.game_name)
if self.pygame_mode != 'Cairo':
self._pgc = PyGameCanvas(*self.game_size)
self.set_canvas(self._pgc)
self._pgc.grab_focus()
self._pgc.connect_game(self.game_handler or self.game_name)
gtk.gdk.threads_init()
else:
self._drawarea = gtk.DrawingArea()
canvas = hippo.Canvas()
canvas.grab_focus()
self.set_canvas(canvas)
self.show_all()
import pygamecairo
pygamecairo.install()
pygamecairo.display.init(canvas)
app = self.game_handler or self.game_name
if ':' not in app:
app += ':main'
mod_name, fn_name = app.split(':')
mod = __import__(mod_name, globals(), locals(), [])
fn = getattr(mod, fn_name)
fn()
def __init__(self, **kwargs):
gobject.GObject.__init__(self, **kwargs)
separator = hippo.Canvas()
box = hippo.CanvasBox(border_color=0xffffffff,
background_color=0xffffffff,
box_height=1,
border_bottom=1)
separator.set_root(box)
self.pack_start(separator, False)
hbox = gtk.HBox()
self.pack_start(hbox)
scroll_left = _TrayScrollButton('go-left', _PREVIOUS_PAGE)
scroll_left_event = gtk.EventBox()
scroll_left_event.add(scroll_left)
scroll_left_event.set_size_request(55, -1)
hbox.pack_start(scroll_left_event, False)
self._viewport = _TrayViewport(gtk.ORIENTATION_HORIZONTAL)
hbox.pack_start(self._viewport)
self._viewport.show()
scroll_right = _TrayScrollButton('go-right', _NEXT_PAGE)
scroll_right_event = gtk.EventBox()
scroll_right_event.add(scroll_right)
scroll_right_event.set_size_request(55, -1)
hbox.pack_start(scroll_right_event, False)
scroll_left.set_focus_on_click(False)
scroll_left_event.modify_bg(
gtk.STATE_NORMAL,
sugar.graphics.style.COLOR_TOOLBAR_GREY.get_gdk_color())
scroll_left.modify_bg(
gtk.STATE_ACTIVE,
sugar.graphics.style.COLOR_BUTTON_GREY.get_gdk_color())
scroll_right.set_focus_on_click(False)
scroll_right_event.modify_bg(
gtk.STATE_NORMAL,
sugar.graphics.style.COLOR_TOOLBAR_GREY.get_gdk_color())
scroll_right.modify_bg(
gtk.STATE_ACTIVE,
sugar.graphics.style.COLOR_BUTTON_GREY.get_gdk_color())
scroll_left.viewport = self._viewport
scroll_right.viewport = self._viewport
self.connect_after("size-allocate", self._sizeAllocateCb)
def __init__(self):
logging.debug('STARTUP: Loading the mesh view')
gobject.GObject.__init__(self)
self.wireless_networks = {}
self._adhoc_manager = None
self._adhoc_networks = []
self._model = neighborhood.get_model()
self._buddies = {}
self._activities = {}
self._mesh = []
self._buddy_to_activity = {}
self._suspended = True
self._query = ''
self._owner_icon = None
self._toolbar = MeshToolbar()
self._toolbar.connect('query-changed', self._toolbar_query_changed_cb)
self.pack_start(self._toolbar, expand=False)
self._toolbar.show()
canvas = hippo.Canvas()
self.add(canvas)
canvas.show()
self._layout_box = hippo.CanvasBox( \
background_color=style.COLOR_WHITE.get_int())
canvas.set_root(self._layout_box)
self._layout = SpreadLayout()
self._layout_box.set_layout(self._layout)
for buddy_model in self._model.get_buddies():
self._add_buddy(buddy_model)
self._model.connect('buddy-added', self._buddy_added_cb)
self._model.connect('buddy-removed', self._buddy_removed_cb)
for activity_model in self._model.get_activities():
self._add_activity(activity_model)
self._model.connect('activity-added', self._activity_added_cb)
self._model.connect('activity-removed', self._activity_removed_cb)
netmgr_observer = NetworkManagerObserver(self)
netmgr_observer.listen()
def __init__(self, activity, bundle_path):
gtk.Window.__init__(self)
self._bundle_path = bundle_path
self._favorite_icon = None
self._title = None
self._description = None
self._tags = None
accel_group = gtk.AccelGroup()
self.set_data('sugar-accel-group', accel_group)
self.add_accel_group(accel_group)
self.set_border_width(style.LINE_WIDTH)
offset = style.GRID_CELL_SIZE
width = gtk.gdk.screen_width() - offset * 2
height = gtk.gdk.screen_height() - offset * 2
self.set_size_request(width, height)
self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.set_decorated(False)
self.set_resizable(False)
self.set_modal(True)
self.connect('realize', self.__realize_cb)
self._activity = activity
vbox = gtk.VBox()
self.add(vbox)
vbox.show()
toolbar = NamingToolbar()
toolbar.connect('keep-clicked', self.__keep_cb)
vbox.pack_start(toolbar, False)
toolbar.show()
canvas = hippo.Canvas()
self._root = hippo.CanvasBox()
self._root.props.background_color = style.COLOR_WHITE.get_int()
canvas.set_root(self._root)
vbox.pack_start(canvas)
canvas.show()
body = self._create_body()
self._root.append(body, hippo.PACK_EXPAND)
widget = self._title.get_property('widget')
widget.grab_focus()
def __init__(self, **kwargs):
self._metadata = None
self._expanded_entry = None
canvas = hippo.Canvas()
self._root = hippo.CanvasBox()
self._root.props.background_color = style.COLOR_PANEL_GREY.get_int()
canvas.set_root(self._root)
back_bar = BackBar()
back_bar.connect('button-release-event',
self.__back_bar_release_event_cb)
self._root.append(back_bar)
gobject.GObject.__init__(self, **kwargs)
self.pack_start(canvas)
canvas.show()
def do_size_allocate(self, alloc):
gtk.HBox.do_size_allocate(self, alloc)
if self._cell_numbers:
rows, columns = self._cell_numbers
elif self._cell_sizes:
columns = max(1, alloc.width / max(1, self._cell_sizes[0]))
rows = max(1, alloc.height / max(1, self._cell_sizes[1]))
if not self._table or columns != self._columns or rows != self._rows:
logging.debug('resize TableView to %s:%s' % (rows, columns))
if self._table:
self.table_box.remove(self._table)
self._table = gtk.Table()
self._table.resize(rows, columns)
self._cells = []
self._columns = columns
self._rows = rows
for y in range(rows):
self._cells.append(columns * [None])
for x in range(columns):
canvas = hippo.Canvas()
canvas.show()
canvas.modify_bg(
gtk.STATE_NORMAL,
style.COLOR_TEXT_FIELD_GREY.get_gdk_color())
canvas.set_size_request(alloc.width / columns,
alloc.height / rows)
sel_box = CanvasRoundBox()
sel_box.props.border_color = \
style.COLOR_TEXT_FIELD_GREY.get_int()
canvas.set_root(sel_box)
if self._hover_selection:
canvas.connect('enter-notify-event',
self._cell_enter_cb, sel_box, y, x)
canvas.connect('leave-notify-event',
self._cell_leave_cb, sel_box, y, x)
cell = self._cell_class()
sel_box.append(cell, hippo.PACK_EXPAND)
canvas.connect('button-release-event',
self._cell_release_cb, cell)
self._table.attach(canvas, x, x + 1, y, y + 1,
gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 0, 0)
self._cells[y][x] = (canvas, cell)
self._setup_adj()
self._fillin(None)
self._table.show_all()
self.table_box.add(self._table)
else:
for y in range(rows):
for x in range(columns):
self._cells[y][x][0].set_size_request(
alloc.width / columns, alloc.height / rows)
import hippo
import gtk
import gobject
from sugar.graphics.icon import CanvasIcon
from sugar.graphics.roundbox import CanvasRoundBox
import common
test = common.Test()
canvas = hippo.Canvas()
test.pack_start(canvas)
canvas.show()
scrollbars = hippo.CanvasScrollbars()
canvas.set_root(scrollbars)
box = hippo.CanvasBox(padding=10, spacing=10)
scrollbars.set_root(box)
def idle_cb():
global countdown
for i in range(0, 100):
entry = hippo.CanvasBox(border=2,
border_color=0x000000ff,
orientation=hippo.ORIENTATION_HORIZONTAL,
padding=10,
spacing=10)
