def test_push(self): stack = hildon.WindowStack() self.assertRaises(TypeError, stack.push) self.assertRaises(TypeError, stack.push, "x") w1 = hildon.StackableWindow() w2 = hildon.StackableWindow() stack.push(w1, w2) self.assertEqual(set(stack.get_windows()), set([w1, w2]))
def test_pop(self): stack = hildon.WindowStack() self.assertRaises(TypeError, stack.pop) self.assertRaises(TypeError, stack.pop, "x") self.assertEqual(stack.pop(1), []) w1 = hildon.StackableWindow() w2 = hildon.StackableWindow() stack.push(w1, w2) self.assertEqual(set(stack.pop(2)), set([w1, w2])) self.assertEqual(stack.pop(1), [])
def test_pop_and_push(self): stack = hildon.WindowStack() self.assertRaises(TypeError, stack.pop_and_push) self.assertRaises(TypeError, stack.pop_and_push, "x") w1 = hildon.StackableWindow() w2 = hildon.StackableWindow() stack.push(w1, w2) w3 = hildon.StackableWindow() w4 = hildon.StackableWindow() self.assertRaises(TypeError, stack.pop_and_push, 2, "x") popped = stack.pop_and_push(2, w3, w4) self.assertEqual(set(popped), set([w1, w2])) popped = stack.pop_and_push(2) self.assertEqual(set(popped), set([w3, w4])) self.assertEqual(stack.pop(1), [])
def showInfo(self): import gtk import hildon win = hildon.StackableWindow() win.set_title("Info") """enlarge the tabs in the notebook vertically to be more finger friendly""" enlargeTabs = 15 versionString = info.getVersionString() if versionString is None: versionString = "unknown version" notebook = gtk.Notebook() # shortcuts need to be pannable pann = hildon.PannableArea() pann.add_with_viewport(info.getShortcutsContent()) # add shortcuts tab notebook.append_page(pann, self._getLabel("Shortcuts", enlargeTabs)) # add stats tab notebook.append_page(info.getStatsContent(self.mieru), self._getLabel("Stats", enlargeTabs)) # add about tab notebook.append_page(info.getAboutContent(versionString), self._getLabel("About", enlargeTabs)) # add the notebook to the new stackable window win.add(notebook) # show it win.show_all() # start on first page notebook.set_current_page(0)
def selection_changed(selector, user_data): current_selection = selector.get_current_text() # Create the main window win = hildon.StackableWindow() win.set_title(current_selection) for row in full_result['query']['results']['item']: name_and_price = "%s (R$%s)" % (row['nome'],row['gasolina']) if name_and_price == current_selection: textarea = gtk.TextView() textarea.set_editable(False) buffer = textarea.get_buffer() iter = buffer.get_iter_at_mark(buffer.get_insert()) buffer.insert(iter,"%s\n" % row['nome']) buffer.insert(iter,"%s, %s\n" % (row['endereco'], row['bairro'])) buffer.insert(iter,"Gasolina: R$%s\n" % row['gasolina']) buffer.insert(iter,"Alcool: R$%s\n" % row['alcool']) buffer.insert(iter,"Diesel: R$%s\n" % row['diesel']) buffer.insert(iter,"GNV: R$%s\n" % row['gnv']) vbox = gtk.VBox(False, 0) vbox.pack_start(textarea, True, True, 0) win.add(vbox) win.show_all()
def configure(widget, win): window = hildon.StackableWindow() window.set_title(settings.app_name + " - Settings") conn = sqlite3.connect(settings.db_path) c = conn.execute("select value from config where name=?", ('user',)) user = c.fetchone() conn.close() label = gtk.Label("Username") entry = hildon.Entry(gtk.HILDON_SIZE_AUTO) entry.set_max_length(64) if user is not None: entry.set_text(user[0]) save_button = hildon.Button(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_HORIZONTAL) save_button.set_text("Save new settings", "") save_button.connect("clicked", save_settings, window, win, entry) uname_box = gtk.HBox(False, 0) uname_box.pack_start(label, False, False, 20) uname_box.pack_start(entry, True, True, 10) save_box = gtk.HBox(False, 0) save_box.pack_start(save_button, True, False, 0) vbox = gtk.VBox(False, 0) vbox.pack_start(uname_box, False, False, 20) vbox.pack_start(save_box, False, False, 0) window.add(vbox) window.show_all()
def showOptions(self): import gtk import hildon win = hildon.StackableWindow() win.set_title("Options") padding = 5 vbox = gtk.VBox(False, padding) # page fitting pLabel = gtk.Label("Page") fitPickerButton = self._getFittingPickerButton("Page fitting") vbox.pack_start(pLabel, False, False, padding * 2) vbox.pack_start(fitPickerButton, False, False, 0) # GUI rotation rLabel = gtk.Label("GUI Rotation") rPickerButton = self._getRotationPickerButton("Rotation mode") vbox.pack_start(rLabel, False, False, padding * 2) vbox.pack_start(rPickerButton, False, False, 0) # kinetic scrolling ksLabel = gtk.Label("Scrolling") ksButton = self.CheckButton("Kinetic scrolling") ksButton.set_active(self.mieru.get('kineticScrolling', True)) ksButton.connect('toggled', self._toggleOptionCB, 'kineticScrolling', False) self.mieru.watch('kineticScrolling', self._updateKSCB, ksButton) vbox.pack_start(ksLabel, False, False, padding * 2) vbox.pack_start(ksButton, False, False, 0) # history hLabel = gtk.Label("History") removeItemPB = self._getRIFHPickerButton() clearHistoryButton = self.Button("Erase history") warning = "Are you sure that you want to completely erase history ?" clearHistoryButton.connect('clicked', self.areYouSureButtonCB, warning, (self._clearHistory, [])) vbox.pack_start(hLabel, False, False, padding * 2) vbox.pack_start(removeItemPB, False, False, 0) vbox.pack_start(clearHistoryButton, False, False, 0) # debug debugLabel = gtk.Label("Debug") debug1Button = self.CheckButton("Print page loading info") debug1Button.set_active(self.mieru.get('debugPageLoading', False)) debug1Button.connect('toggled', self._toggleOptionCB, 'debugPageLoading', False) vbox.pack_start(debugLabel, False, False, padding * 2) vbox.pack_start(debug1Button, False, False, 0) # as options are too long, add a pannable area pan = hildon.PannableArea() pan.add_with_viewport(vbox) win.add(pan) win.show_all()
def basic_window(m): window = hildon.StackableWindow() window.set_border_width(3) #window.maximize() m.window = window table = m.interior() window.add(table) window.show_all() m.window.connect("delete-event", lambda _, _1: m.close())
def __init__(self, mieru, type, size=(800, 480)): gui.GUI.__init__(self, mieru) if type == "hildon": import hildon self.window = hildon.StackableWindow() else: self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.resize(*size) self.window.connect("destroy", self._destroyCB) self.vbox = gtk.VBox(False, 2) self.window.add(self.vbox) self.fullscreen = False
def set_lang(widget, langs): sel = [None] def selection_changed(selector, seltype): __import__("sentences.sentences_"+selector.get_current_text()) saera_processing.sent = sys.modules["sentences.sentences_"+selector.get_current_text()] stack = hildon.WindowStack.get_default() stack.pop_1() lwin = hildon.StackableWindow() selector = hildon.TouchSelector(text = True) selector.connect("changed", selection_changed) for i in langs: selector.append_text(i) selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE) lwin.add(selector) lwin.show_all()
def main(): program = hildon.Program.get_instance() gtk.set_application_name("hildon-touch-selector example program") window = hildon.StackableWindow() program.add_window(window) # Create touch selector selector = create_simple_selector() window.add(selector) window.connect("destroy", app_quit) window.show_all() gtk.main()
def main(): program = hildon.Program.get_instance() # Create the main window win = hildon.StackableWindow() win.set_title("Welcome to Maemo Leste") button = gtk.Button("Go to subview") win.add(button) button.connect("clicked", show_new_window) win.connect("destroy", gtk.main_quit, None) # This call show the window and also add the window to the stack win.show_all() gtk.main()
def main(): Setup() logging.basicConfig(filename=os.path.expanduser(settings.log_file), filemode='w', format=settings.log_format, level=logging.getLevelName(settings.log_level)) gtk.set_application_name(settings.app_name) program = hildon.Program.get_instance() win = hildon.StackableWindow() win.set_title(settings.app_name) win.connect("destroy", gtk.main_quit, None) hildon.hildon_gtk_window_set_progress_indicator(win, 1) win.show_all() pannable_area = hildon.PannableArea() conn = sqlite3.connect(settings.db_path) c = conn.execute("select value from config where name=?", ('user',)) user = c.fetchone() conn.close() if user is None: message = "No user set up in database." logging.error("%s" % message) message += " Please go to Settings and enter a username." info = hildon.hildon_note_new_information(win, message) response = gtk.Dialog.run(info) if response == gtk.RESPONSE_DELETE_EVENT: info.destroy() try: if user is not None: user = user[0] logging.info("Loading notices for %s" % user) nf = NoticeFetcher(user) nf.fetch() except Exception, e: message = "Problem loading notices. Is the network down?" logging.error("%s | %s" % (message, e)) hildon.hildon_banner_show_information(pannable_area, '', message)
def __init__(self): self.lines = [['What can I help you with?', False]] try: program = hildon.Program.get_instance() self.win = hildon.StackableWindow() rotation_object = FremantleRotation(app_name, self.win, app_version, initial_mode) program.add_window(self.win) except: print "No hildon win" self.win = gtk.Window() self.win.set_size_request(400, 550) self.win.set_title("Saera") self.vbox = gtk.VBox() self.win.add(self.vbox) self.input = gtk.Entry() self.darea = gtk.DrawingArea() self.vbox.pack_start(self.input, False, True, 0) self.vbox.pack_start(self.darea, True, True, 0) self.darea.add_events(gtk.gdk.EXPOSURE_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK) self.input.connect('activate', self.run_saera) self.darea.connect("expose-event", self.expose_event) self.darea.connect("button-press-event", self.button_press_event) try: self.bgimage = cairo.ImageSurface.create_from_png("saera_bg.png") self.micimage = cairo.ImageSurface.create_from_png("siri_mic.png") self.micpulse = cairo.ImageSurface.create_from_png( "siri_mic_spinner.png") self.cbgimage = cairo.ImageSurface.create_from_png( "saera_chat_bg.png") except Exception, e: print e.message sys.exit(1)
def __init__(self): # hildon has one program instance per app, so get instance self.p = hildon.Program.get_instance() # set name of application: this shows in titlebar gtk.set_application_name("Maemo GStreamer VideoTest") # stackable window in case we want more windows in future in app self.w = hildon.StackableWindow() box = gtk.VBox() self.video_widget = VideoWidget() # video widget we want to expand to size box.pack_start(self.video_widget, True, True, 0) # a button finger height to play/pause self.button = hildon.Button(gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_VERTICAL, title="Pause") self.button.connect_after("clicked", self.on_button_clicked) # don't want button to expand or fill, just stay finger height box.pack_start(self.button, False, False, 0) self.w.add(box) self.w.connect("delete-event", gtk.main_quit) self.p.add_window(self.w) self.w.show_all() self.start_streaming()
def __init__(self, fname, standalone=False, spawner=None): self.cont = fMMSController.fMMS_controllerGTK() self.ch = ContactH.ContactHandler() self.standalone = standalone self.config = self.cont.config self._mmsdir = self.config.get_mmsdir() self._pushdir = self.config.get_pushdir() self._outdir = self.config.get_outdir() self.osso_c = osso.Context("se.frals.fmms_ui", self.config.get_version(), False) self.spawner = spawner self.window = hildon.StackableWindow() self.window.set_title("MMS") self.window.connect("delete_event", self.quit) vbox = gtk.VBox() pan = hildon.PannableArea() pan.set_property("mov-mode", hildon.MOVEMENT_MODE_BOTH) self._direction = self.cont.get_direction_mms(fname) self._parse_mms(fname, vbox) pan.add_with_viewport(vbox) align = gtk.Alignment(1, 1, 1, 1) align.set_padding(2, 2, 10, 10) align.add(pan) self.window.add(align) if not self.cont.is_mms_read(fname) and self._direction == fMMSController.MSG_DIRECTION_IN: self.cont.mark_mms_read(fname) if self.spawner: self.spawner.refreshlistview = True mms_menu = self.create_mms_menu(fname) self.window.set_app_menu(mms_menu) self.window.show_all()
def open_settings(self): def set_lang(widget, langs): sel = [None] def selection_changed(selector, seltype): __import__("sentences.sentences_"+selector.get_current_text()) saera_processing.sent = sys.modules["sentences.sentences_"+selector.get_current_text()] stack = hildon.WindowStack.get_default() stack.pop_1() lwin = hildon.StackableWindow() selector = hildon.TouchSelector(text = True) selector.connect("changed", selection_changed) for i in langs: selector.append_text(i) selector.set_column_selection_mode(hildon.TOUCH_SELECTOR_SELECTION_MODE_SINGLE) lwin.add(selector) lwin.show_all() try: win = hildon.StackableWindow() except NameError: win = gtk.Window() win.set_modal(True) win.set_transient_for(self.win) win.set_title("Settings") vbox = gtk.VBox() win.add(vbox) langs = [i.split("_")[1].split(".")[0] for i in os.listdir('sentences') if (i.endswith('.py') and not 'init' in i)] try: langbut = hildon.GtkButton(gtk.HILDON_SIZE_AUTO_WIDTH | gtk.HILDON_SIZE_FINGER_HEIGHT) langbut.set_label("Language") langbut.connect("clicked", set_lang, langs) vbox.pack_start(langbut, True, False, 0) except NameError: cbox = gtk.combo_box_new_text() for i in langs: cbox.append_text(i) vbox.pack_start(cbox, True, False, 0) win.show_all()
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)
def setUp(self): self.window = hildon.StackableWindow()
def test_get_windows(self): stack = hildon.WindowStack() w = hildon.StackableWindow() stack.push_1(w) self.assertEqual(stack.get_windows(), [w])
def __init__(self, settings, filename=None): self.__log = logging.getLogger('panucci.panucci.PanucciGUI') interface.register_gui(self) self.config = settings.config self.playlist = playlist.Playlist(self.config) # Build the base ui (window and menubar) if platform.MAEMO: self.app = hildon.Program() if platform.FREMANTLE: window = hildon.StackableWindow() else: window = hildon.Window() self.app.add_window(window) else: window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.main_window = window window.set_title('Panucci') self.window_icon = util.find_data_file('panucci.png') if self.window_icon is not None: window.set_icon_from_file(self.window_icon) window.set_default_size(400, -1) window.set_border_width(0) window.connect("destroy", self.destroy) # Add the tabs (they are private to prevent us from trying to do # something like gui_root.player_tab.some_function() from inside # playlist_tab or vice-versa) self.__player_tab = PlayerTab(self) self.__playlist_tab = gtkplaylist.PlaylistTab(self, self.playlist) self.create_actions() if platform.FREMANTLE: self.playlist_window = hildon.StackableWindow() self.playlist_window.set_app_menu(self.create_playlist_app_menu()) else: self.playlist_window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.playlist_window.connect('delete-event', gtk.Widget.hide_on_delete) self.playlist_window.set_title(_('Playlist')) self.playlist_window.set_transient_for(self.main_window) self.playlist_window.add(self.__playlist_tab) if platform.MAEMO: if platform.FREMANTLE: window.set_app_menu(self.create_app_menu()) else: window.set_menu(self.create_menu()) window.add(self.__player_tab) else: menu_vbox = gtk.VBox() menu_vbox.set_spacing(0) window.add(menu_vbox) menu_bar = gtk.MenuBar() self.create_desktop_menu(menu_bar) menu_vbox.pack_start(menu_bar, False, False, 0) menu_bar.show() menu_vbox.pack_end(self.__player_tab, True, True, 6) # Tie it all together! self.__ignore_queue_check = False self.__window_fullscreen = False if platform.MAEMO and interface.headset_device: # Enable play/pause with headset button import dbus interface.headset_device.connect_to_signal('Condition', \ self.handle_headset_button) system_bus = dbus.SystemBus() # Monitor connection state of BT headset # I haven't seen this option before "settings.play_on_headset" PATH = '/org/freedesktop/Hal/devices/computer_logicaldev_input_1' def handler_func(device_path): if device_path == PATH and settings.play_on_headset and not self.playlist.player.playing: self.playlist.player.play() system_bus.add_signal_receiver(handler_func, 'DeviceAdded', \ 'org.freedesktop.Hal.Manager', None, \ '/org/freedesktop/Hal/Manager') # End Monitor connection state of BT headset # Monitor BT headset buttons def handle_bt_button(signal, button): # See http://bugs.maemo.org/8283 for details if signal == 'ButtonPressed': if button == 'play-cd': self.playlist.player.play_pause_toggle() elif button == 'pause-cd': self.playlist.player.pause() elif button == 'next-song': self.__player_tab.do_seek( self.config.getint("options", "seek_short")) elif button == 'previous-song': self.__player_tab.do_seek( -1 * self.config.getint("options", "seek_short")) system_bus.add_signal_receiver(handle_bt_button, 'Condition', \ 'org.freedesktop.Hal.Device', None, PATH) # End Monitor BT headset buttons self.main_window.connect('key-press-event', self.on_key_press) self.playlist.register('file_queued', self.on_file_queued) self.playlist.register('playlist-to-be-overwritten', self.check_queue) self.__player_tab.register('select-current-item-request', self.__select_current_item) self.main_window.show_all() # this should be done when the gui is ready self.playlist.init(filepath=filename) pos_int, dur_int = self.playlist.player.get_position_duration() # This prevents bogus values from being set while seeking if (pos_int > 10**9) and (dur_int > 10**9): self.set_progress_callback(pos_int, dur_int) gtk.main()
def __init__(self, *args, **kwargs): GUIModule.__init__(self, *args, **kwargs) # some constants self.msLongPress = 400 # window state self.fullscreen = False # map center shifting variables self.centerShift = (0, 0) self.expandViewportTiles = 0.0 # viewport self.viewportWH = (0,0) """ NOTE: we are calling the device module through the main class as it otherwise is first available in firstTime """ # create the GTK window # when on N900, use a hildon StackableWindow, which # enables app menu and other features on Maemo 5 if self.modrana.dmod.device_id == 'n900': try: import hildon win = hildon.StackableWindow() except Exception: self.log.exception("creating hildon stackable window failed") win = gtk.Window() else: win = gtk.Window() self.win = win win.connect("destroy", self._destroyCB) # register centering.shift callbacks self._registerCenteringShiftCallbacks() # resize it to preferred width x height (w, h) = self.modrana.dmod.window_wh self.resize(w, h) self.modrana.addTime("window created") # set title self.setWindowTitle("modRana") # connect delete event win.connect('delete-event', gtk.main_quit) ## Instantiate the main widget ## self.mw = MainWidget(self) self.mw.topWindow = win # make the main window accessible from modules self.topWindow = win self.modrana.addTime("map widget created") # check if we should start in fullscreen if self.shouldStartInFullscreen(): self.setFullscreen(True) # Event handling event_box = gtk.EventBox() event_box.connect("button_press_event", self.mw.pressed) event_box.connect("button_release_event", self.mw.released) event_box.connect("scroll_event", self.mw.scrolled) event_box.connect("motion_notify_event", self.mw.moved) win.add(event_box) # add redraw request watch self.watch('needRedraw', self.mw._checkForRedrawCB) # react on redraw requests # TODO: add a function for directly requesting redraw event_box.add(self.mw) # Finalise the window win.show_all() self.modrana.addTime("window finalized")
def __init__(self): """ Initializes the GUI, creating all widgets. """ self.cont = fMMSController.fMMS_controllerGTK() self.config = self.cont.config self.ch = ContactH.ContactHandler() self.osso_c = osso.Context("se.frals.fmms", self.config.get_version(), False) self.osso_rpc = osso.Rpc(self.osso_c) self.osso_rpc.set_rpc_callback("se.frals.fmms", "/se/frals/fmms", "se.frals.fmms", self.cb_open_fmms, self.osso_c) self.refreshlistview = True self.viewerimported = False self.senderimported = False self._screenwidth = 800 self.avatarlist = {} self.namelist = {} self.nrlist = {} hildon.Program.__init__(self) program = hildon.Program.get_instance() self.window = hildon.StackableWindow() hildon.hildon_gtk_window_set_portrait_flags( self.window, hildon.PORTRAIT_MODE_SUPPORT) gtk.set_application_name("fMMS") self.window.set_title("fMMS") program.add_window(self.window) self.window.connect("delete_event", self.quit) self.pan = hildon.PannableArea() self.pan.set_property("mov-mode", hildon.MOVEMENT_MODE_VERT) # wonder how much memory this is wasting self.iconcell = gtk.CellRendererPixbuf() self.photocell = gtk.CellRendererPixbuf() self.textcell = gtk.CellRendererText() self.photocell.set_property('xalign', 1.0) self.textcell.set_property('mode', gtk.CELL_RENDERER_MODE_INERT) self.textcell.set_property('xalign', 0.0) self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, gtk.gdk.Pixbuf, str, str, str) self.treeview = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL) self.treeview.set_property("fixed-height-mode", True) self.treeview.set_model(self.liststore) # create ui self._create_ui() self.treeview.tap_and_hold_setup(self.liststore_mms_menu()) self.treeview.tap_and_hold_setup(None) self.tapsignal = self.treeview.connect('hildon-row-tapped', self.show_mms) self.treeview.connect('button-press-event', self.cb_button_press) mmsBox = gtk.HBox() icon_theme = gtk.icon_theme_get_default() envelopePixbuf = icon_theme.load_icon("general_sms_button", 48, 0) envelopeImage = gtk.Image() envelopeImage.set_from_pixbuf(envelopePixbuf) envelopeImage.set_alignment(1, 0.5) mmsLabel = gtk.Label( gettext.ldgettext('rtcom-messaging-ui', "messaging_ti_new_mms")) mmsLabel.set_alignment(0, 0.5) mmsBox.pack_start(envelopeImage, True, True, 0) mmsBox.pack_start(mmsLabel, True, True, 0) newMsgButton = hildon.Button(gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_HORIZONTAL) newMsgButton.add(mmsBox) newMsgButton.connect('clicked', self.new_mms_button_clicked) """ gets the newMsgButton on top of the treeview """ actionbox = self.treeview.get_action_area_box() self.treeview.set_action_area_visible(True) actionbox.add(newMsgButton) self.pan.add(self.treeview) self.livefilter = hildon.LiveSearch() modelfilter = self.liststore.filter_new() modelfilter.set_visible_func(self.cb_filter_row) self.treeview.set_model(modelfilter) self.livefilter.set_filter(modelfilter) self.livefilter.widget_hook(self.window, self.treeview) contBox = gtk.VBox() contBox.pack_start(self.pan, True, True, 0) contBox.pack_start(self.livefilter, False, False, 0) align = gtk.Alignment(1, 1, 1, 1) align.set_padding(2, 2, 10, 10) align.add(contBox) self.window.add(align) menu = self.cont.create_menu(self.window) self.window.set_app_menu(menu) self.window.connect('focus-in-event', self.cb_on_focus) self.window.connect('configure-event', self._onOrientationChange) self.window.show_all() self.add_window(self.window)
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 __init__(self, spawner=None, tonumber=None, withfile=None, subject=None, message=None, forward=None): hildon.Program.__init__(self) program = hildon.Program.get_instance() self.ch = ContactH.ContactHandler() self.cont = fMMSController.fMMS_controllerGTK() self.config = self.cont.config self.subject = subject self.osso_c = osso.Context("fMMS", "1.0", False) self.window = hildon.StackableWindow() self.window.set_title( gettext.ldgettext('rtcom-messaging-ui', "messaging_ti_new_mms")) if subject: try: self.window.set_title(subject) except: pass program.add_window(self.window) self.window.connect("delete_event", self.quit) self.attachmentFile = "" draftfile = False # got spawner and not a forward and not a reply if spawner != None and forward == None and tonumber == None: self.spawner = spawner (tonumber, message, tmpfn) = self.cont.get_draft() if tmpfn != "" and tmpfn != "None" and os.path.isfile(tmpfn): withfile = tmpfn self.attachmentFile = tmpfn draftfile = True # forwarding/replying message elif spawner != None and (forward or tonumber != None): self.spawner = spawner else: self.spawner = self.window allBox = gtk.VBox() """ Begin top section """ topHBox1 = gtk.HBox() bTo = hildon.Button(gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_HORIZONTAL, \ gettext.ldgettext('rtcom-messaging-ui', "messaging_fi_new_sms_to")) bTo.connect('clicked', self.open_contacts_dialog) bTo.set_size_request(128, gtk.HILDON_SIZE_FINGER_HEIGHT) self.eNumber = hildon.Entry(gtk.HILDON_SIZE_FINGER_HEIGHT) if tonumber != None: self.eNumber.set_text(tonumber) self.bSend = hildon.Button(gtk.HILDON_SIZE_FINGER_HEIGHT, hildon.BUTTON_ARRANGEMENT_HORIZONTAL) self.bSend.connect('clicked', self.send_mms_clicked) icon_theme = gtk.icon_theme_get_default() sendPixbuf = icon_theme.load_icon("email_message_send", 48, 0) sendImage = gtk.Image() sendImage.set_from_pixbuf(sendPixbuf) #sendImage.set_alignment(1, 0.5) self.bSend.set_image(sendImage) self.bSend.set_size_request(128, gtk.HILDON_SIZE_FINGER_HEIGHT) topHBox1.pack_start(bTo, False, True, 0) topHBox1.pack_start(self.eNumber, True, True, 5) topHBox1.pack_start(self.bSend, False, True, 0) """ Begin midsection """ pan = hildon.PannableArea() pan.set_property("mov-mode", hildon.MOVEMENT_MODE_BOTH) midBox = gtk.VBox() centerBox = gtk.HBox() self.imageBox = gtk.EventBox() self.imageBox.set_size_request(400, 200) self.imageBoxContent = gtk.Fixed() border = gtk.Image() border.set_from_file("/opt/fmms/dotted_border.png") addimglabel = gtk.Label( gettext.ldgettext('modest', "mcen_me_editor_attach_inlineimage")) addimglabel.set_justify(gtk.JUSTIFY_CENTER) addimglabel.set_size_request(300, 50) self.imageBoxContent.put(border, 0, 0) self.imageBoxContent.put(addimglabel, 50, 100) self.imageBox.add(self.imageBoxContent) self.imageBox.connect('button-press-event', self.open_file_dialog) centerBox.pack_start(self.imageBox, True, False, 0) self.tvMessage = hildon.TextView() self.tvMessage.set_property("name", "hildon-fullscreen-textview") self.tvMessage.set_wrap_mode(gtk.WRAP_WORD_CHAR) self.tvMessage.set_justification(gtk.JUSTIFY_LEFT) if message != None and message != '': tb = gtk.TextBuffer() tb.set_text(message) self.tvMessage.set_buffer(tb) midBox.pack_start(centerBox) midBox.pack_start(self.tvMessage) pan.add_with_viewport(midBox) # Copy the file to our tempdir in case sharing service removes it if withfile and not draftfile: filename = os.path.basename(withfile) dst = "%s/%s" % (self.config.get_imgdir(), filename) log.info("Copying file to: %s" % dst) copy(withfile, dst) self.attachmentFile = dst self.fromSharingService = True self.fromSharingFile = dst if withfile or draftfile: try: self.set_thumbnail(self.attachmentFile) except: log.exception("wtf: %s" % self.attachmentFile) """ Show it all! """ allBox.pack_start(topHBox1, False, False) allBox.pack_start(pan, True, True) #allBox.pack_start(self.botHBox, False, False) align = gtk.Alignment(1, 1, 1, 1) align.set_padding(2, 2, 10, 10) align.add(allBox) self.window.add(align) self.window.show_all() self.menu = self.cont.create_menu(self.window) self.window.set_app_menu(self.menu) self.add_window(self.window) # so appearently throwing an exception here # makes osso-abook always load the contacts... self.this_doesnt_exist()
def unrelayout(): self._in_relayout = False return False gobject.idle_add(unrelayout) gobject.type_register(TagCloud) if __name__ == '__main__': l = TagCloud(tags) try: import hildon w = hildon.StackableWindow() sw = hildon.PannableArea() except: w = gtk.Window() w.set_default_size(600, 300) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) w.set_title('Tag cloud Demo') w.add(sw) sw.add(l) def on_tag_selected(cloud, tag): print 'tag selected:', tag l.connect('selected', on_tag_selected)