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)
