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)
