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 test_set_display_event_cb(self):
state = osso.DeviceState(self.ctx)
def callback(*args):
print "display_event_callback:", args
state.set_display_event_cb(callback)
self.assertTrue("OSSO_DISPLAY_ON" in dir(osso.device_state))
self.assertTrue("OSSO_DISPLAY_OFF" in dir(osso.device_state))
self.assertTrue("OSSO_DISPLAY_DIMMED" in dir(osso.device_state))
def main():
global count
loop = gobject.MainLoop()
osso_c = osso.Context("osso_test_device_on", "0.0.1", False)
device = osso.DeviceState(osso_c)
gobject.timeout_add(11000, blink_cb, device, loop)
loop.run()
def get_device_state():
"""
Returns the OSSO device state object.
@since: 0.96.3
@return: OSSO device state
"""
import osso
return osso.DeviceState(_osso_ctx)
def main():
global count
loop = gobject.MainLoop()
osso_c = osso.Context("osso_test_device_on", "0.0.1", False)
device = osso.DeviceState(osso_c)
device.set_device_state_callback(state_cb, user_data=loop)
loop.run()
device.set_device_state_callback(None)
def main():
global count
loop = gobject.MainLoop()
osso_c = osso.Context("osso_test_device_on", "0.0.1", False)
device = osso.DeviceState(osso_c)
device.display_blanking_pause()
gobject.timeout_add(15000, quit_cb, loop)
loop.run()
def __init__(self, app, h_window, h_context):
self._app = app
self._h_window = h_window
self._h_context = h_context
state = osso.DeviceState(self._h_context)
state.set_device_state_callback(self._device_state_cb)
con = conic.Connection()
con.connect('connection-event', self._connection_cb)
if not con.request_connection(conic.CONNECT_FLAG_NONE):
logging.debug("error with conic connection thingy")
def test_set_device_state_callback(self):
state = osso.DeviceState(self.ctx)
main_loop = gobject.MainLoop()
self.called = False
def callback(shutdown, save_data, memory_low, system_inactivity, mode, user_data):
print "set_device_state_callback:", locals()
self.called = True
main_loop.quit()
state.set_device_state_callback(callback, save_data=True, user_data="abc")
gobject.idle_add(DbusTestObject.emit_signal)
source_id = gobject.timeout_add(1000, main_loop.quit)
main_loop.run()
gobject.source_remove(source_id)
self.assertTrue(self.called)
def test_display_blanking_pause(self):
state = osso.DeviceState(self.ctx)
state.display_blanking_pause()
def test_display_state_on(self):
state = osso.DeviceState(self.ctx)
state.display_state_on()
def test_constructor(self):
state = osso.DeviceState(self.ctx)
self.assertTrue(isinstance(state, osso.DeviceState))
class QuicknoteProgram(hildonize.get_app_class()):
_user_data = os.path.join(os.path.expanduser("~"), ".%s" % constants.__app_name__)
_user_settings = "%s/settings.ini" % _user_data
def __init__(self):
super(QuicknoteProgram, self).__init__()
self._clipboard = gtk.clipboard_get()
_moduleLogger.info('Starting quicknote')
self._wordWrapEnabled = False
self._window_in_fullscreen = False #The window isn't in full screen mode initially.
self._db = speichern.Speichern()
#Create GUI main vbox
vbox = gtk.VBox(homogeneous = False, spacing = 0)
if hildonize.GTK_MENU_USED:
#Create Menu and apply it for hildon
filemenu = gtk.Menu()
menu_items = gtk.MenuItem(_("Set DB file"))
filemenu.append(menu_items)
menu_items.connect("activate", self.set_db_file, None)
menu_items = gtk.MenuItem(_("SQL History"))
filemenu.append(menu_items)
menu_items.connect("activate", self._on_view_sql_history, None)
menu_items = gtk.MenuItem(_("Sync notes"))
filemenu.append(menu_items)
menu_items.connect("activate", self._on_sync_notes, None)
menu_items = gtk.MenuItem(_("Quit"))
filemenu.append(menu_items)
menu_items.connect("activate", self._on_destroy, None)
file_menu = gtk.MenuItem(_("File"))
file_menu.show()
file_menu.set_submenu(filemenu)
categorymenu = gtk.Menu()
menu_items = gtk.MenuItem(_("Search"))
categorymenu.append(menu_items)
menu_items.connect("activate", self._on_toggle_search)
menu_items = gtk.MenuItem(_("Delete"))
categorymenu.append(menu_items)
menu_items.connect("activate", self._on_delete_category)
category_menu = gtk.MenuItem(_("Category"))
category_menu.show()
category_menu.set_submenu(categorymenu)
viewmenu = gtk.Menu()
menu_items = gtk.MenuItem(_("Move To Category"))
viewmenu.append(menu_items)
menu_items.connect("activate", self._on_move_category)
menu_items = gtk.MenuItem(_("History"))
viewmenu.append(menu_items)
menu_items.connect("activate", self._on_show_history)
menu_items = gtk.MenuItem(_("Word Wrap"))
viewmenu.append(menu_items)
menu_items.connect("activate", self._on_toggle_word_wrap)
view_menu = gtk.MenuItem(_("Note"))
view_menu.show()
view_menu.set_submenu(viewmenu)
helpmenu = gtk.Menu()
menu_items = gtk.MenuItem(_("About"))
helpmenu.append(menu_items)
menu_items.connect("activate", self._on_show_about, None)
help_menu = gtk.MenuItem(_("Help"))
help_menu.show()
help_menu.set_submenu(helpmenu)
menuBar = gtk.MenuBar()
menuBar.show()
menuBar.append (file_menu)
menuBar.append (category_menu)
menuBar.append (view_menu)
menuBar.append (help_menu)
vbox.pack_start(menuBar, False, False, 0)
else:
menuBar = gtk.MenuBar()
menuBar.show()
vbox.pack_start(menuBar, False, False, 0)
#Create GUI elements
self._category = kopfzeile.Kopfzeile(self._db)
self._search = search.Search()
self._notizen = notizen.Notizen(self._db, self._category, self._search)
# notizen packs in the category
vbox.pack_start(self._notizen, expand = True, fill = True)
vbox.pack_start(self._search, expand = False, fill = True)
#Get the Main Window, and connect the "destroy" event
self._window = gtk.Window()
self._window.add(vbox)
self._on_toggle_word_wrap()
try:
os.makedirs(self._user_data)
except OSError, e:
if e.errno != 17:
raise
self._window = hildonize.hildonize_window(self, self._window)
hildonize.set_application_title(self._window, "%s" % constants.__pretty_app_name__)
menuBar = hildonize.hildonize_menu(
self._window,
menuBar,
)
if hildonize.IS_FREMANTLE_SUPPORTED:
moveToCategoryButton = gtk.Button(_("Move Note"))
moveToCategoryButton.connect("clicked", self._on_move_category)
menuBar.append(moveToCategoryButton)
historyButton = gtk.Button(_("Note History"))
historyButton.connect("clicked", self._on_show_history)
menuBar.append(historyButton)
searchButton= gtk.Button(_("Search Category"))
searchButton.connect("clicked", self._on_toggle_search)
menuBar.append(searchButton)
deleteCategoryButton = gtk.Button(_("Delete Category"))
deleteCategoryButton.connect("clicked", self._on_delete_category)
menuBar.append(deleteCategoryButton)
menuBar.show_all()
if not hildonize.IS_HILDON_SUPPORTED:
_moduleLogger.info("No hildonization support")
if osso is not None:
self._osso_c = osso.Context(constants.__app_name__, constants.__version__, False)
self._deviceState = osso.DeviceState(self._osso_c)
self._deviceState.set_device_state_callback(self._on_device_state_change, 0)
else:
_moduleLogger.info("No osso support")
self._osso_c = None
self._deviceState = None
self._window.connect("delete-event", self._on_delete_event)
self._window.connect("destroy", self._on_destroy)
self._window.connect("key-press-event", self._on_key_press)
self._window.connect("window-state-event", self._on_window_state_change)
self._window.show_all()
self._search.hide()
self._load_settings()
def __init__(self):
self._osso_context = osso.Context('Panucci', panucci.__version__,
False)
self._osso_device_state = osso.DeviceState(self._osso_context)
self.anti_blank_timer_id = None
