def run(widget):
if (has_hildon):
print "+++ Hildon, yay!"
widget.app = hildon.Program()
window = hildon.Window()
gtk.set_application_name(widget.display_name)
else:
print "--- No Hildon, sorry"
window = gtk.Window()
window.set_title(widget.display_name)
widget.app_window = window
window.resize(800, 480)
window.add(widget)
window.connect("delete-event", gtk.main_quit)
window.connect("window-state-event", widget.do_window_state_event)
window.connect("focus-in-event", widget.do_focus_in_event)
window.connect("property-notify-event", widget.do_property_event)
if (has_osso):
print "+++ Have osso, yay!"
try:
osso_context = osso.Context(widget.dbus_name, widget.version, False)
device = osso.DeviceState(osso_context)
device.set_device_state_callback(state_change, system_inactivity=True, user_data=widget)
except:
print "*** Failed to initialise OSSO context. Power management disabled..."
has_osoo = False
window.present()
widget.show()
gtk.main()
def new_window():
w = ScanWindow()
w.connect("destroy", _destroy_callback)
if is_maemo():
import hildon
hildon_app = hildon.Program()
hildon_app.add_window(w)
open_windows.append(w)
return w
def main():
osso_c = osso.Context("osso_test_app", "0.0.1", False)
print "osso_test_app started"
program = hildon.Program()
window = hildon.Window()
label = gtk.Label("Sample app")
window.add(label)
window.show_all()
gtk.main()
def adjust_to_hildon(self):
"""Adjust the GUI to be usable in maemo platform."""
if is_hildon:
self.app = hildon.Program()
hildon_main_window = self.create_main_window()
self.app.add_window(hildon_main_window)
gtk_main_vbox = self.glade_xml.get_widget('main_vbox')
gtk_main_vbox.reparent(hildon_main_window)
main_menu = self.glade_xml.get_widget('main_menu')
main_menu.destroy()
gtk_main_window = self.glade_xml.get_widget('main_window')
gtk_main_window.destroy()
def __init__(self):
hildon.Window.__init__(self)
self.app = hildon.Program()
self.app.add_window(self)
self.set_title("PyGTK+ Code Demos")
self.connect('destroy', lambda w: gtk.main_quit())
#self.set_default_size(800, 400)
hbox = gtk.HBox(False, 3)
self.add(hbox)
treeview = self.__create_treeview()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(treeview)
hbox.pack_start(scroll, False, False)
self.notebook = gtk.Notebook()
hbox.pack_start(self.notebook, expand=True)
scrolled_window, self.info_buffer = self.__create_text(False)
self._new_notebook_page(scrolled_window, '_Info')
tag = self.info_buffer.create_tag('title')
tag.set_property('font', 'Sans 18')
scrolled_window, self.source_buffer = self.__create_text(True)
self._new_notebook_page(scrolled_window, '_Source')
tag = self.source_buffer.create_tag('source')
tag.set_property('font', 'monospace')
tag.set_property('pixels_above_lines', 0)
tag.set_property('pixels_below_lines', 0)
tag = self.source_buffer.create_tag('keyword', foreground='#00007F',
weight=pango.WEIGHT_BOLD)
tag = self.source_buffer.create_tag('string', foreground='#7F007F')
tag = self.source_buffer.create_tag('comment', foreground='#007F00',
style=pango.STYLE_ITALIC)
self.path = None
self.connect("key-press-event", self.key_press_cb, treeview)
self.show_all()
def __create_show_main_window(self):
try:
if option_parser.get_inventory():
from umit.inventory.Viewer import InventoryViewer
self.main_window = InventoryViewer()
else:
from umit.gui.MainWindow import MainWindow
self.main_window = MainWindow()
except Exception:
# If any exception happens at this point we need to stop gtk
# so Umit doesn't hang.
import gtk
gtk.main_quit()
raise
if is_maemo():
import hildon
self.hildon_app = hildon.Program()
self.hildon_app.add_window(self.main_window)
self.main_window.show_all()
if not expose_conf.show_toolbar:
self.main_window.toolbar.hide_all()
def main():
program = hildon.Program()
window = hildon.Window()
window.connect('destroy', gtk.main_quit)
window.set_title("Help example")
osso_c = osso.Context("osso_test_help", "0.0.1", False)
osso_hlp = osso.Help(osso_c)
vbox = gtk.VBox(True)
button = gtk.Button("Click to open a dialog with help button")
button.connect("clicked", button_handler, osso_hlp)
vbox.pack_start(button)
button = gtk.Button("Click to open help")
button.connect("clicked", show_help, osso_hlp)
vbox.pack_start(button)
window.add(vbox)
window.show_all()
gtk.main()
import hildon
class EditableLabel(gtk.Entry, gtk.Editable):
def __init__(self, text):
gtk.Entry.__init__(self, 100)
self.set_text(text)
def do_do_delete_text(self, start_pos, end_pos):
print "do_do_delete_text", start_pos, end_pos
gtk.Entry.do_do_delete_text(self, start_pos, end_pos)
gobject.type_register(EditableLabel)
if __name__ == '__main__':
app = hildon.Program()
w = hildon.Window()
app.add_window(w)
vbox = gtk.VBox()
w.add(vbox)
label = EditableLabel("Foo Bar Zbr")
vbox.add(label)
bt = gtk.Button("delete word")
def delete_word(bt):
label.delete_text(4, 7)
bt.connect("clicked", delete_word)
vbox.add(bt)
w.connect("destroy", lambda w: gtk.main_quit())
w.show_all()
gtk.main()
def __init__(self):
#self.printlog ("starting up")
self.program = None
if istablet:
self.program = hildon.Program()
self.program.__init__()
self.client = None
self._connected = False
# message handling variables
self._data_buf = None
self._data_channel = ""
self._recv_mode = "channel"
self._datalen_buf = ""
self._datalen = 0
self._data_received = 0
self._screenshot_count = 0
self.messages = []
self.gate_labels = {} # an empty dictionary
self.features_param = None
self.map_list = None
self.logger_info = None
self.heartbeat_time = .0
if istablet:
self.bpp = 16
else:
self.bpp = 24
# make the hildon window and add to the program
self.window = None
if istablet:
self.window = hildon.Window()
else:
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Navguide")
self.window.connect("destroy", gtk.main_quit)
if istablet:
self.program.add_window(self.window)
# read glade file
self.wTree = gtk.glade.XML(GLADE_FILE)
# status icon
self.status_icon = self.wTree.get_widget("status_icon")
#reparent the vbox1 from glade to self.window
self.vbox1 = self.wTree.get_widget("vbox1")
self.reparent_loc(self.vbox1, self.window)
#get menu from glade and reparent as common menu in hildon program
self.menuGlade = self.wTree.get_widget("menu1")
if istablet and self.menuGlade:
self.program.set_common_menu(self.menuGlade)
# quit button
self.menuItem_quit = self.wTree.get_widget("quit")
if self.menuItem_quit:
self.menuItem_quit.connect("clicked", gtk.main_quit)
# calib_start button
self.calib_start_button = self.wTree.get_widget("calib_start")
if (self.calib_start_button):
self.calib_start_button.connect("clicked", self.on_calib_start)
# calib_process button
self.calib_process_button = self.wTree.get_widget("calib_process")
if (self.calib_process_button):
self.calib_process_button.connect("clicked", self.on_calib_process)
# calib_check button
self.calib_check_button = self.wTree.get_widget("calib_check")
if (self.calib_check_button):
self.calib_check_button.connect("clicked", self.on_calib_check)
# calib_stop check button
self.calib_stop_check_button = self.wTree.get_widget(
"calib_stop_check")
if (self.calib_stop_check_button):
self.calib_stop_check_button.connect("clicked",
self.on_calib_stop_check)
# start record button
self.start_record_button = self.wTree.get_widget("start_record")
if (self.start_record_button):
self.start_record_button.connect("clicked", self.on_start_record)
# stop record button
self.stop_record_button = self.wTree.get_widget("stop_record")
if (self.stop_record_button):
self.stop_record_button.connect("clicked", self.on_stop_record)
# start system
if self.wTree.get_widget("start_system"):
self.wTree.get_widget("start_system").connect(
"clicked", self.on_start_system)
# stop system
if self.wTree.get_widget("stop_system"):
self.wTree.get_widget("stop_system").connect(
"clicked", self.on_stop_system)
# enable/disable features
self.enable_features = self.wTree.get_widget("enable_features")
if (self.enable_features):
self.enable_features.connect("toggled",
self.on_enable_features_toggled)
# system reset menu
self.reset_button = self.wTree.get_widget("system_reset")
if (self.reset_button):
self.reset_button.connect("activate", self.on_system_reset)
# system shutdown menu
self.shutdown_button = self.wTree.get_widget("system_shutdown")
if (self.shutdown_button):
self.shutdown_button.connect("activate", self.on_system_shutdown)
# imu reset menu
self.imu_reset_button = self.wTree.get_widget("imu_reset")
if (self.imu_reset_button):
self.imu_reset_button.connect("activate", self.on_imu_reset)
# camera reset menu
self.camera_reset_button = self.wTree.get_widget("camera_reset")
if (self.camera_reset_button):
self.camera_reset_button.connect("activate", self.on_camera_reset)
# screenshot menu
self.screenshot_button = self.wTree.get_widget("screenshot")
if self.screenshot_button:
self.screenshot_button.connect("clicked", self.on_screenshot)
# start homing
homing_button = self.wTree.get_widget("homing")
if homing_button:
homing_button.connect("clicked", self.on_homing)
# start replay
replay_button = self.wTree.get_widget("replay")
if replay_button:
replay_button.connect("clicked", self.on_replay)
# start exploration
start_exp_button = self.wTree.get_widget("start_exploration")
if start_exp_button:
start_exp_button.connect("clicked", self.on_start_exploration)
# add node
add_node_button = self.wTree.get_widget("map_add_node")
if add_node_button:
add_node_button.connect("clicked", self.on_add_node)
# new gate
self.new_gate_button = self.wTree.get_widget("new_gate")
if self.new_gate_button:
self.new_gate_button.connect("clicked", self.on_new_gate)
# feature type
self.feature_type_combo = self.wTree.get_widget("features_type")
if self.feature_type_combo:
self.feature_type_combo.connect("changed",
self.on_features_type_changed)
# viewer display mode
self.viewer_display_mode_combo = self.wTree.get_widget(
"viewer_display_mode")
if self.viewer_display_mode_combo:
self.viewer_display_mode_combo.connect(
"changed", self.on_viewer_display_mode_changed)
# feature enable/disable
self.feature_enable_combo = self.wTree.get_widget("features_enabled")
if self.feature_enable_combo:
self.feature_enable_combo.connect("changed",
self.on_features_enabled_changed)
# video mode
self.video_mode_combo = self.wTree.get_widget("video_mode")
if self.video_mode_combo:
self.video_mode_combo.connect("changed",
self.on_video_mode_changed)
# demo level
self.class_demo_level_combo = self.wTree.get_widget("class_demo_level")
if self.class_demo_level_combo:
self.class_demo_level_combo.connect(
"changed", self.on_class_demo_level_changed)
# checkpoint revisit
self.checkpoint_revisit_button = self.wTree.get_widget(
"checkpoint_revisit")
if self.checkpoint_revisit_button:
self.checkpoint_revisit_button.connect("clicked",
self.on_checkpoint_revisit)
# checkpoint create
self.checkpoint_create_button = self.wTree.get_widget(
"checkpoint_create")
if self.checkpoint_create_button:
self.checkpoint_create_button.connect("clicked",
self.on_checkpoint_create)
# label this place
self.map_apply_label_button = self.wTree.get_widget("map_apply_label")
if self.map_apply_label_button:
self.map_apply_label_button.connect("clicked",
self.on_map_apply_label)
# set label filter callback
entry = self.wTree.get_widget("label_filter")
if entry:
entry.connect("activate", self.populate_label_window)
# refresh video button
if self.wTree.get_widget("video_refresh"):
self.wTree.get_widget("video_refresh").connect(
"clicked", self.on_video_refresh)
# map
if self.wTree.get_widget("map_zoom_in"):
self.wTree.get_widget("map_zoom_in").connect(
"clicked", self.on_map_zoom_in)
if self.wTree.get_widget("map_zoom_out"):
self.wTree.get_widget("map_zoom_out").connect(
"clicked", self.on_map_zoom_out)
if self.wTree.get_widget("map_center_start"):
self.wTree.get_widget("map_center_start").connect(
"clicked", self.on_map_center_start)
if self.wTree.get_widget("map_center_end"):
self.wTree.get_widget("map_center_end").connect(
"clicked", self.on_map_center_end)
if self.wTree.get_widget("map_move_left"):
self.wTree.get_widget("map_move_left").connect(
"clicked", self.on_map_move)
if self.wTree.get_widget("map_move_top"):
self.wTree.get_widget("map_move_top").connect(
"clicked", self.on_map_move)
if self.wTree.get_widget("map_move_right"):
self.wTree.get_widget("map_move_right").connect(
"clicked", self.on_map_move)
if self.wTree.get_widget("map_move_bottom"):
self.wTree.get_widget("map_move_bottom").connect(
"clicked", self.on_map_move)
if self.wTree.get_widget("map_labels"):
self.wTree.get_widget("map_labels").connect(
"toggled", self.on_map_label_toggled)
if self.wTree.get_widget("map_fancy"):
self.wTree.get_widget("map_fancy").connect(
"toggled", self.on_map_fancy_toggled)
# connect button
self.wTree.get_widget("connect").connect("clicked", self.on_connect)
#destroy the gtk window imported from glade
self.gtkWindow = self.wTree.get_widget("window1")
self.gtkWindow.destroy()
# set combo boxes
if self.wTree.get_widget("video_mode"):
self.wTree.get_widget("video_mode").set_active(0)
if self.wTree.get_widget("video_front_back"):
self.wTree.get_widget("video_front_back").set_active(0)
# set window size
self.window.set_resizable(False)
if istablet:
self.window.fullscreen()
else:
self.window.set_resizable(True)
self.window.set_default_size(800, 480)
# add timeouts
gobject.timeout_add(1000, self.update_status_bar)
gobject.timeout_add(1000, self.publish_ui_state)
#display everything
self.window.show_all()
# map
self.view_map = view_map_t(self.wTree.get_widget("map"), 700, 400,
self.wTree.get_widget("map_scale"), 50, 90,
20, self.bpp)
self.wTree.get_widget("map_frame").connect("button-press-event",
self.on_map_press)
self.wTree.get_widget("map_frame").connect("button-release-event",
self.on_map_release)
self.wTree.get_widget("map_frame").connect("motion-notify-event",
self.on_map_motion_notify)
# system info
self.view_system_info = view_system_info_t(
self.wTree.get_widget("system_info"), 800, 400, self.bpp)
self.wTree.get_widget("system_info_frame").connect(
"button-press-event", self.on_system_info_press)
self.wTree.get_widget("system_info_frame").set_events(
gtk.gdk.EXPOSURE_MASK | gtk.gdk.KEY_PRESS_MASK)
# nav info
self.view_nav_info = view_nav_info_t(self.wTree.get_widget("nav_info"),
800, 400, self.bpp)
self.wTree.get_widget("nav_frame").connect("button-press-event",
self.on_nav_press)
self.wTree.get_widget("nav_frame").set_events(gtk.gdk.EXPOSURE_MASK
| gtk.gdk.KEY_PRESS_MASK)
# panel
self.view_panel = view_panel_t(self.wTree.get_widget("panel_info"),
800, 400, self.bpp)
self.wTree.get_widget("panel_frame").connect("button-press-event",
self.on_panel_info_press)
self.view_panel.render()
# calibration
self.view_calibration = view_calibration_t(
self.wTree.get_widget("calibration_info"), 800, 400, self.bpp)
self.wTree.get_widget("calibration_frame").connect(
"button-press-event", self.on_calibration_info_press)
self.view_calibration.render()
# main window keyboard callback
#if self.wTree.get_widget ("window1"):
self.wTree.get_widget("vbox1").connect("key-press-event",
self.on_main_key_press)
def __init__(self):
pygame.init()
# self.clock=pygame.time.Clock()
if len(sys.argv) >= 2 and sys.argv[1] != "":
self.file = sys.argv[1]
self.currentdir = os.path.realpath(os.path.dirname(sys.argv[1]))
pygame.mixer.music.load(self.file)
pygame.mixer.music.play()
else:
self.file = None
self.currentdir = os.path.realpath(os.path.dirname(sys.argv[0]))
print self.currentdir
self.isPaused = False
pygame.mixer.init()
pygame.mixer.music.set_volume(1.0)
print pygame.mixer.get_init()
print pygame.mixer.music.get_volume()
if isHildon:
self.app = hildon.Program()
self.window = hildon.Window()
else:
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title(APP_TITLE)
self.window.connect("delete_event", self.delete_event)
self.window.set_border_width(10)
self.window.connect("key-press-event", self.on_key_press)
self.window.connect("window-state-event", self.on_window_state_change)
self.window_in_fullscreen = False # The window isn't in full screen mode initially.
self.vbox = gtk.VBox(False, 0)
self.hbox = gtk.HBox(False, 0)
self.browserFrame = gtk.Frame("")
self.browserFrame.show()
self.playlistFrame = gtk.Frame("")
self.playlistFrame.show()
global FileBrowser, PlayListBrowser
self.fileBrowser = FileBrowser(self.browserFrame, self)
self.fileBrowser.refreshFiles()
self.playlistBrowser = PlayListBrowser(self.playlistFrame, self)
self.playBtn = gtk.Button("\nPlay\n")
self.playBtn.connect("clicked", self.play, None)
self.pauseBtn = gtk.Button("Pause")
self.pauseBtn.connect("clicked", self.pause, None)
self.stopBtn = gtk.Button("Stop")
self.stopBtn.connect("clicked", self.stop, None)
# self.loadBtn = gtk.Button("Load")
# self.loadBtn.connect("clicked", self.fileBrowser.playSelected, None)
self.hbox.pack_start(self.playBtn, True, True, 0)
self.hbox.pack_start(self.pauseBtn, True, True, 0)
self.hbox.pack_start(self.stopBtn, True, True, 0)
# self.hbox.pack_start(self.loadBtn, True, True, 0)
self.hbox2 = gtk.HBox(False, 0)
self.statusLabel = gtk.Label("")
if self.file == None:
self.displayStatus("No file loaded")
else:
self.displayStatus("File: " + os.path.basename(self.file))
self.hbox2.pack_start(self.statusLabel, False, False, 0)
self.timeLabel = gtk.Label("")
self.hbox2.pack_end(self.timeLabel, False, False, 0)
# About
self.aboutFrame = gtk.Frame()
self.Label2 = gtk.Label(APP_ABOUT)
self.Label2.set_line_wrap(True)
self.aboutFrame.add(self.Label2)
self.aboutFrame.show()
self.notebook = gtk.Notebook()
self.notebook.set_tab_pos(gtk.POS_TOP)
self.notebook.append_page(self.browserFrame, gtk.Label("File browser"))
self.notebook.append_page(self.playlistFrame, gtk.Label("Playlist"))
self.notebook.append_page(self.aboutFrame, gtk.Label("About"))
self.notebook.show()
self.vbox.pack_start(self.hbox2, False, False, 0)
self.vbox.pack_start(self.hbox, False, False, 0)
self.vbox.pack_start(self.notebook, True, True, 0)
self.window.add(self.vbox)
self.hbox.show()
self.playBtn.show()
self.pauseBtn.show()
self.stopBtn.show()
# self.loadBtn.show()
self.hbox2.show()
self.statusLabel.show()
self.timeLabel.show()
self.Label2.show()
self.vbox.show()
self.window.show()
self.source_id = gobject.timeout_add(250, self.doIdle)
"""
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 create_textarea(window):
scrolledwindow = gtk.ScrolledWindow(None, None)
scrolledwindow.show()
scrolledwindow.set_policy('automatic', 'automatic')
textview = gtk.TextView()
textview.set_editable(1)
textview.set_left_margin(10)
textview.set_right_margin(10)
scrolledwindow.add(textview)
window.add(scrolledwindow)
buffer = textview.get_buffer()
buffer.connect('modified-changed', callback_buffer_modified)
buffer.connect('changed', callback_buffer_modified)
program = hildon.Program()
window = hildon.Window()
window.set_title("MaemoPad")
window.connect('destroy', gtk.main_quit)
program.add_window(window)
create_textarea(window)
create_menu(window)
create_toolbar(window)
window.show_all()
gtk.main()
