def __init__(self, jokebook):
Page.__init__(self, xalign=hippo.ALIGNMENT_CENTER)
preview_box = CanvasListBox()
# cover
cover = self.make_listrow()
cover.props.orientation=hippo.ORIENTATION_VERTICAL
cover.append(hippo.CanvasText(text='"' + (jokebook.title or '')+ '" ' +
_('started by') + ' ' + (jokebook.owner or ''),
xalign=hippo.ALIGNMENT_CENTER,
padding_top=10))
cover.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
cover_picture = self.make_imagebox(jokebook, 'image', 480, 360, False)
cover.append(cover_picture)
cover.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
preview_box.append(cover)
# jokes
for joke in jokebook.jokes:
list_row = self.make_listrow(JokeViewer(joke, jokebook.title))
preview_box.append(list_row)
self.append(preview_box, hippo.PACK_EXPAND)
self.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
button = gtk.Button(_('Edit'))
button.connect('clicked', self.__do_clicked_edit, jokebook)
self.append(hippo.CanvasWidget(widget=theme.theme_widget(button)))
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 __init__(self, joke, jokebook_title=''):
Page.__init__(
self,
spacing=8,
#background_color=theme.COLOR_PAGE.get_int(),
padding=4,
border_color=theme.COLOR_RED.get_int(),
border=0,
xalign=hippo.ALIGNMENT_START,
orientation=hippo.ORIENTATION_HORIZONTAL)
# left column
self.left = hippo.CanvasBox(border=0,
border_color=theme.COLOR_RED.get_int(),
box_width=450,
xalign=hippo.ALIGNMENT_START,
orientation=hippo.ORIENTATION_VERTICAL)
joke_image = self.make_imagebox(joke, 'image', 320, 240, False)
self.left.append(joke_image)
self.left.append(
hippo.CanvasText(text=jokebook_title,
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_DARK_GREEN.get_int()))
self.left.append(
hippo.CanvasText(text=_('Joke') + ' ' + str(joke.id),
xalign=hippo.ALIGNMENT_START))
self.left.append(
hippo.CanvasText(text=_('By') + ' ' + str(joke.joker),
xalign=hippo.ALIGNMENT_START))
# right column
self.right = hippo.CanvasBox(border=0,
border_color=theme.COLOR_RED.get_int(),
box_width=350,
xalign=hippo.ALIGNMENT_START,
orientation=hippo.ORIENTATION_VERTICAL)
self.right.append(
hippo.CanvasText(text=_('Question'),
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_DARK_GREEN.get_int()))
self.right.append(self.make_bodytext(joke.text))
self.right.append(hippo.CanvasBox(box_height=30)) # spacer
self.answer_box = hippo.CanvasBox()
self.answer_box.append(
hippo.CanvasText(text=_('Answer'),
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_DARK_GREEN.get_int()))
self.answer_box.append(self.make_bodytext(joke.answer))
self.right.append(self.answer_box)
self.append(self.left)
self.append(self.right)
def __init__(self, cal, **kwargs):
"""
Constructor.
"""
CanvasTable.__init__(self, **kwargs)
self.cal = cal
self.range = kwargs.get('range')
self.active_range = self.range
self.selected = None
# Create canvas items.
self.scroll = hippo.CanvasScrollbars()
self.hbox_top = hippo.CanvasBox(
orientation=hippo.ORIENTATION_HORIZONTAL)
self.vbox_top = hippo.CanvasBox()
self.day_captions = CanvasTable()
self.timeline = CanvasTimeline(self.cal)
self.padding_left = hippo.CanvasBox()
self.padding_right = hippo.CanvasBox()
self.allday_view = CanvasHEventView(self.cal,
yalign=hippo.ALIGNMENT_FILL)
self.grid = CanvasGrid(self._new_cell)
self.gridbox = hippo.CanvasBox(
orientation=hippo.ORIENTATION_HORIZONTAL)
self.vevent_views = {}
self.hevent_views = {}
self.allocs = {}
self.allocs[self.padding_left] = (0, 0, 0, 0)
self.allocs[self.padding_right] = (0, 0, 0, 0)
self.vbox_top.append(self.day_captions)
self.vbox_top.append(self.allday_view)
self.day_captions.set_homogeneus_columns(True)
self.hbox_top.append(self.padding_left)
self.hbox_top.append(self.vbox_top, hippo.PACK_EXPAND)
self.hbox_top.append(self.padding_right)
self.gridbox.append(self.timeline)
self.gridbox.append(self.grid, hippo.PACK_EXPAND)
self.scroll.set_root(self.gridbox)
self.add(self.hbox_top, 0, 1, 0, 1)
self.add(self.scroll, 0, 1, 1, 2)
self.set_row_expand(1, True)
self.set_column_expand(0, True)
self.allday_view.show_normal = False
self.allday_view.connect('event-clicked', self.on_view_event_clicked)
self.grid.connect('paint', self.on_grid_paint)
self.grid.set_homogeneus_columns(True)
def _create_body(self):
body = hippo.CanvasBox()
body.props.orientation = hippo.ORIENTATION_VERTICAL
body.props.background_color = style.COLOR_WHITE.get_int()
body.props.padding_top = style.DEFAULT_SPACING * 3
header = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
padding=style.DEFAULT_PADDING,
padding_right=style.GRID_CELL_SIZE,
spacing=style.DEFAULT_SPACING)
body.append(header)
descriptions = hippo.CanvasBox(
orientation=hippo.ORIENTATION_HORIZONTAL,
spacing=style.DEFAULT_SPACING * 3,
padding_left=style.GRID_CELL_SIZE,
padding_right=style.GRID_CELL_SIZE,
padding_top=style.DEFAULT_SPACING * 3)
body.append(descriptions, hippo.PACK_EXPAND)
first_column = hippo.CanvasBox(orientation=hippo.ORIENTATION_VERTICAL,
spacing=style.DEFAULT_SPACING)
descriptions.append(first_column)
second_column = hippo.CanvasBox(orientation=hippo.ORIENTATION_VERTICAL,
spacing=style.DEFAULT_SPACING)
descriptions.append(second_column, hippo.PACK_EXPAND)
self._favorite_icon = self._create_favorite_icon()
header.append(self._favorite_icon)
entry_icon = self._create_entry_icon()
header.append(entry_icon)
self._title = self._create_title()
header.append(self._title, hippo.PACK_EXPAND)
if gtk.widget_get_default_direction() == gtk.TEXT_DIR_RTL:
header.reverse()
description_box, self._description = self._create_description()
second_column.append(description_box)
tags_box, self._tags = self._create_tags()
second_column.append(tags_box)
return body
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 __init__(self, jokebook, parent):
Page.__init__(self)
self.__parent = parent
# list of jokes
jokes_div = CanvasListBox()
jokes_div.props.border = 0
for joke in jokebook.jokes:
button = gtk.Button(' ' + _('Delete') + ' ')
button.connect('clicked', self.__do_clicked_delete, jokebook, joke)
list_row = self.make_listrow(JokeEditor(joke), hippo.PACK_EXPAND)
list_row.append(
hippo.CanvasWidget(widget=theme.theme_widget(button),
padding=5), hippo.PACK_END)
jokes_div.append(list_row)
self.append(jokes_div, hippo.PACK_EXPAND)
# new joke button
buttons = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
xalign=hippo.ALIGNMENT_START)
button = gtk.Button(_('Add New Joke'))
button.connect('clicked', self.do_clicked_add_joke, jokebook)
buttons.append(hippo.CanvasWidget(widget=theme.theme_widget(button)))
jokes_div.append(buttons)
def __init__(self, jokebook, parent):
Page.__init__(self,
xalign=hippo.ALIGNMENT_CENTER,
orientation=hippo.ORIENTATION_VERTICAL,
padding=20,
spacing=20)
self.__parent = parent
# page title
self.append(
self.make_field(_('Title of Jokebook:'), 250, jokebook, 'title',
300, True))
#field = self.make_field(_('Sound Effect:'), 250, None, '', 300, False)
sound_effect = hippo.CanvasBox(
orientation=hippo.ORIENTATION_HORIZONTAL, spacing=10)
sound_effect.append(
self.make_bodytext(_('Sound Effect:'), 250, hippo.ALIGNMENT_START,
theme.COLOR_DARK_GREEN))
sound_effect.append(self.make_audiobox(jokebook, 'sound', 316))
self.append(sound_effect)
# cover picture
cover_image = self.make_imagebox(jokebook, 'image', 320, 240, True)
self.append(cover_image)
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 _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 make_field(self,
label,
label_width,
obj,
property,
field_width,
editable=True):
value = self.__get_property_value(obj, property)
field_box = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
xalign=hippo.ALIGNMENT_START,
spacing=10)
field_box.append(
hippo.CanvasText(text=label,
box_width=label_width,
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_DARK_GREEN.get_int()))
#if editable:
textfield = self.__textview(value, field_width, -1, editable, False)
textfield.control.get_buffer().connect('changed',
self.__do_changed_control, obj,
property)
field_box.append(textfield)
#else: # TODO - move to __textview()
#glitch_box = CanvasBox(box_width=field_width)
#glitch_box.append(hippo.CanvasText(text=value,
#size_mode=hippo.CANVAS_SIZE_WRAP_WORD,
#box_width=field_width,
#xalign=hippo.ALIGNMENT_START))
#field_box.append(glitch_box)
return field_box
def __make_header(self):
ret = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL)
# logo
logo = gtk.Image()
logo.set_from_file(Globals.logo)
ret.append(hippo.CanvasWidget(widget=logo))
# lesson plans
lesson_plans = hippo.CanvasWidget(
background_color=theme.COLOR_BACKGROUND.get_int(),
border_top=theme.BORDER_WIDTH,
border_left=theme.BORDER_WIDTH,
border_right=theme.BORDER_WIDTH,
border_color=theme.COLOR_FRAME.get_int(),
padding_top=12,
padding_bottom=12,
padding_left=30,
padding_right=30,
yalign=hippo.ALIGNMENT_CENTER,
orientation=hippo.ORIENTATION_VERTICAL)
button = gtk.Button(_('Lesson Plans'))
button.set_size_request(200, -1)
button.active = False
button.connect('clicked', self.__do_clicked_lessonplans)
lesson_plans.props.widget = theme.theme_widget(button)
ret.append(lesson_plans, hippo.PACK_EXPAND)
return ret
def __init__(self):
logging.debug('STARTUP: Loading the group view')
gobject.GObject.__init__(self)
self._box = hippo.CanvasBox()
self._box.props.background_color = style.COLOR_WHITE.get_int()
self.set_root(self._box)
self._friends = {}
self._layout = SpreadLayout()
self._box.set_layout(self._layout)
client = gconf.client_get_default()
color = XoColor(client.get_string('/desktop/sugar/user/color'))
self._owner_icon = CanvasIcon(icon_name='computer-xo', cache=True,
xo_color=color)
self._owner_icon.props.size = style.LARGE_ICON_SIZE
self._owner_icon.set_palette(BuddyMenu(get_owner_instance()))
self._layout.add(self._owner_icon)
friends_model = friends.get_model()
for friend in friends_model:
self.add_friend(friend)
friends_model.connect('friend-added', self._friend_added_cb)
friends_model.connect('friend-removed', self._friend_removed_cb)
def _create_technical(self):
vbox = hippo.CanvasBox()
vbox.props.spacing = style.DEFAULT_SPACING
lines = [
_('Kind: %s') %
(self._metadata.get('mime_type') or _('Unknown'), ),
_('Date: %s') % (self._format_date(), ),
_('Size: %s') % (format_size(
int(
self._metadata.get(
'filesize', model.get_file_size(
self._metadata['uid']))))),
]
for line in lines:
text = hippo.CanvasText(
text=line, font_desc=style.FONT_NORMAL.get_pango_desc())
text.props.color = style.COLOR_BUTTON_GREY.get_int()
if gtk.widget_get_default_direction() == gtk.TEXT_DIR_RTL:
text.props.xalign = hippo.ALIGNMENT_END
else:
text.props.xalign = hippo.ALIGNMENT_START
vbox.append(text)
return vbox
def __init__(self, jokebook, parent):
Page.__init__(self)
self.__parent = parent
jokes_div = CanvasListBox()
jokes_div.props.border = 0
for joke in jokebook.submissions:
list_row = self.make_listrow(JokeViewer(joke, jokebook.title))
list_row.props.orientation = hippo.ORIENTATION_VERTICAL
buttons = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
xalign=hippo.ALIGNMENT_END,
spacing=10,
padding=10)
button = gtk.Button(' ' + _('Reject') + ' ')
button.connect('clicked', self.__do_clicked_reject, jokebook, joke)
buttons.append(
hippo.CanvasWidget(widget=theme.theme_widget(button),
border_color=theme.COLOR_RED.get_int(),
border=0,
xalign=hippo.ALIGNMENT_CENTER))
button = gtk.Button(' ' + _('Accept') + ' ')
button.connect('clicked', self.__do_clicked_accept, jokebook, joke)
buttons.append(
hippo.CanvasWidget(widget=theme.theme_widget(button),
border_color=theme.COLOR_RED.get_int(),
border=0,
xalign=hippo.ALIGNMENT_CENTER))
list_row.append(buttons)
#list_row.props.orientation=hippo.ORIENTATION_VERTICAL
#status_box = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL,
#padding_top=4,
#padding_left=4)
#status_box.append(hippo.CanvasText(text=_('Status:'),
#color=theme.COLOR_DARK_GREEN.get_int(),
#box_width=100,
#xalign=hippo.ALIGNMENT_START))
##button = None
#button = gtk.RadioButton()
#button = gtk.RadioButton(button, _('Approved'))
#button.set_size_request(200, -1)
#status_box.append(hippo.CanvasWidget(widget = button))
#button = gtk.RadioButton(button, _('Rejected'))
#button.set_size_request(200, -1)
#status_box.append(hippo.CanvasWidget(widget = button))
#button = gtk.RadioButton(button, _('Not Reviewed'))
#button.set_size_request(200, -1)
#button.set_active(True)
#status_box.append(hippo.CanvasWidget(widget = button))
#list_row.append(status_box)
jokes_div.append(list_row)
self.append(jokes_div)
def __init__(self, parent, **kwargs):
hippo.CanvasBox.__init__(self, **kwargs)
self.__parent = parent
self.props.border = 1
self.props.border_color = theme.COLOR_TAB_ACTIVE.get_int()
self.props.background_color = theme.COLOR_PAGE.get_int()
self.props.orientation = hippo.ORIENTATION_VERTICAL
tab_box = hippo.CanvasBox(
background_color=theme.COLOR_TAB_SEPERATOR.get_int(),
spacing=2,
orientation=hippo.ORIENTATION_HORIZONTAL)
self.__tab_1 = hippo.CanvasText(
text=_('Edit Jokebook Cover'),
padding=theme.PADDING_TAB,
xalign=hippo.ALIGNMENT_START,
background_color=theme.COLOR_TAB_ACTIVE.get_int(),
color=theme.COLOR_TAB_TEXT.get_int())
self.__tab_1.page = EditInfo
self.__tab_1.connect('button-press-event', self.__do_clicked_tab)
tab_box.append(self.__tab_1, hippo.PACK_EXPAND)
self.__tab_2 = hippo.CanvasText(
text=_('Edit My Jokes'),
padding=theme.PADDING_TAB,
xalign=hippo.ALIGNMENT_START,
background_color=theme.COLOR_TAB_INACTIVE.get_int(),
color=theme.COLOR_TAB_TEXT.get_int())
self.__tab_2.page = EditJokes
self.__tab_2.connect('button-press-event', self.__do_clicked_tab)
tab_box.append(self.__tab_2, hippo.PACK_EXPAND)
self.__tab_3 = hippo.CanvasText(
text=_('Review Submitted Jokes'),
padding=theme.PADDING_TAB,
xalign=hippo.ALIGNMENT_START,
background_color=theme.COLOR_TAB_INACTIVE.get_int(),
color=theme.COLOR_TAB_TEXT.get_int())
self.__tab_3.page = EditReview
self.__tab_3.connect('button-press-event', self.__do_clicked_tab)
tab_box.append(self.__tab_3, hippo.PACK_EXPAND)
self.append(tab_box)
self.__page = hippo.CanvasBox(
background_color=theme.COLOR_PAGE.get_int(),
orientation=hippo.ORIENTATION_VERTICAL)
self.append(self.__page, hippo.PACK_EXPAND)
def __init__(self):
hippo.Canvas.__init__(self)
# Root Frame ###############################################################
# Holds: Everything
self.__root = hippo.CanvasBox(orientation=hippo.ORIENTATION_VERTICAL)
self.set_root(self.__root)
# Application Header #######################################################
# Holds: App logo, language box, lessons plan box
self.__header = self.__make_header()
self.__root.append(self.__header)
# Page Container ###########################################################
# Holds: The currently open UI page
self.__container = hippo.CanvasBox(
border=theme.BORDER_WIDTH,
border_color=theme.COLOR_FRAME.get_int(),
background_color=theme.COLOR_BACKGROUND.get_int(),
spacing=4,
padding_top=20,
padding_left=40,
padding_right=40,
padding_bottom=20,
orientation=hippo.ORIENTATION_VERTICAL)
self.__root.append(self.__container, hippo.PACK_EXPAND)
self.__page = hippo.CanvasBox(
background_color=theme.COLOR_PAGE.get_int(),
border=4,
border_color=theme.COLOR_PAGE_BORDER.get_int(),
spacing=8,
padding=20,
orientation=hippo.ORIENTATION_VERTICAL)
self.__container.append(self.__page, hippo.PACK_EXPAND)
self.__page_class = None
# Application Footer #######################################################
# Holds: Task buttons
self.__footer = self.__make_footer()
self.__container.append(self.__footer)
def make_audiobox(self, obj, property, width):
image_file = os.path.join(Globals.pwd, theme.AUDIO_CHOOSE)
if not os.path.exists(image_file):
logging.debug('cannot find %s' % image_file)
return hippo.CanvasBox()
surface = cairo.ImageSurface.create_from_png(image_file)
preview_sound = hippo.CanvasImage(image=surface,
xalign=hippo.ALIGNMENT_START,
yalign=hippo.ALIGNMENT_CENTER)
preview_sound.connect('button-press-event',
self.__do_clicked_preview_sound, obj, property)
if hasattr(obj, property) and getattr(obj, property) != None:
sound_name = getattr(obj, property)
else:
sound_name = _('Click to choose a sound')
choose_sound = hippo.CanvasText(text=sound_name,
xalign=hippo.ALIGNMENT_START)
choose_sound.connect('button-press-event',
self.__do_clicked_choose_sound, obj, property)
sound_box = RoundBox()
sound_box.props.padding = 2
sound_box.props.spacing = 10
sound_box.props.box_width = width
sound_box.props.border = theme.BORDER_WIDTH_CONTROL / 2
sound_box.props.border_color = theme.COLOR_DARK_GREEN.get_int()
sound_box.props.background_color = theme.COLOR_WHITE.get_int()
sound_box.props.orientation = hippo.ORIENTATION_HORIZONTAL
sound_box.props.xalign = hippo.ALIGNMENT_START
sound_box.set_clickable(True)
sound_box.append(preview_sound)
sound_box.append(choose_sound)
deglitch_box = hippo.CanvasBox(xalign=hippo.ALIGNMENT_START,
box_width=width)
deglitch_box.append(sound_box)
return deglitch_box
def __init__(self, joke):
Page.__init__(self,
spacing=8,
padding=4,
border_color=theme.COLOR_RED.get_int(),
border=0,
orientation=hippo.ORIENTATION_HORIZONTAL)
# left column
self.left = hippo.CanvasBox(border=0,
border_color=theme.COLOR_RED.get_int(),
xalign=hippo.ALIGNMENT_START,
orientation=hippo.ORIENTATION_VERTICAL,
padding=theme.BORDER_WIDTH_CONTROL / 2)
joke_image = self.make_imagebox(joke, 'image', 320, 240, True)
self.left.append(joke_image)
# right column
self.right = hippo.CanvasBox(
border=0,
border_color=theme.COLOR_RED.get_int(),
padding=theme.SPACER_HORIZONTAL,
orientation=hippo.ORIENTATION_VERTICAL,
padding_bottom=theme.BORDER_WIDTH_CONTROL / 2,
spacing=theme.BORDER_WIDTH_CONTROL / 2)
self.right.append(
hippo.CanvasText(text=_('Question'),
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_DARK_GREEN.get_int()))
self.right.append(self.make_textbox(joke, 'text'))
self.right.append(hippo.CanvasBox(box_height=theme.SPACER_VERTICAL))
self.right.append(
hippo.CanvasText(text=_('Answer'),
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_DARK_GREEN.get_int()))
self.right.append(self.make_textbox(joke, 'answer'))
self.append(self.left)
self.append(self.right, hippo.PACK_EXPAND)
def __make_jokebook_div(self, jokebook, edit=False):
list_row = self.make_listrow()
# thumbnail
thumbnail = self.make_imagebox(jokebook, 'image', 80, 60, False, 10)
list_row.append(self.__make_column_div(100, thumbnail))
# title
title = hippo.CanvasText(text=(jokebook.title or '') + "\n" +
(jokebook.owner or ''),
padding_left=20,
xalign=hippo.ALIGNMENT_START,
color=theme.COLOR_LINK.get_int())
title.set_clickable(True)
title.connect('button-press-event', self.__do_clicked_title, jokebook)
list_row.append(self.__make_column_div(-1, title), hippo.PACK_EXPAND)
list_row.append(
hippo.CanvasBox(box_width=theme.SPACER_HORIZONTAL)) # TODO spacer
# buttons
if edit:
button = gtk.Button(_('Edit'))
button.connect('clicked', self.__do_clicked_edit, jokebook)
list_row.append(
self.__make_column_div(
100,
hippo.CanvasWidget(widget=theme.theme_widget(button))))
list_row.append(hippo.CanvasBox(
box_width=theme.SPACER_HORIZONTAL)) # TODO spacer
button = gtk.Button(_('Delete'))
button.connect('clicked', self.__do_clicked_delete, jokebook)
list_row.append(
self.__make_column_div(
100,
hippo.CanvasWidget(widget=theme.theme_widget(button))))
list_row.append(hippo.CanvasBox(
box_width=theme.SPACER_HORIZONTAL)) # TODO spacer
return list_row
def __init__(self,
jokebook,
last_joke=0): # last_joke is for 'back' button
Page.__init__(self, spacing=10)
# create a new joke
joke = Joke()
joke.id = jokebook.next_joke_id
logging.info('Created new joke with id: %d' % joke.id)
joke.joker = Globals.nickname
# info
self.append(
self.make_field(_('Submission For:'), 250, jokebook, 'title', 300,
False))
self.append(
self.make_field(_('Your Name:'), 250, joke, 'joker', 300, True))
self.append(
hippo.CanvasBox(box_height=theme.SPACER_VERTICAL)) # spacer
# joke editor
jokebox = JokeEditor(joke)
nav = hippo.CanvasBox(padding_right=8,
padding_top=8,
spacing=18,
orientation=hippo.ORIENTATION_HORIZONTAL)
button = gtk.Button(_('Submit'))
button.connect('clicked', self.__do_clicked_submit, jokebook, joke)
nav.append(
hippo.CanvasWidget(widget=theme.theme_widget(button),
padding_right=10,
padding_top=20))
button = gtk.Button(_('Back'))
button.connect('clicked', self.__do_clicked_back, jokebook, last_joke)
nav.append(
hippo.CanvasWidget(widget=theme.theme_widget(button),
padding_top=20))
jokebox.right.append(nav)
self.append(jokebox)
def __init__(self, buddies):
hippo.CanvasBox.__init__(self,
xalign=hippo.ALIGNMENT_START,
orientation=hippo.ORIENTATION_HORIZONTAL)
for buddy in buddies:
nick_, color = buddy
hbox = hippo.CanvasBox(orientation=hippo.ORIENTATION_HORIZONTAL)
icon = CanvasIcon(icon_name='computer-xo',
xo_color=XoColor(color),
size=style.STANDARD_ICON_SIZE)
icon.set_palette(BuddyPalette(buddy))
hbox.append(icon)
self.append(hbox)
def __textview(self,
text,
width=300,
height=-1,
editable=True,
multiline=False):
textview = gtk.TextView()
textview.get_buffer().set_text(text)
# control props
textview.set_wrap_mode(gtk.WRAP_WORD)
textview.modify_base(gtk.STATE_NORMAL,
theme.COLOR_TEXTBOX.get_gdk_color())
textview.set_editable(editable)
textview.set_cursor_visible(editable)
if height == -1:
context = textview.create_pango_context()
layout = pango.Layout(context)
layout.set_text(text[:text.find('\n')])
(w, h) = layout.get_pixel_size()
height = h #+ theme.BORDER_WIDTH_CONTROL / 2 # fudge factor - on the XO-1 hardware all known solutions evaporate
textview.set_size_request(width, height)
textview.set_border_window_size(gtk.TEXT_WINDOW_LEFT, 0)
textview.set_border_window_size(gtk.TEXT_WINDOW_RIGHT, 0)
textview.set_border_window_size(gtk.TEXT_WINDOW_TOP, 0)
textview.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 0)
textview.show()
if editable: # because rounded corners are well... pretty
border_box = RoundBox()
border_box.control = textview
border_box.props.padding = 2
border_box.props.spacing = 0
border_box.props.border = theme.BORDER_WIDTH_CONTROL / 2
border_box.props.border_color = theme.COLOR_DARK_GREEN.get_int()
border_box.props.background_color = theme.COLOR_TEXTBOX.get_int()
border_box.props.xalign = hippo.ALIGNMENT_START
#border_box.props.box_width = width
#border_box.props.box_height = height
# TODO - File bug: RoundBox seriously messes with TextView's
# (and other things) width !!
deglitch_box = hippo.CanvasBox()
deglitch_box.append(hippo.CanvasWidget(widget=textview))
border_box.append(deglitch_box)
return border_box
no_edit_box = hippo.CanvasWidget(widget=textview)
no_edit_box.control = textview
return no_edit_box
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 _add_buddy(self, buddy):
box = hippo.CanvasBox(
orientation = hippo.ORIENTATION_HORIZONTAL,
background_color = BUDDIES_COLOR.get_int(),
spacing = ENTRY_YPAD
)
buddy_face, buddy_widget = self._new_face(buddy, BUDDIES_COLOR)
char_box = hippo.CanvasBox(
orientation = hippo.ORIENTATION_VERTICAL,
)
nick = hippo.CanvasText(
text = buddy.props.nick,
xalign = hippo.ALIGNMENT_START,
yalign = hippo.ALIGNMENT_START
)
lang = hippo.CanvasText(
text = '',
xalign = hippo.ALIGNMENT_START,
yalign = hippo.ALIGNMENT_START
)
char_box.append(nick)
char_box.append(lang)
box.append(buddy_widget)
box.append(char_box, hippo.PACK_EXPAND)
self._buddies[buddy] = {
'box': box,
'face': buddy_face,
'lang': lang
}
self._buddies_list.append(box)
if len(self._buddies) == 1:
self._desk.append(self._buddies_box)
def labelize(text, widget):
box = hippo.CanvasBox()
box.props.spacing = style.DEFAULT_SPACING
text = hippo.CanvasText(text=text)
text.props.color = style.COLOR_SELECTION_GREY.get_int()
if gtk.widget_get_default_direction() == gtk.TEXT_DIR_RTL:
text.props.xalign = hippo.ALIGNMENT_END
else:
text.props.xalign = hippo.ALIGNMENT_START
box.append(text)
box.append(widget, hippo.PACK_EXPAND)
return box
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):
gobject.GObject.__init__(self)
self._box = hippo.CanvasBox()
self._box.props.background_color = style.COLOR_WHITE.get_int()
self.set_root(self._box)
self._layout = _Layout()
self._box.set_layout(self._layout)
self._my_icon = BuddyIcon(buddy=get_owner_instance(),
size=style.XLARGE_ICON_SIZE)
self._box.append(self._my_icon)
self._animator = animator.Animator(0.3)
self._animator.connect('completed', self._animation_completed_cb)
def __init__(self, **kwargs):
logging.debug('GLYCOGEN: Loading the pathway view')
gobject.GObject.__init__(self, **kwargs)
# DND stuff
self._pressed_button = None
self._press_start_x = None
self._press_start_y = None
self._hot_x = None
self._hot_y = None
self._last_clicked_icon = None
self._box = hippo.CanvasBox()
self._box.props.background_color = style.COLOR_WHITE.get_int()
self.set_root(self._box)
self._my_icon = OwnerIcon(style.XLARGE_ICON_SIZE)
self._my_icon.connect('register-activate', self.__register_activate_cb)
self._box.append(
self._my_icon
) # looks like this puts the xo user icon in the middle
self._current_activity = CurrentActivityIcon()
self._box.append(
self._current_activity
) # looks like this puts the current activity icon under the user icon
self._layout = None
self._alert = None
self._resume_mode = True
# More DND stuff
self.add_events(gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
self.connect('motion-notify-event', self.__motion_notify_event_cb)
self.connect('button-press-event', self.__button_press_event_cb)
self.connect('drag-begin', self.__drag_begin_cb)
self.connect('drag-motion', self.__drag_motion_cb)
self.connect('drag-drop', self.__drag_drop_cb)
self.connect('drag-data-received', self.__drag_data_received_cb)
gobject.idle_add(self.__connect_to_bundle_registry_cb)
favorites_settings = get_settings()
favorites_settings.changed.connect(self.__settings_changed_cb)
self._set_layout(favorites_settings.layout)
def _create_preview(self):
width = style.zoom(320)
height = style.zoom(240)
box = hippo.CanvasBox()
if len(self._metadata.get('preview', '')) > 4:
if self._metadata['preview'][1:4] == 'PNG':
preview_data = self._metadata['preview']
else:
# TODO: We are close to be able to drop this.
import base64
preview_data = base64.b64decode(self._metadata['preview'])
png_file = StringIO.StringIO(preview_data)
try:
surface = cairo.ImageSurface.create_from_png(png_file)
has_preview = True
except Exception:
logging.exception('Error while loading the preview')
has_preview = False
else:
has_preview = False
if has_preview:
preview_box = hippo.CanvasImage(
image=surface,
border=style.LINE_WIDTH,
border_color=style.COLOR_BUTTON_GREY.get_int(),
xalign=hippo.ALIGNMENT_CENTER,
yalign=hippo.ALIGNMENT_CENTER,
scale_width=width,
scale_height=height)
else:
preview_box = hippo.CanvasText(
text=_('No preview'),
font_desc=style.FONT_NORMAL.get_pango_desc(),
xalign=hippo.ALIGNMENT_CENTER,
yalign=hippo.ALIGNMENT_CENTER,
border=style.LINE_WIDTH,
border_color=style.COLOR_BUTTON_GREY.get_int(),
color=style.COLOR_BUTTON_GREY.get_int(),
box_width=width,
box_height=height)
preview_box.connect_after('button-release-event',
self._preview_box_button_release_event_cb)
box.append(preview_box)
return box
