def test_set_app_menu(self): w = hildon.Window() m = hildon.AppMenu() self.assertEqual(getrefcount(m), 2) w.set_app_menu(m) self.assertEqual(getrefcount(m), 3) w.set_app_menu(m) self.assertEqual(getrefcount(m), 3) m2 = hildon.AppMenu() self.assertEqual(getrefcount(m2), 2) w.set_app_menu(m2) self.assertEqual(getrefcount(m), 2) self.assertEqual(getrefcount(m2), 3)
def test_set_app_menu_implicitly_deleted(self): w = hildon.Window() m = hildon.AppMenu() w.set_app_menu(m) w.set_app_menu() # should not segfault m.append(gtk.Button('test'))
def _create_menu(self): menu = hildon.AppMenu() self.settings_button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT) self.settings_button.set_label(_("Settings")) self.settings_button.connect('clicked', self.open_settings) self.settings_button.show() menu.append(self.settings_button) self.status_button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT) self.status_button.set_label("status") self.status_button.connect('clicked', self.update_status) self.status_button.show() menu.append(self.status_button) self.chatroom_button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT) self.chatroom_button.set_label(_("Chatroom")) #menu.append(self.chatroom) self.spread_button = hildon.GtkButton(gtk.HILDON_SIZE_FINGER_HEIGHT) self.spread_button.set_label(_("Invite friends")) self.spread_button.connect('clicked', self.invite_friends) menu.append(self.spread_button) menu.show_all() return menu
def _addAppMenu(self): """add application menu & enable zoom key paging""" import gtk import gobject import hildon window = self.mieru.gui.getWindow() # enable zoom/volume keys for usage by mieru self.enableZoomKeys(window) # enable rotation self.rotationObject = self._startAutorotation() # add application menu menu = hildon.AppMenu() openFolderButton = gtk.Button("Open folder") openFolderButton.connect('clicked', self.startChooserCB, "folder") openFileButton = gtk.Button("Open file") openFileButton.connect('clicked', self.startChooserCB, "file") fullscreenButton = gtk.Button("Fullscreen") fullscreenButton.connect('clicked', self._toggleFullscreenCB) # last open mangas list self.historyStore = gtk.ListStore(gobject.TYPE_STRING) self.historyLocked = False self._updateHistory() selector = self._getHistorySelector() selector.connect('changed', self._historyRowSelected) historyPickerButton = self.getVerticalPickerButton("History") historyPickerButton.set_selector(selector) self.historyPickerButton = historyPickerButton self.mieru.watch('openMangasHistory', self._updateHistoryCB) optionsButton = gtk.Button("Options") optionsButton.connect('clicked', self._showOptionsCB) infoButton = gtk.Button("Info") infoButton.connect('clicked', self._showInfoCB) pagingButton = gtk.Button("Paging") pagingButton.connect('clicked', self.showPagingDialogCB) fitPickerButton = self._getFittingPickerButton( "Page fitting", arrangement=hildon.BUTTON_ARRANGEMENT_VERTICAL) menu.append(openFileButton) menu.append(openFolderButton) menu.append(fullscreenButton) menu.append(historyPickerButton) menu.append(pagingButton) menu.append(fitPickerButton) menu.append(optionsButton) menu.append(infoButton) # Show all menu items menu.show_all() # Add the menu to the window window.set_app_menu(menu)
def test_get_items(self): m = hildon.AppMenu() self.assertEqual(set(m.get_items()), set([])) b1 = gtk.Button() b2 = gtk.Button() m.append(b1) m.append(b2) self.assertEqual(set(m.get_items()), set([b1, b2]))
def test_get_filters(self): m = hildon.AppMenu() self.assertEqual(set(m.get_filters()), set([])) f1 = gtk.RadioButton() f2 = gtk.RadioButton() m.add_filter(f1) m.add_filter(f2) self.assertEqual(set(m.get_filters()), set([f1, f2]))
def test_app_menu_ownership(self): w = hildon.Window() m = hildon.AppMenu() m_str = str(m) w.set_app_menu(m) self.assertEqual(w.get_app_menu(), m) # set_app_menu takes ownership of the passed menu # so this should not segfault del m self.assertEqual(str(w.get_app_menu()), m_str)
def create_playlist_app_menu(self): menu = hildon.AppMenu() for action in (self.action_save, self.action_delete_bookmarks): b = gtk.Button() action.connect_proxy(b) menu.append(b) menu.show_all() return menu
def create_app_menu(self): menu = hildon.AppMenu() for action in (self.action_settings, self.action_playlist, self.action_open, self.action_open_dir, self.action_empty_playlist, self.action_about): b = gtk.Button() action.connect_proxy(b) menu.append(b) menu.show_all() return menu
def create_mms_menu(self, fname): """ create app menu for mms viewing window """ menu = hildon.AppMenu() self.headerstxt = _("Headers") headers = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) headers.set_label(self.headerstxt) headers.connect('clicked', self.mms_menu_button_clicked, fname) self.replytxt = gettext.ldgettext('skype-ui', 'skype_ti_incoming_call_options') reply = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) reply.set_label(self.replytxt) reply.connect('clicked', self.mms_menu_button_clicked, fname) self.replysmstxt = "%s (%s)" % (gettext.ldgettext('skype-ui', 'skype_ti_incoming_call_options'), "SMS") replysms = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) replysms.set_label(self.replysmstxt) replysms.connect('clicked', self.mms_menu_button_clicked, fname) self.forwardtxt = gettext.ldgettext('rtcom-messaging-ui', 'messaging_fi_forward') forward = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) forward.set_label(self.forwardtxt) forward.connect('clicked', self.mms_menu_button_clicked, fname) self.copytxt = "%s" % gettext.ldgettext('rtcom-messaging-ui', 'messaging_fi_copy') copyb = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) copyb.set_label(self.copytxt) copyb.connect('clicked', self.mms_menu_button_clicked, fname) self.deletetxt = gettext.ldgettext('hildon-libs', 'wdgt_bd_delete') delete = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) delete.set_label(self.deletetxt) delete.connect('clicked', self.mms_menu_button_clicked, fname) self.saveattachments = gettext.ldgettext('modest', 'mcen_me_viewer_save_attachments') saveattach = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) saveattach.set_label(self.saveattachments) saveattach.connect('clicked', self.mms_menu_button_clicked, fname) menu.append(reply) menu.append(replysms) menu.append(saveattach) menu.append(copyb) menu.append(forward) menu.append(headers) menu.append(delete) menu.show_all() return menu
def create_menu(win, pannable_area, timeline): menu = hildon.AppMenu() rm_read_button = gtk.Button('Remove read') rm_read_button.connect("clicked", remove_read_notices, timeline) jump_unread_button = gtk.Button('Jump to unread') jump_unread_button.connect("clicked", jump_to_unread, pannable_area, timeline) settings_button = gtk.Button("Settings") settings_button.connect("clicked", configure, win) menu.append(rm_read_button) menu.append(jump_unread_button) menu.append(settings_button) menu.show_all() return menu
def new(self): self._is_updating = False if hasattr(self, 'custom_title'): self.main_window.set_title(self.custom_title) if not hasattr(self, 'add_urls_callback'): self.add_urls_callback = None titlecell = gtk.CellRendererText() titlecell.set_property('ellipsize', pango.ELLIPSIZE_END) titlecolumn = gtk.TreeViewColumn( '', titlecell, markup=OpmlListModel.C_DESCRIPTION_MARKUP) self.treeview.append_column(titlecolumn) selection = self.treeview.get_selection() selection.connect('changed', self.on_selection_changed) selection.set_mode(gtk.SELECTION_MULTIPLE) selection.unselect_all() self.app_menu = hildon.AppMenu() for action in (self.action_select_all, \ self.action_select_none): button = gtk.Button() action.connect_proxy(button) self.app_menu.append(button) self.main_window.set_app_menu(self.app_menu) self.edit_toolbar = EditToolbarDeluxe(self.main_window.get_title(), \ _('Subscribe')) self.edit_toolbar.connect('arrow-clicked', \ self.on_close_button_clicked) self.edit_toolbar.connect('button-clicked', \ self.on_subscribe_button_clicked) self.edit_toolbar.show_all() # This method needs a EditToolbarDeluxe to work self.edit_toolbar.set_button_sensitive(False) self.main_window.set_edit_toolbar(self.edit_toolbar) self.main_window.fullscreen() self.main_window.show()
def create_mainwin_menu(self, vbox): self.main_menu = hildon.AppMenu() self.mm_item_new = hildon.Button( gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "Add record", None) self.main_menu.append(self.mm_item_new) self.mm_item_edit = hildon.Button( gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "Edit record", None) self.main_menu.append(self.mm_item_edit) self.mm_item_delete = hildon.Button( gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "Delete record", None) self.main_menu.append(self.mm_item_delete) self.mm_item_settings = hildon.Button( gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "Settings", None) self.main_menu.append(self.mm_item_settings) self.mm_item_about = hildon.Button( gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL, "About ...", None) self.main_menu.append(self.mm_item_about) self.mm_item_new.connect("clicked", callbacks.newrecord, self) self.mm_item_edit.connect("clicked", callbacks.editrecord, self) self.mm_item_settings.connect("clicked", callbacks.settings, self) self.mm_item_delete.connect("clicked", callbacks.deleterecord, self) self.mm_item_about.connect("clicked", callbacks.about, self) self.set_app_menu(self.main_menu) FuelpadAbstractWindow.create_mainwin_menu(self, vbox)
def _addHildonAppMenu(self): menu = hildon.AppMenu() self.centeringToggleButton = gtk.ToggleButton(label="Centering") self.centeringToggleButton.connect('toggled', self._toggle, 'centred') self.rotationToggleButton = gtk.ToggleButton(label="Map rotation") self.rotationToggleButton.connect('toggled', self._toggle, 'rotateMap') self.soundToggleButton = gtk.ToggleButton(label="Sound") self.soundToggleButton.connect('toggled', self._toggle, 'soundEnabled') mapButton = gtk.Button("Map screen") mapButton.connect('clicked', self._switchToMenu, None) optionsButton = gtk.Button("Options") optionsButton.connect('clicked', self._switchToMenu, 'options') searchButton = gtk.Button("Search") searchButton.connect('clicked', self._switchToMenu, 'searchWhat') routeButton = gtk.Button("Route") routeButton.connect('clicked', self._switchToMenu, 'route') self._updateAppMenu() # update initial button states menu.append(self.centeringToggleButton) menu.append(self.rotationToggleButton) menu.append(self.soundToggleButton) menu.append(mapButton) menu.append(optionsButton) menu.append(searchButton) menu.append(routeButton) # Show all menu items menu.show_all() # Add the menu to the window self.topWindow.set_app_menu(menu) # register callbacks to update upp menu toggle buttons # when the controlled value changes from elsewhere self.watch('rotateMap', self._updateAppMenu) self.watch('soundEnabled', self._updateAppMenu) self.watch('centred', self._updateAppMenu)
def new(self): self._selected_tasks = [] selection = self.treeview.get_selection() selection.connect('changed', self.on_selection_changed) appmenu = hildon.AppMenu() for action in (self.action_pause, \ self.action_resume, \ self.action_cancel, \ self.action_cleanup): button = gtk.Button() action.connect_proxy(button) appmenu.append(button) for action in (self.action_select_all, \ self.action_select_none): button = gtk.Button() action.connect_proxy(button) appmenu.append(button) appmenu.show_all() self.main_window.set_app_menu(appmenu)
def create_menu(self, parent=None): """ Creates the application menu. """ menu = hildon.AppMenu() config = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) config.set_label(self.config_label) config.connect('clicked', self.menu_button_clicked, parent) reset = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) reset.set_label(self.reset_label) reset.connect('clicked', self.menu_button_clicked, parent) about = hildon.GtkButton(gtk.HILDON_SIZE_AUTO) about.set_label(self.about_label) about.connect('clicked', self.menu_button_clicked, parent) menu.append(config) menu.append(reset) menu.append(about) menu.show_all() return menu
def new(self): self.channel = None # Styling for the label that appears when the list is empty hildon.hildon_helper_set_logical_font(self.empty_label, \ 'LargeSystemFont') hildon.hildon_helper_set_logical_color(self.empty_label, \ gtk.RC_FG, gtk.STATE_NORMAL, 'SecondaryTextColor') self.episode_actions = gPodderEpisodeActions(self.main_window, \ episode_list_status_changed=self.episode_list_status_changed, \ episode_is_downloading=self.episode_is_downloading, \ show_episode_shownotes=self.show_episode_shownotes, \ playback_episodes=self.playback_episodes, \ download_episode_list=self.download_episode_list, \ show_episode_in_download_manager=self.show_episode_in_download_manager, \ add_download_task_monitor=self.add_download_task_monitor, \ remove_download_task_monitor=self.remove_download_task_monitor, \ for_each_episode_set_task_status=self.for_each_episode_set_task_status, \ delete_episode_list=self.delete_episode_list) # Tap-and-hold (aka "long press") context menu self.touched_episode = None self.context_menu = gtk.Menu() # "Emulate" hildon_gtk_menu_new self.context_menu.set_name('hildon-context-sensitive-menu') self.context_menu.append(self.action_shownotes.create_menu_item()) self.context_menu.append(self.action_download.create_menu_item()) self.context_menu.append(self.action_delete.create_menu_item()) self.context_menu.append(gtk.SeparatorMenuItem()) self.context_menu.append(self.action_keep.create_menu_item()) self.context_menu.append(self.action_mark_as_old.create_menu_item()) self.context_menu.show_all() self.treeview.tap_and_hold_setup(self.context_menu) # Workaround for Maemo bug XXX self.button_search_episodes_clear.set_name('HildonButton-thumb') appmenu = hildon.AppMenu() for action in (self.action_update, \ self.action_rename, \ self.action_login, \ self.action_website, \ self.action_unsubscribe, \ self.action_check_for_new_episodes, \ self.action_delete_episodes): button = gtk.Button() action.connect_proxy(button) appmenu.append(button) self.pause_sub_button = hildon.CheckButton( gtk.HILDON_SIZE_FINGER_HEIGHT) self.pause_sub_button.set_label(_('Pause subscription')) self.pause_sub_button.connect( 'toggled', self.on_pause_subscription_button_toggled) appmenu.append(self.pause_sub_button) self.keep_episodes_button = hildon.CheckButton( gtk.HILDON_SIZE_FINGER_HEIGHT) self.keep_episodes_button.set_label(_('Keep episodes')) self.keep_episodes_button.connect('toggled', self.on_keep_episodes_button_toggled) appmenu.append(self.keep_episodes_button) for filter in (self.item_view_episodes_all, \ self.item_view_episodes_undeleted, \ self.item_view_episodes_downloaded): button = gtk.ToggleButton() filter.connect_proxy(button) appmenu.add_filter(button) appmenu.show_all() self.main_window.set_app_menu(appmenu)
def new( self): self._config.connect_gtk_window(self.gPodderEpisodeSelector, 'episode_selector', True) if not hasattr( self, 'callback'): self.callback = None if not hasattr(self, 'remove_callback'): self.remove_callback = None if not hasattr(self, 'remove_action'): self.remove_action = _('Remove') if not hasattr(self, 'remove_finished'): self.remove_finished = None if not hasattr( self, 'episodes'): self.episodes = [] if not hasattr( self, 'size_attribute'): self.size_attribute = 'length' if not hasattr(self, 'tooltip_attribute'): self.tooltip_attribute = 'description' if not hasattr( self, 'selection_buttons'): self.selection_buttons = {} if not hasattr( self, 'selected_default'): self.selected_default = False if not hasattr( self, 'selected'): self.selected = [self.selected_default]*len(self.episodes) if len(self.selected) < len(self.episodes): self.selected += [self.selected_default]*(len(self.episodes)-len(self.selected)) if not hasattr( self, 'columns'): self.columns = (('title_markup', None, None, _('Episode')),) if hasattr( self, 'title'): self.gPodderEpisodeSelector.set_title( self.title) if hasattr(self, 'instructions'): #self.show_message(self.instructions) pass if self.remove_callback is not None: self.btnRemoveAction.show() self.btnRemoveAction.set_label(self.remove_action) if hasattr(self, 'stock_ok_button'): if self.stock_ok_button == 'gpodder-download': self.btnOK.set_image(gtk.image_new_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_BUTTON)) self.btnOK.set_label(_('Download')) else: self.btnOK.set_label(self.stock_ok_button) self.btnOK.set_use_stock(True) # Work around Maemo bug #4718 self.btnOK.set_name('HildonButton-finger') self.btnRemoveAction.set_name('HildonButton-finger') # Make sure the window comes up quick self.main_window.show() self.main_window.present() while gtk.events_pending(): gtk.main_iteration(False) # Determine the styling for the list items head_font = style.get_font_desc('SystemFont') head_color = style.get_color('ButtonTextColor') head = (head_font.to_string(), head_color.to_string()) head = '<span font_desc="%s" foreground="%s">%%s</span>' % head sub_font = style.get_font_desc('SmallSystemFont') sub_color = style.get_color('SecondaryTextColor') sub = (sub_font.to_string(), sub_color.to_string()) sub = '<span font_desc="%s" foreground="%s">%%s</span>' % sub self._markup_template = '\n'.join((head, sub)) # Context menu stuff for the treeview (shownotes) self.touched_episode = None if hasattr(self, 'show_episode_shownotes'): self.context_menu = gtk.Menu() # "Emulate" hildon_gtk_menu_new self.context_menu.set_name('hildon-context-sensitive-menu') self.context_menu.append(self.action_shownotes.create_menu_item()) self.context_menu.show_all() self.treeviewEpisodes.connect('button-press-event', self.on_treeview_button_press) self.treeviewEpisodes.tap_and_hold_setup(self.context_menu) # This regex gets the two lines of the normal Maemo markup, # as used on Maemo 4 (see maemo_markup() in gpodder.model) markup_re = re.compile(r'<b>(.*)</b>\n<small>(.*)</small>') next_column = self.COLUMN_ADDITIONAL for name, sort_name, sort_type, caption in self.columns: renderer = gtk.CellRendererText() if next_column < self.COLUMN_ADDITIONAL + 2: renderer.set_property('ellipsize', pango.ELLIPSIZE_END) column = gtk.TreeViewColumn(caption, renderer, markup=next_column) column.set_resizable( True) # Only set "expand" on the first column if next_column < self.COLUMN_ADDITIONAL + 1: column.set_expand(True) if sort_name is not None: column.set_sort_column_id(next_column+1) else: column.set_sort_column_id(next_column) self.treeviewEpisodes.append_column( column) next_column += 1 if sort_name is not None: # add the sort column column = gtk.TreeViewColumn() column.set_visible(False) self.treeviewEpisodes.append_column( column) next_column += 1 column_types = [ int, str, bool ] # add string column type plus sort column type if it exists for name, sort_name, sort_type, caption in self.columns: column_types.append(str) if sort_name is not None: column_types.append(sort_type) self.model = gtk.ListStore( *column_types) tooltip = None for index, episode in enumerate( self.episodes): if self.tooltip_attribute is not None: try: tooltip = getattr(episode, self.tooltip_attribute) except: log('Episode object %s does not have tooltip attribute: "%s"', episode, self.tooltip_attribute, sender=self) tooltip = None row = [ index, tooltip, self.selected[index] ] for name, sort_name, sort_type, caption in self.columns: if name.startswith('maemo_') and name.endswith('markup'): # This will fetch the Maemo 4 markup from the object # and then filter the two lines (using markup_re.match) # and use the markup template to create Maemo 5 markup markup = getattr(episode, name) args = markup_re.match(markup).groups() row.append(self._markup_template % args) elif not hasattr(episode, name): log('Warning: Missing attribute "%s"', name, sender=self) row.append(None) else: row.append(getattr( episode, name)) if sort_name is not None: if not hasattr(episode, sort_name): log('Warning: Missing attribute "%s"', sort_name, sender=self) row.append(None) else: row.append(getattr( episode, sort_name)) self.model.append( row) self.treeviewEpisodes.set_rules_hint( True) self.treeviewEpisodes.set_model( self.model) self.treeviewEpisodes.columns_autosize() self.calculate_total_size() selection = self.treeviewEpisodes.get_selection() selection.connect('changed', self.on_selection_changed) selection.set_mode(gtk.SELECTION_MULTIPLE) selection.unselect_all() appmenu = hildon.AppMenu() for action in (self.action_select_all, \ self.action_select_none): button = gtk.Button() action.connect_proxy(button) appmenu.append(button) if self.selection_buttons: for label in self.selection_buttons: button = gtk.Button(label) button.connect('clicked', self.custom_selection_button_clicked, label) appmenu.append(button) appmenu.show_all() self.main_window.set_app_menu(appmenu)
def __init__(self, wtype): self.__wtype = wtype self.__flags = 0 # widget of the windows contents self.__contents = [] # window menu if (platforms.MAEMO5): self.__menu = hildon.AppMenu() elif (platforms.MAEMO4): self.__menu = gtk.Menu() else: self.__menu = gtk.Menu() # table: name -> menu_item self.__menu_items = {} self.__size = (0, 0) self.__has_size_set = False self.__is_button_pressed = False self.__screen = None # whether this window should be stackable self.__is_stackable = False # timeout handler for handling the window configure events self.__configure_event_handler = None Widget.__init__(self) if (wtype == self.TYPE_TOPLEVEL): self.__is_stackable = True if (platforms.MAEMO5): self.__window = hildon.StackableWindow() self.__window.set_app_menu(self.__menu) # stacking is handled by Maemo5 self.__is_stackable = False elif (platforms.MAEMO4): self.__window = hildon.Window() #self.__window.set_menu(self.__menu) self.__window.fullscreen() elif (platforms.MEEGO_WETAB): self.__window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.__window.set_decorated(False) self.__window.maximize() elif (platforms.MEEGO_NETBOOK): self.__window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.__window.set_decorated(False) self.__window.maximize() #self.__window.fullscreen() #self.__window.set_size_request(gtk.gdk.screen_width(), # gtk.gdk.screen_height()) else: self.__window = gtk.Window(gtk.WINDOW_TOPLEVEL) elif (wtype == self.TYPE_SUBWINDOW): self.__is_stackable = True if (platforms.MAEMO5): self.__window = hildon.StackableWindow() self.__window.set_app_menu(self.__menu) # stacking is handled by Maemo5 self.__is_stackable = False elif (platforms.MAEMO4): self.__window = gtk.Window() #self.__window.set_decorated(False) self.__window.fullscreen() # hide some ugly separator :) #self.__window.vbox.get_children()[0].hide() elif (platforms.MEEGO_WETAB): self.__window = gtk.Window() self.__window.maximize() self.__window.set_decorated(False) elif (platforms.MEEGO_NETBOOK): self.__window = gtk.Dialog() self.__window.set_decorated(False) self.__window.maximize() #self.__window.set_size_request(gtk.gdk.screen_width(), # gtk.gdk.screen_height()) # hide some ugly separator :) self.__window.vbox.get_children()[0].hide() else: self.__window = gtk.Window(gtk.WINDOW_TOPLEVEL) # hide some ugly separator :) #self.__window.vbox.get_children()[0].hide() elif (wtype == self.TYPE_DIALOG): if (platforms.MAEMO5): self.__window = gtk.Dialog() elif (platforms.MAEMO4 or platforms.MEEGO_NETBOOK): self.__window = gtk.Dialog() # hide some ugly separator :) self.__window.vbox.get_children()[0].hide() else: self.__window = gtk.Dialog() # hide some ugly separator :) self.__window.vbox.get_children()[0].hide() # title bar on some platforms if (not platforms.MAEMO5 and wtype != self.TYPE_DIALOG): self.__title_bar = TitleBar() self.__title_bar.connect_switch(lambda: self.__window.iconify()) self.__title_bar.connect_menu(lambda: self.show_menu()) self.__title_bar.connect_close( lambda: self.emit_event(self.EVENT_CLOSED)) if (wtype == self.TYPE_SUBWINDOW): self.__title_bar.set_mode(TitleBar.MODE_SUBWINDOW) Widget.add(self, self.__title_bar) else: self.__title_bar = None self.__window.set_title(" ") self.__window.set_default_size(480, 800) #800, 480) self.__window.set_app_paintable(True) self.__window.set_double_buffered(False) self.__window.connect("configure-event", self.__on_configure) self.__window.connect("expose-event", self.__on_expose) self.__window.connect("button-press-event", self.__on_button_pressed) self.__window.connect("button-release-event", self.__on_button_released) self.__window.connect("motion-notify-event", self.__on_pointer_moved) self.__window.connect("key-press-event", self.__on_key_pressed) self.__window.connect("key-release-event", self.__on_key_released) self.__window.connect("delete-event", self.__on_close_window) self.__window.set_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) self.__window.realize() if (platforms.MAEMO5): if (wtype in [self.TYPE_TOPLEVEL, self.TYPE_SUBWINDOW]): pass #self.__set_portrait_property("_HILDON_PORTRAIT_MODE_SUPPORT", 1) else: self.__set_portrait_property("_HILDON_PORTRAIT_MODE_SUPPORT", 1) self.__layout = gtk.Fixed() self.__layout.show() try: self.__window.vbox.add(self.__layout) except: self.__window.add(self.__layout) # video screen self.__vidscreen = gtk.DrawingArea() self.__vidscreen.set_double_buffered(False) self.__vidscreen.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000")) self.__vidscreen.set_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK) self.__layout.put(self.__vidscreen, 0, 0) self.__update_window_background()
def _display_results(self, caches, truncated): sortfuncs = [ ('Dist', lambda x, y: cmp(x.prox, y.prox)), ('Name', lambda x, y: cmp(x.title, y.title)), ('Diff', lambda x, y: cmp(x.difficulty if x.difficulty > 0 else 100, y.difficulty if y.difficulty > 0 else 100)), ('Terr', lambda x, y: cmp(x.terrain if x.terrain > 0 else 100, y.terrain if y.terrain > 0 else 100)), ('Size', lambda x, y: cmp(x.size if x.size > 0 else 100, y.size if y.size > 0 else 100)), ('Type', lambda x, y: cmp(x.type, y.type)), ] if self.gps_data != None and self.gps_data.position != None: for c in caches: c.prox = c.distance_to(self.gps_data.position) else: for c in caches: c.prox = None win = hildon.StackableWindow() win.set_title("Search results") ls = gtk.ListStore(str, str, str, str, object) tv = hildon.TouchSelector() col1 = tv.append_column(ls, gtk.CellRendererText()) c1cr = gtk.CellRendererText() c1cr.ellipsize = pango.ELLIPSIZE_MIDDLE c2cr = gtk.CellRendererText() c3cr = gtk.CellRendererText() c4cr = gtk.CellRendererText() col1.pack_start(c1cr, True) col1.pack_end(c2cr, False) col1.pack_start(c3cr, False) col1.pack_end(c4cr, False) col1.set_attributes(c1cr, text=0) col1.set_attributes(c2cr, text=1) col1.set_attributes(c3cr, text=2) col1.set_attributes(c4cr, text=3) def select_cache(widget, data, more): self.show_cache(self._get_selected(tv)[4]) tv.connect("changed", select_cache, None) def on_change_sort(widget, sortfunc): tv.handler_block_by_func(select_cache) ls.clear() caches.sort(cmp=sortfunc) for c in caches: ls.append([ self.shorten_name(c.title, 40), " " + c.get_size_string(), ' D%s T%s' % (c.get_difficulty(), c.get_terrain()), " " + geo.Coordinate.format_distance(c.prox), c ]) tv.handler_unblock_by_func(select_cache) menu = hildon.AppMenu() button = None for name, function in sortfuncs: button = hildon.GtkRadioButton(gtk.HILDON_SIZE_AUTO, button) button.set_label(name) button.connect("clicked", on_change_sort, function) menu.add_filter(button) button.set_mode(False) def download_geocaches(widget): self.core.download_cache_details_list(caches) button = hildon.Button(gtk.HILDON_SIZE_AUTO, hildon.BUTTON_ARRANGEMENT_VERTICAL) button.set_title("Download Details") button.set_value("for all Geocaches") button.connect("clicked", download_geocaches) menu.append(button) menu.show_all() win.set_app_menu(menu) win.add(tv) on_change_sort(None, sortfuncs[0][1]) win.show_all() if truncated: hildon.hildon_banner_show_information_with_markup( win, "hu", "Showing only the first %d results." % len(caches)) win.connect('delete_event', self.hide_search_view)