def __init__(self, *args, **kwargs):
gtk.StatusIcon.__init__(self, *args, **kwargs)
self.set_from_stock(gtk.STOCK_FIND)
self.set_tooltip('Fetching')
self._init_menu()
self.cb_refresh()
gobject.timeout_add_seconds(10*60, self.cb_refresh)
def profile_update(self):
try:
self.user = data_handle.UserData(self.connection.get_user_data())
except:
self.show_error("There was a connection problem with the login page. Live profile update will be disabled.\n"
"Please relog/restart the client.")
return False
self.accountlabel.set_text(self.user.name)
self.emaillabel.set_text(self.user.email)
if self.user.forum != "0":
self.forumnotelabel.set_text(self.user.forum)
else:
self.forumnotelabel.set_text("none")
if self.user.messages != "0":
self.privatenotelabel.set_text(self.user.messages)
else:
self.privatenotelabel.set_text("none")
if self.user.games != "0":
self.gamenotelabel.set_text(self.user.games)
else:
self.gamenotelabel.set_text("none")
#Let's load the picture from the web
response = urllib2.urlopen(self.user.imagesmall)
loader = gtk.gdk.PixbufLoader()
loader.write(response.read())
loader.close()
self.profilepic.set_from_pixbuf(loader.get_pixbuf().scale_simple(35,35,gtk.gdk.INTERP_BILINEAR))
#refresh the update based on the settings, we do this because they may change dynamically
#so we have to break the chain and re-create it every time
gobject.timeout_add_seconds(int(self.settings["profile_update"]),self.profile_update)
return False
def search(self, callback, ctx=None, criteria=None, keywords=None, replicated=False, fetch=True):
""" The caller gets an indetermistic number of result callbacks.
Empty keywords, or keywords == None, means get all messages. """
if criteria == None:
criteria = {}
sctx = Search_Context(callback, ctx=ctx, criteria=criteria, keywords=keywords)
if fetch:
self.searchctxs.append(sctx)
timeout_add_seconds(SEARCH_TIMEOUT, self.cancel_search, sctx)
self.statusindicator.set_status("Searching messages", timeout=SEARCH_TIMEOUT)
# Query others
req = {"t": "msgquery"}
if keywords != None:
req["keywords"] = keywords
req["criteria"] = criteria
com = self.community.get_default_community()
self.fetcher.fetch_community(com, self.name, req, self.got_query_results)
self.query_cache(sctx)
# Then query myself
sctx.process(self.community.get_myself(), self.all_metas())
def _initGui(self):
if self.WHICH_CAMERA == 1:
print "using bottom camera"
self._con.switchToBottomCamera()
else:
print "using top camera"
self._con.switchToTopCamera()
stage_color = clutter.Color(0x99, 0xCC, 0xFF, 0xFF)
stage = clutter.Stage()
# stage.connect('button-press-event', clutter.main_quit)
stage.connect("destroy", clutter.main_quit)
stage.set_color(stage_color)
stage.set_user_resizable(True)
stage.set_size(400, 300)
self._texture = texture = clutter.Texture("top.jpg")
texture.set_position(0, 0)
stage.add(texture)
# tick(texture)
gobject.timeout_add_seconds(1, self.onUpdateImage)
stage.show()
stage.show_all()
self.stage = stage
def check(self):
new = False
for label in self.labels:
new = label.check()
if new:
self.notify()
gobject.timeout_add_seconds(self.timeout, self.check)
def __init__(self):
self.caps = []
self.rssfeeds = set()
self.seen = set()
self.windows = list()
# self.rssfeeds.add('http://www.usgs.gov/hazard_alert/alerts/landslides.rss')
# self.rssfeeds.add('http://alerts.weather.gov/cap/ca.php?x=0')
self.rssfeeds.add('http://edis.oes.ca.gov/index.atom')
# self.rssfeeds.add('http://earthquake.usgs.gov/eqcenter/recenteqsww/catalogs/caprss7days5.xml')
self.mycoords = LATLONG_COORDS
self.statusIcon = gtk.StatusIcon()
self.statusIcon.set_from_stock(gtk.STOCK_DIALOG_WARNING)
self.statusIcon.set_visible(True)
self.statusIcon.set_tooltip("Common Alerting Protocol Viewer")
self.menu = gtk.Menu()
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_EXECUTE)
self.menuItem.connect('activate', self.execute_cb, self.statusIcon)
self.menu.append(self.menuItem)
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.menuItem.connect('activate', self.quit_cb, self.statusIcon)
self.menu.append(self.menuItem)
self.menuItem = gtk.ImageMenuItem(gtk.STOCK_CONNECT)
self.menuItem.connect('activate', self.rssTimer_cb, self.statusIcon)
self.statusIcon.connect('popup-menu', self.popup_menu_cb, self.menu)
self.statusIcon.set_visible(1)
gobject.timeout_add_seconds(60*10, self.rssTimer_cb)
gobject.timeout_add(100, self.startup_cb)
self.execute_cb(None, None, None)
def __init__(self, bus):
self.path = "/org/freesmartphone/Time"
super(Time, self).__init__(bus, self.path)
self.interface = "org.freesmartphone.Time"
self.last_emitted = None
gobject.timeout_add_seconds(1, self.time_changed)
self.bus = bus
def __init__(self, timeout, function):
self.last = d.datetime.now()
self.last_active = False
self.value = timeout
self.function = function
self.counter = self.value
gobject.timeout_add_seconds(1, self.callback)
def __init__(self):
self.register_plugin(PLUGIN_TYPE_SCHEDULER)
self.community = None
self.callbacks = []
self.periodic = []
timeout_add_seconds(SCHEDULE_PERIOD, self.schedule)
def onAppStarted(self):
""" This is the real initialization function, called when the module has been loaded """
wTree = tools.prefs.getWidgetsTree()
self.playtime = 0
self.bufferedTrack = None
# Retrieve widgets
self.window = wTree.get_object('win-main')
columns = (('', [(gtk.CellRendererPixbuf(), gtk.gdk.Pixbuf), (gtk.CellRendererText(), TYPE_STRING)], True),
(None, [(None, TYPE_PYOBJECT)], False),
)
self.tree = TrackTreeView(columns, use_markup=True)
self.tree.enableDNDReordering()
self.tree.setDNDSources([DND_INTERNAL_TARGET])
wTree.get_object('scrolled-tracklist').add(self.tree)
# GTK handlers
self.tree.connect('exttreeview-button-pressed', self.onMouseButton)
self.tree.connect('tracktreeview-dnd', self.onDND)
self.tree.connect('key-press-event', self.onKeyboard)
self.tree.get_model().connect('row-deleted', self.onRowDeleted)
(options, args) = prefs.getCmdLine()
self.savedPlaylist = os.path.join(consts.dirCfg, 'saved-playlist')
self.paused = False
# Populate the playlist with the saved playlist
dump = None
if os.path.exists(self.savedPlaylist):
try:
dump = pickleLoad(self.savedPlaylist)
except:
msg = '[%s] Unable to restore playlist from %s\n\n%s'
log.logger.error(msg % (MOD_INFO[modules.MODINFO_NAME],
self.savedPlaylist, traceback.format_exc()))
if dump:
self.restoreTreeDump(dump)
log.logger.info('[%s] Restored playlist' % MOD_INFO[modules.MODINFO_NAME])
self.tree.collapse_all()
self.select_last_played_track()
self.onListModified()
commands, args = tools.separate_commands_and_tracks(args)
# Add commandline tracks to the playlist
if args:
log.logger.info('[%s] Filling playlist with files given on command line' % MOD_INFO[modules.MODINFO_NAME])
tracks = media.getTracks([os.path.abspath(arg) for arg in args])
playNow = not 'stop' in commands and not 'pause' in commands
modules.postMsg(consts.MSG_CMD_TRACKLIST_ADD, {'tracks': tracks, 'playNow': playNow})
elif 'play' in commands:
modules.postMsg(consts.MSG_CMD_TOGGLE_PAUSE)
# Automatically save the content at regular intervals
gobject.timeout_add_seconds(SAVE_INTERVAL, self.save_track_tree)
def __init__ (self, run_selector = True):
"""run_selector means that we start our regular game.
For testing purposes, it will be convenient to hand a
run_selector=False to this method to avoid running the dialog
and allow a tester to set up a game programmatically.
"""
mateconf_wrapper.MateConfWrapper.__init__(self,
mateconf_wrapper.MateConf('mate-sudoku')
)
self.setup_gui()
self.timer = timer.ActiveTimer(self.w)
self.won = False
# add the accelerator group to our toplevel window
self.worker_connections = []
self.is_fullscreen = False
# setup sudoku maker...
self.sudoku_maker = sudoku_maker.SudokuMaker()
self.sudoku_tracker = saver.SudokuTracker()
# generate puzzles while our use is working...
self.show()
if run_selector:
self.do_stop()
if self.select_game():
# If this return True, the user closed...
self.quit = True
else:
self.quit = False
# Generate puzzles in background...
if self.mateconf['generate_puzzles_in_background']:
gobject.timeout_add_seconds(1, lambda *args: self.start_worker_thread() and True)
def destroy (self):
debugprint ("DESTROY: %s" % self)
for binding in self.bindings:
delattr (self, binding)
if self.thread.isAlive ():
gobject.timeout_add_seconds (1, self._reap_thread)
def __init__(self, mapsObj):
gtk.Window.__init__(self)
self.mapsObj = mapsObj
self.gps_values = []
self.__stop = False
vbox = gtk.VBox(False)
vbox.pack_start(self._createLabels(FontDescription("16")))
self.add(vbox)
self.set_title("GPS")
self.set_border_width(10)
self.update_widgets()
self.set_position(gtk.WIN_POS_CENTER)
self.set_gravity(gtk.gdk.GRAVITY_STATIC)
self.placement = self.get_position()
self.set_size_request(250, 300)
self.connect('key-press-event', self.key_press)
self.connect('delete-event', self.on_delete)
self.connect('hide', self.on_hide)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
menu = self.rclick_menu()
self.connect('button_press_event', self.window_event, menu)
self.show_all()
self.set_transient_for(mapsObj)
self.connect('show', self.on_show)
timeout_add_seconds(1, self.update_widgets)
def __init__(self):
self.statusicon = gtk.StatusIcon()
while not self.statusicon.is_embedded():
gtk.main_iteration()
self.bkgr_pixbuf = gen_pixbuf(border_color, width, height)
tmp_pixbuf = gen_pixbuf(background_color, width-2*border, height-2*border)
tmp_pixbuf.copy_area(src_x=0, src_y=0, width=width-2*border, height=height-2*border,
dest_pixbuf=self.bkgr_pixbuf, dest_x=border, dest_y=border)
self.normal_pixbuf = gen_pixbuf(normal_color, width-2*border, height-2*border)
self.low_pixbuf = gen_pixbuf(low_color, width-2*border, height-2*border)
self.critical_pixbuf = gen_pixbuf(critical_color, width-2*border, height-2*border)
self.disabled_pixbuf = gen_pixbuf(border_color, width, height)
tmp_pixbuf = gen_pixbuf(disabled_color, width-2*border, height-2*border)
tmp_pixbuf.copy_area(src_x=0, src_y=0, width=width-2*border, height=height-2*border,
dest_pixbuf=self.disabled_pixbuf, dest_x=border, dest_y=border)
self.update()
gobject.timeout_add_seconds(sleep, self.update)
self.statusicon.connect("popup-menu", self.right_click_event)
def toggle_process_pool_window(self, widget=None, value=None, action=None):
toggle_process_pool_checkbox = self.gui.get_object("ToggleProcessPoolWindow")
checkbox_state = toggle_process_pool_checkbox.get_active()
if value is None:
new_state = checkbox_state
else:
if action is None:
new_state = value
else:
new_state = action
if new_state:
is_available = pycam.Utils.threading.is_pool_available()
disabled_box = self.gui.get_object("ProcessPoolDisabledBox")
statistics_box = self.gui.get_object("ProcessPoolStatisticsBox")
if is_available:
disabled_box.hide()
statistics_box.show()
# start the refresh function
interval = int(max(1, self.gui.get_object(
"ProcessPoolRefreshInterval").get_value()))
gobject.timeout_add_seconds(interval,
self.update_process_pool_statistics, interval)
else:
disabled_box.show()
statistics_box.hide()
self.process_pool_window.show()
else:
self.process_pool_window.hide()
toggle_process_pool_checkbox.set_active(new_state)
# don't destroy the window with a "destroy" event
return True
def update(self):
""" Circle of updating, meanwhile controls rest window
and timer update """
if self.gui.state == "working":
# Update tooltip anyway
self.update_tray_icon_tooltip()
# Handle long rest first
if time() > self.timer.long_rest_time:
self.gui.call_rest_window()
self.timer.rest_time_ending = time() + self.timer.long_rest_length
self.update_rest_window()
self.timer.update_long_rest_time()
elif time() > self.timer.short_rest_time:
self.gui.call_rest_window()
self.timer.rest_time_ending = time() + self.timer.short_rest_length
self.update_rest_window()
self.timer.update_short_rest_time()
else:
# Reinit timer data for currect timing after idle state
self.timer.reinit_timer()
# Check in circle
gobject.timeout_add_seconds(5, self.update)
def testMonitorDeleteNonExistingEvent(self):
result = []
mainloop = self.create_mainloop(None)
events = parse_events("test/data/five_events.js")
@asyncTestMethod(mainloop)
def timeout():
# We want this timeout - we should not get informed
# about deletions of non-existing events
mainloop.quit()
return False
@asyncTestMethod(mainloop)
def notify_insert_handler(time_range, events):
event_ids = map(lambda ev : ev.id, events)
self.client.delete_events([9999999])
@asyncTestMethod(mainloop)
def notify_delete_handler(time_range, event_ids):
mainloop.quit()
self.fail("Notified about deletion of non-existing events %s", events)
self.client.install_monitor(TimeRange(125, 145), [],
notify_insert_handler, notify_delete_handler)
gobject.timeout_add_seconds(5, timeout)
self.client.insert_events(events)
mainloop.run()
def show_indicator(self, conversation):
print "adding " + conversation.display_name
try:
# Ubuntu 9.10 and above
indicator = indicate.Indicator()
except:
# Ubuntu 9.04
indicator = indicate.IndicatorMessage()
indicator.set_property("name", conversation.display_name)
indicator.set_property("subtype", "instant")
indicator.set_property('draw-attention', 'true');
# we can only display timestamp OR count
if conversation.count == 1:
indicator.set_property_time('time', conversation.timestamp)
else:
indicator.set_property('count', str(conversation.count));
indicator.connect("user-display", self.show_conversation)
indicator.show()
# TODO: why?
gobject.timeout_add_seconds(5, do_nothing, indicator)
def launched_application(self, app_id, pid):
if self._has_match(app_id):
return
timeout = time() + 15
gobject.timeout_add_seconds(2, self._find_application, app_id, pid, timeout)
# and once later
gobject.timeout_add_seconds(30, self._find_application, app_id, pid, timeout)
def update_group_information(self):
"""
update the information for a conversation with multiple users
"""
if not self.rotate_started:
self.rotate_started = True
gobject.timeout_add_seconds(5, self.rotate_picture)
#TODO add plus support for nick to the tab label!
members_nick = []
i = 0
for account in self.members:
i += 1
contact = self.session.contacts.get(account)
if contact is None or contact.nick is None:
nick = account
elif len(contact.nick) > 20 and i != len(self.members):
nick = contact.nick[:20] + '...'
else:
nick = contact.nick
members_nick.append(nick)
self.header.information = \
('%d members' % (len(self.members) + 1, ),
", ".join(members_nick))
self.update_tab()
def __init__( self, data ):
self.data = data
self.data.gtk = gtk
self.data.builder = gtk.Builder()
factory = gtk.IconFactory()
factory.add_default()
builder = self.data.builder
builder.add_from_file("../res/gui.glade")
self.window = builder.get_object("window1")
self.window.connect("delete_event", self.delete_event)
self.setCellRenderers()
#self.pb_blue = gtk.gdk.pixbuf_new_from_file("../pixbuf1.png")
#self.pb_green = gtk.gdk.pixbuf_new_from_file("../pixbuf2.png")
#self.pb_red = gtk.gdk.pixbuf_new_from_file("../pixbuf3.png")
self.data.status = builder.get_object("gui_status")
self.viewer = ocad_viewer.ocad_viewer(self.data, gtk, self.window)
self.viewer.isLayerVisible = self.isLayerVisible
self.initImageViewer()
self.viewer.viewer = self.view
#every second check if status is empty
gobject.timeout_add_seconds(1, self.check_status, False)
self.clean_status = True
def __init__(self, timeout_power, timeout_weather):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_size_request(800,600);
self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(0,0,0))
# self.window.fullscreen()
self.label = gtk.Label('time label')
self.label.set_use_markup(True)
self.label.modify_font(pango.FontDescription("sans 20"))
self.label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(65535,65535,65535))
self.weather = gtk.Label('Weather')
self.weather.set_use_markup(True)
self.weather.modify_font(pango.FontDescription("sans 20"))
self.weather.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(0,65535,0))
self.power = gtk.Label('Power')
self.power.set_use_markup(True)
self.power.modify_font(pango.FontDescription("sans 50"))
self.power.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(65535,65535,65535))
vbox = gtk.VBox()
vbox.pack_start(self.label)
vbox.pack_start(self.weather)
vbox.pack_start(self.power)
self.window.add(vbox)
self.window.show_all()
gobject.timeout_add_seconds(timeout_power, self.update_power)
gobject.timeout_add_seconds(timeout_weather, self.update_weather)
def show_xep0184_warning(self, id_):
if id_ in self.xep0184_marks:
return
buffer = self.tv.get_buffer()
buffer.begin_user_action()
self.xep0184_marks[id_] = buffer.create_mark(None,
buffer.get_end_iter(), left_gravity=True)
self.xep0184_shown[id_] = NOT_SHOWN
def show_it():
if (not id_ in self.xep0184_shown) or \
self.xep0184_shown[id_] == ALREADY_RECEIVED:
return False
end_iter = buffer.get_iter_at_mark(
self.xep0184_marks[id_])
buffer.insert(end_iter, ' ')
buffer.insert_pixbuf(end_iter,
ConversationTextview.XEP0184_WARNING_PIXBUF)
before_img_iter = buffer.get_iter_at_mark(
self.xep0184_marks[id_])
before_img_iter.forward_char()
post_img_iter = before_img_iter.copy()
post_img_iter.forward_char()
buffer.apply_tag_by_name('xep0184-warning', before_img_iter,
post_img_iter)
self.xep0184_shown[id_] = SHOWN
return False
gobject.timeout_add_seconds(2, show_it)
buffer.end_user_action()
def __toggled(self, widget, argv):
if argv == "auto_time_toggle":
is_auto_set_time = widget.get_active()
self.datetime_settings.set_boolean("is-auto-set", is_auto_set_time)
if is_auto_set_time:
self.__send_message("status", ("date_time", _("Time will be synchronized with an Internet time server")))
self.set_time_spin_align.set_child_visible(False)
gobject.timeout_add_seconds(3, self.__set_using_ntp, True)
else:
self.__send_message("status", ("date_time", _("Time will not be synchronized with an Internet time server")))
self.set_time_spin_align.set_child_visible(True)
if self.__toggle_id:
gobject.source_remove(self.__toggle_id)
self.__toggle_id = gobject.timeout_add_seconds(3, self.__set_using_ntp, False)
return
if argv == "time_display_toggle":
self.is_24hour = widget.get_active()
if self.is_24hour:
self.__send_message("status", ("date_time", _("Time will be shown in 24 hour format")))
else:
self.__send_message("status", ("date_time", _("Time will be shown in 12 hour format")))
self.datetime_settings.set_boolean("is-24hour", self.is_24hour)
self.datetime_widget.set_is_24hour(self.is_24hour)
self.set_time_spin.set_24hour(self.is_24hour)
def refresh(self, *args):
if self.refresh_timer_id:
gobject.source_remove(self.refresh_timer_id)
refresh_interval = gsettings.get_int("interval")
if not self.maintRunning and not self.refreshRunning:
log.logger.debug("Refresh interval is set to %s", refresh_interval)
operations = []
for o in self.collector.get_operations():
interval = FEATURES[o[1]].get("interval", 1)
if self.refresh_count % interval == 0:
operations.append(o)
if operations:
log.logger.debug("** Starting Refresh - %s **", mx.DateTime.now())
self.LoadingStarted()
self.perform_async_operation(operations)
self.refresh_timer_id = gobject.timeout_add_seconds(int(60 * refresh_interval), self.refresh)
else:
self.refresh_timer_id = gobject.timeout_add_seconds(int(30), self.refresh)
if not self.maintDone:
self.maint_timer_id = gobject.timeout_add_seconds(60, self.do_maintenance)
return False
def grab(self, window, att=0):
window.show()
self.grabed_window = window
self.set_left_cursor(window)
window.set_keep_above(True)
pstatus = self.lock_pointer(window)
kstatus = self.lock_keyboard(window)
window.set_keep_above(True)
if self.grab_connect_id > 0:
gobject.source_remove(self.grab_connect_id)
self.grab_connect_id = 0
self.grab_connect_id = window.connect("event",
self.grabed_window_event)
# stop after 4 attempts
if att >= 4:
return
if pstatus != gtk.gdk.GRAB_SUCCESS or kstatus != gtk.gdk.GRAB_SUCCESS:
gobject.timeout_add_seconds(1, self.grab,
window,
att+1)
def send_command(self, command):
if not self.skype_out:
self.attach(command.Timeout)
self.push_command(command)
self.notifier.sending_command(command)
cmd = '#%d %s' % (command.Id, command.Command)
self.logger.debug('sending %s', repr(cmd))
if command.Blocking:
if self.run_main_loop:
command._event = event = threading.Event()
else:
command._loop = loop = gobject.MainLoop()
command._set = False
else:
command._timer = timer = threading.Timer(command.timeout2float(), self.pop_command, (command.Id,))
try:
result = self.skype_out.Invoke(cmd)
except dbus.DBusException as err:
raise SkypeAPIError(str(err))
if result.startswith('#%d ' % command.Id):
self.notify(result)
if command.Blocking:
if self.run_main_loop:
event.wait(command.timeout2float())
if not event.isSet():
raise SkypeAPIError('Skype command timeout')
elif not command._set:
gobject.timeout_add_seconds(int(command.timeout2float()), loop.quit)
loop.run()
if not command._set:
raise SkypeAPIError('Skype command timeout')
else:
timer.start()
def __init__(self,nic,fg,bg,ival):
gtk.gdk.threads_init()
self.myqueue=deque()
self.lastvalue=None
self.fgcolor=fg
self.bgcolor=bg
self.nic=nic
for i in range(self.w):
self.myqueue.append(20)
sys.stderr.write("icon init started\n")
# create a new Status Icon
self.staticon = gtk.StatusIcon()
#self.draw_graph()
gobject.timeout_add_seconds(ival, self.timer_update)
self.staticon.connect("activate", self.activate)
self.staticon.connect("popup_menu", self.popup)
self.staticon.set_visible(True)
sys.stderr.write("icon init finished\n")
def cache_dirs(self, keep_caching):
for index, path in enumerate(self.paths):
# Cache dirs one by one after a small timeout
gobject.timeout_add_seconds(3 * index, self.search_dir, path,
CACHE_QUERY)
# Keep caching in regular intervals
return keep_caching
def test_queries_while_batch_insert (self):
self.assertTrue (os.path.exists ('ttl'))
for root, dirs, files in os.walk('ttl'):
for ttl_file in filter (lambda f: f.endswith (".ttl"), files):
full_path = os.path.abspath(os.path.join (root, ttl_file))
print full_path
counter = 0
current_batch = ""
for line in open(full_path):
if (line.startswith ("@prefix")):
continue
current_batch += line
if len(line) > 1 and line[:-1].endswith ('.'):
counter += 1
if counter == BATCH_SIZE:
query = "INSERT {" + current_batch + "}"
self.tracker.get_tracker_iface ().BatchSparqlUpdate (query,
timeout=20000,
reply_handler=self.batch_success_cb,
error_handler=self.batch_failed_cb)
self.run_a_query ()
counter = 0
current_batch = ""
self.batch_counter += 1
gobject.timeout_add_seconds (2, self.run_a_query)
# Safeguard of 60 seconds. The last reply should quit the loop
gobject.timeout_add_seconds (60, self.timeout_cb)
self.main_loop.run ()
def _init_dbus_reconnect_timer(self):
gobject.timeout_add_seconds(constants.DBUS_RECONNECT_INTERVAL_SECONDS,
self._dbus_reconnect)
def _init_dbus_check_timer(self):
gobject.timeout_add_seconds(constants.DBUS_CHECK_INTERVAL_SECONDS,
self._dbus_check)
def _init_autoexit_timer(self):
gobject.timeout_add_seconds(constants.AUTOEXIT_TIMEOUT_SECONDS,
self._autoexit)
def _init_autoexitcheck_timer(self):
if self._indicator_hdl.get_keep_alive() is False:
gobject.timeout_add_seconds(
constants.AUTOEXIT_CHECK_INTERVAL_SECONDS, self._autoexitcheck)
bus = pipeline.get_bus()
#Set the download flag
flags = pipeline.get_property("flags")
flags |= GstPlayFlags.GST_PLAY_FLAG_DOWNLOAD
pipeline.set_property("flags", flags)
#Start playing
ret = pipeline.set_state(gst.STATE_PLAYING)
if (ret == gst.STATE_CHANGE_FAILURE):
print >> sys.stderr, "Unable to set pipeline to playing state"
exit(-1)
elif (ret == gst.STATE_CHANGE_NO_PREROLL):
data.is_live = True
main_loop = gobject.MainLoop(None, False)
data.loop = main_loop
data.pipeline = pipeline
bus.add_signal_watch()
bus.connect("message", cb_message, data)
pipeline.connect("deep-notify::temp-location", got_location)
#Register a function that GLib will call every second
gobject.timeout_add_seconds(1, refresh_ui, data)
main_loop.run()
#Free resources
pipeline.set_state(gst.STATE_NULL)
print ""
def idle( self ):
logger.info( "================== mainloop entered ===================" )
logger.info( "startup time was %.2f seconds" % ( time.time() - self.launchTime ) )
gobject.timeout_add_seconds( 1*60, self.timeout )
return False # mainloop: don't call me again
def __init__(self):
self.dirs = dirs
user_config = configuration.Config(self.dirs.config_file)
# Apply defaults where no custom values have been set
for key, value in default_config.items():
if key not in user_config:
user_config[key] = value
self.config = user_config
self.config.save_state()
logging.info('Running in portable mode: %s' % self.dirs.portable)
# Allow starting minimized to tray
# When we start minimized we have to set the tray icon visible
self.start_minimized = filesystem.HAS_TRAY and args.minimized
if not filesystem.HAS_TRAY:
self.config['closeToTray'] = 0
elif self.start_minimized:
self.config['closeToTray'] = 1
self.month = None
self.date = None
self.months = {}
# The dir name is the title
self.title = ''
# show instructions at first start
self.is_first_start = self.config.read('firstStart', 1)
self.config['firstStart'] = 0
logging.info('First Start: %s' % bool(self.is_first_start))
logging.info('RedNotebook version: %s' % info.version)
logging.info(filesystem.get_platform_info())
utils.set_environment_variables(self.config)
self.actual_date = self.get_start_date()
# Let components check if the MainWindow has been created
self.frame = None
self.frame = MainWindow(self)
journal_path = self.get_journal_path()
if not self.dirs.is_valid_journal_path(journal_path):
logging.error('Invalid directory: %s. Using default journal.' %
journal_path)
self.show_message(
_('You cannot use this directory for your journal:') +
' %s' % journal_path + '. ' + _('Opening default journal.'),
error=True)
journal_path = self.dirs.default_data_dir
self.open_journal(journal_path)
self.archiver = backup.Archiver(self)
#self.archiver.check_last_backup_date()
# Check for a new version
if self.config.read('checkForNewVersion', 0) == 1:
utils.check_new_version(self, info.version, startup=True)
# Automatically save the content after a period of time
gobject.timeout_add_seconds(600, self.save_to_disk)
self.topwindow.show_all()
## offset the window if required
self.topwindow.move(int(xoffset), int(yoffset))
self.running = True
if self.last_file is not None:
self.topwindow.set_title(g_progname + ': ' +
os.path.basename(self.last_file))
self.last_file_mtime = datetime.datetime.fromtimestamp(
os.path.getmtime(self.last_file))
self.ct = 0
self._periodic('BEGIN')
gobject.timeout_add_seconds(g_periodic_secs, self._periodic,
'Continue')
# or use gobject.timeout_add() interval units in mS
def _periodic(self, arg):
# print "_periodic:",self.ct,arg
self.ct += 1
self.halg.poll()
# prevent it forcing to the top when embedded into another window
# that gremlin_view knows nothing about
if g_childwindow == False:
if self.parent is None:
self.topwindow.deiconify()
if (self.parent is not None) and (self.ct) == 2:
# not sure why delay is needed for reparenting
def on_leave_notify_event(self, *args):
"""
callback called when the mouse leaves this window
"""
if self.tag is None:
self.tag = gobject.timeout_add_seconds(1, self.windows_workaround)
def bind_timer(self, ev, interval, handler, *args, **kwargs): self.unbind_ev(ev) self.events[ev] = gobject.timeout_add_seconds(interval, handler, *args, **kwargs)
def rescan():
mpris2sources.rescan()
gobject.timeout_add_seconds(30, rescan)
def run(self):
"""
Starts phony service which manages device pairing and setting
up of hands-free profile services. This function never returns.
"""
stdin_fd = sys.stdin.fileno()
pid = os.fork()
if not pid:
#child
os.setsid()
bus = phony.base.ipc.BusProvider()
# Find the first audio card that provides audio input and output mixers.
audio_card_index = -1
with phony.bluetooth.adapters.Bluez5(bus) as adapter, \
phony.bluetooth.profiles.handsfree.Ofono(bus) as hfp, \
phony.audio.alsa.Alsa(card_index=audio_card_index) as audio, \
phony.headset.HandsFreeHeadset(bus, adapter, hfp, audio) as hs:
# Register to receive some bluetooth events
hs.on_device_connected(self.device_connected)
hs.on_incoming_call(self.incoming_call)
hs.on_call_began(self.call_began)
hs.on_call_ended(self.call_ended)
hs.start('MyBluetoothHeadset', pincode='1234')
hs.enable_pairability(timeout=30)
self._hs = hs
signal.signal(signal.SIGTERM, process_end)
signal.signal(signal.SIGINT, process_end)
signal.signal(signal.SIGUSR1, process_answer_call)
signal.signal(signal.SIGUSR2, process_dial_number)
gobject.timeout_add_seconds(1, tick)
loop = gobject.MainLoop()
try:
loop.run()
except KeyboardInterrupt:
print("Child caught keyborad interrupt")
return 0
# Wait forever> gobject.MainLoop().run()
#parent
def on_sigchld(signum, frame):
assert signum == signal.SIGCHLD
print("Child terminated - terminating parent")
sys.exit(0)
signal.signal(signal.SIGCHLD, on_sigchld)
stdin_attrs = termios.tcgetattr(stdin_fd)
tty.setcbreak(stdin_fd)
while True:
try:
char = os.read(stdin_fd, 1)
if char.lower() == "a":
os.kill(pid, signal.SIGUSR1)
if char.lower() == "d":
os.kill(pid, signal.SIGUSR2)
except KeyboardInterrupt:
print("Forwarding SIGINT to child process")
os.kill(pid, signal.SIGINT)
except SystemExit:
print("Caught SystemExit: cleaning up")
termios.tcsetattr(stdin_fd, termios.TCSADRAIN, stdin_attrs)
print("Parent terminated normally")
return 0
# use work stealing
sched = WSScheduler()
# our application state
state = {}
# our exclusive port, only one of these will be processed
# at a time and no teardown or concurrent will be processed
# concurrently
port_e = Port()
# our concurrent port, as many of these will be processed as
# allowed concurrently
port_c = Port()
# our teardown port, after a message is received from this port,
# no more messages will be received, ever.
port_t = Port()
# setup our coordinator to manage the receivers
recv_e = Arbiter.receive(port_e, onExclusiveMsg, state, scheduler=None)
recv_c = Arbiter.receive(port_c, onConcurrentMsg, state, scheduler=None)
recv_t = Arbiter.receive(port_t, onTeardownMsg, state, scheduler=None)
a = Arbiter.coordinate(recv_e, recv_c, recv_t)
gobject.timeout_add(0, queueMsgs, (port_e, port_c, port_t))
gobject.timeout_add_seconds(
2, printStat, (port_e, port_c, port_t, recv_e, recv_c, recv_t, a))
gtk.main()
def on_show(self, widget=None, event=None):
self.move(self.placement[0], self.placement[1])
if self.__stop:
self.__stop = False
timeout_add_seconds(1, self.update_widgets)
def main():
#
# Check if Source Controller started and available
#
printer('Checking if Source Controller is online...')
messaging.publish_command('/source/next', 'SET')
# !! !! TODO IMPORTANT !! !!
#
# QuickPlay
#
print "XX DEBUG XX"
print SOURCE
print SOURCE_SUB
print "XX DEBUG XX"
SOURCE = None
# BOOT is true for 'early boot'
#if BOOT and not prevSource = "" and not prevSource == SOURCE:
#if not prevSource == SOURCE and not prevSource:
# print('Quickplay failed due mismatching source')
# exit()
if not SOURCE:
printer ('No previous source; starting first available source', tag='QPLAY')
messaging.send_command('/source/next', 'SET')
messaging.send_command('/player/state', 'SET:play')
else:
ret = QuickPlay( prevSource,
prevSourceSub )
if ret:
printer ('Checking other sources...', tag='QPLAY')
# TODO: the prev. source is now checked again.. this is not efficient..
Sources.sourceCheckAll()
printSummary(Sources)
else:
printer ('Continuing playback not available, checking all sources...', tag='QPLAY')
Sources.sourceCheckAll()
printSummary(Sources)
printer ('Starting first available source', tag='QPLAY')
Sources.next()
hu_play(resume=False)
print "XX DEBUG XX"
"""
# Save Settings
currSrc = Sources.getComposite()
cSettings.set('source',currSrc['name'])
# update sub-source key (in case of sub-source)
if 'subsource' in currSrc:
subsource_key = {}
for key in currSrc['subsource_key']:
subsource_key[key] = currSrc['subsource'][key]
cSettings.set('subsourcekey', subsource_key)
cSettings.save()
"""
"""
else:
for source in Sources.getAll():
if source['name'] == prevSource:
print("!! PREVIOUS SOURCE: {0}".format(source['name']))
#if 'label' in source:
index = Sources.getIndex
print("!! CHECKING IF IT IS AVAILABLE...")
Sources.sourceCheck(
"""
# First, try previously active source
# on demand...
#plugin_sources.media.media_add('/media/USBDRIVE', Sources)
#myprint('A WARNING', level=logging.WARNING, tag="test")
#logger.warning('Another WARNING', extra={'tag':'test'})
# Save operational settings
#dSettings1 = {"source": -1, 'volume': 99, 'mediasource': -1, 'medialabel': ''} # No need to save random, we don't want to save that (?)
#settings_save( sFileSettings, dSettings1 )
#
# Setting up worker threads
#
"""
printer('Setting up queues and worker threads')
qPrio = Queue(maxsize=4) # Short stuff that can run anytime:
qBlock = Queue(maxsize=4) # Blocking stuff that needs to run in sequence
qAsync = Queue(maxsize=4) # Long stuff that can run anytime (but may occasionally do a reality check):
t = threading.Thread(target=worker_queue_prio)
#p = Process(target=worker_queue_prio)
t.setDaemon(True)
#p.daemon = True
t.start()
#p.join()
# disabled: see idle_add Queue Handler below
# t = threading.Thread(target=worker_queue_blocking)
# p = Process(target=worker_queue_blocking)
# t.setDaemon(True)
# p.daemon = True
# t.start()
t = threading.Thread(target=worker_queue_async)
#p = Process(target=worker_queue_async)
t.setDaemon(True)
#p.daemon = True
# DISABLED FOR ZMQ:
#t.start()
"""
"""
qBlock.put("SOURCE")
qPrio.put("VOL_UP")
qBlock.put("NEXT")
qPrio.put("VOL_UP")
qPrio.put("VOL_ATT")
qBlock.put("SHUFFLE")
qPrio.put("SHUTDOWN")
exit()
"""
#********************************************************************************
#
# Main loop
#
#
# Initialize the mainloop
#
DBusGMainLoop(set_as_default=True)
#
# main loop
#
mainloop = gobject.MainLoop()
#
# 30 second timer
#
# timer1:
# - Save settings
# - check if dbus services still online? (or make this a separate service?)
gobject.timeout_add_seconds(30,cb_timer1)
#
# Queue handler
# NOTE: Remember, everything executed through the qBlock queue blocks, including qPrio!
# IDEALLY, WE'D PUT THIS BACK IN A THREAD, IF THAT WOULD PERFORM... (which for some reason it doesn't!)
gobject.idle_add(idle_msg_receiver)
queue_actions = Queue(maxsize=40) # Blocking stuff that needs to run in sequence
#gobject.idle_add(process_queue)
#
# Start the blocking main loop...
#
#with PidFile(PID_FILE) as p:
try:
mainloop.run()
finally:
mainloop.quit()
def __init__(self, loop, autorefresh=True):
self.bus = dbus.SessionBus()
bus_name = dbus.service.BusName("com.Gwibber.Service", bus=self.bus)
dbus.service.Object.__init__(self, bus_name, self.__dbus_object_path__)
self.db = sqlite3.connect(SQLITE_DB_FILENAME)
self.accounts = storage.AccountManager(self.db)
self.searches = storage.SearchManager(self.db)
self.streams = storage.StreamManager(self.db)
self.messages = storage.MessageManager(self.db)
self.collector = OperationCollector(self)
# Monitor the connection
self.connection_monitor = util.getbus("Connection")
self.connection_monitor.connect_to_signal("ConnectionOnline",
self.on_connection_online)
self.connection_monitor.connect_to_signal("ConnectionOffline",
self.on_connection_offline)
self.indicate = None
if indicate and util.resources.get_desktop_file():
self.indicate = indicate.indicate_server_ref_default()
self.indicate.set_type("message.gwibber")
self.indicate.set_desktop_file(util.resources.get_desktop_file())
self.indicate.connect("server-display",
self.on_indicator_server_activate)
self.indicate.connect("interest-added",
self.on_indicator_interest_added)
self.indicate.connect("interest-removed",
self.on_indicator_interest_removed)
self.indicate.show()
self.indicator_items = {}
self.notified_items = []
self.notified_errors = {}
self.messages_indicator = None
self.replies_indicator = None
self.private_indicator = None
self.unseen_counts = {}
for s in "messages", "replies", "private":
self.unseen_counts[s] = 0
if Unity and Dbusmenu:
launcher = Unity.LauncherEntry.get_for_desktop_id(
"gwibber.desktop")
ql = Dbusmenu.Menuitem.new()
refresh_menu = Dbusmenu.Menuitem.new()
refresh_menu.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
_("Refresh"))
refresh_menu.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE,
True)
refresh_menu.connect("item-activated", self.refresh)
ql.child_append(refresh_menu)
accounts_menu = Dbusmenu.Menuitem.new()
accounts_menu.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
_("Accounts"))
accounts_menu.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE,
True)
accounts_menu.connect("item-activated", self.show_accounts)
ql.child_append(accounts_menu)
preferences_menu = Dbusmenu.Menuitem.new()
preferences_menu.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
_("Preferences"))
preferences_menu.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE,
True)
preferences_menu.connect("item-activated", self.show_preferences)
ql.child_append(preferences_menu)
quit_menu = Dbusmenu.Menuitem.new()
quit_menu.property_set(Dbusmenu.MENUITEM_PROP_LABEL, _("Quit"))
quit_menu.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
quit_menu.connect("item-activated", self.shutdown)
ql.child_append(quit_menu)
launcher.set_property("quicklist", ql)
self.refresh_count = 0
self.mainloop = loop
self.workerpool = multiprocessing.Pool()
self.refresh_timer_id = None
self.maintDone = False
self.maintRunning = False
self.refreshRunning = False
if autorefresh:
if self.refresh_timer_id:
gobject.source_remove(self.refresh_timer_id)
# wait a few seconds before alerting the world we are online
self.refresh_timer_id = gobject.timeout_add_seconds(
int(10), self.refresh)
self.accounts_service = util.getbus("Accounts")
self.accounts_service.connect_to_signal("Updated",
self.on_account_updated)
self.accounts_service.connect_to_signal("Deleted",
self.on_account_deleted)
self.accounts_service.connect_to_signal("Created",
self.on_account_created)
def rescan():
mpris2sources.rescan()
gobject.timeout_add_seconds(TIME_FOR_RESCAN, rescan)
def run(self):
gobject.timeout_add_seconds(60, self._refresh)
self._refresh()
loop = gobject.MainLoop()
loop.run()
def __init__(self, ThisPtr, timeout):
# register a periodic timer
self.ThisPtr = ThisPtr
self.tick = 120
self.tag = gobject.timeout_add_seconds(timeout, self.callback)
def __init__(self, path):
self.vfile = vfs.File.for_path(path)
self.monitor = self.vfile.monitor()
self.monitor.connect('changed', self.on_change)
if self.vfile.props.file_type == vfs.FILE_TYPE_DIRECTORY:
gobject.timeout_add_seconds(2, self.do_emit)
def state_checker(self):
if os.path.exists(self.lock_file):
self.ind.set_from_file(gtk.icon_theme_get_default().lookup_icon("bumblebee-indicator-active", 48, 0).get_filename())
else:
self.ind.set_from_file(gtk.icon_theme_get_default().lookup_icon("bumblebee-indicator", 48, 0).get_filename())
gobject.timeout_add_seconds(5, self.state_checker)
class DailyView(object):
def __init__(self):
# initialize the window. explicitly set it to None first, so that the
# creator knows it doesn't yet exist.
self.window = None
self.create_hamster_window()
self.new_name.grab_focus()
# DBus Setup
try:
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
# Set up connection to the screensaver
self.dbusIdleListener = idle.DbusIdleListener()
self.dbusIdleListener.connect('idle-changed', self.on_idle_changed)
except dbus.DBusException, e:
logging.error("Can't init dbus: %s" % e)
# configuration
self.timeout_enabled = conf.get("enable_timeout")
self.notify_on_idle = conf.get("notify_on_idle")
self.notify_interval = conf.get("notify_interval")
self.workspace_tracking = conf.get("workspace_tracking")
conf.connect('conf-changed', self.on_conf_changed)
# Load today's data, activities and set label
self.last_activity = None
self.todays_facts = None
runtime.storage.connect('activities-changed',self.after_activity_update)
runtime.storage.connect('facts-changed',self.after_fact_update)
runtime.storage.connect('toggle-called', self.on_toggle_called)
self.screen = None
if self.workspace_tracking:
self.init_workspace_tracking()
self.notification = None
if pynotify:
self.notification = pynotify.Notification("Oh hi",
"Greetings from hamster!")
self.notification.set_urgency(pynotify.URGENCY_LOW) # lower than grass
# refresh hamster every 60 seconds
gobject.timeout_add_seconds(60, self.refresh_hamster)
self.prev_size = None
# bindings
self.accel_group = self.get_widget("accelgroup")
self.window.add_accel_group(self.accel_group)
gtk.accel_map_add_entry("<hamster-applet>/tracking/add", gtk.keysyms.n, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/tracking/overview", gtk.keysyms.o, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/tracking/stats", gtk.keysyms.i, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/tracking/close", gtk.keysyms.Escape, 0)
gtk.accel_map_add_entry("<hamster-applet>/tracking/quit", gtk.keysyms.q, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/edit/prefs", gtk.keysyms.p, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/help/contents", gtk.keysyms.F1, 0)
# create the status icon
self.statusicon = ProjectHamsterStatusIcon(self)
self.reposition_hamster_window()
self.show_hamster_window()
self.show_in_tray()
def __init__(self,
dirs,
args,
update_period=300,
update_period_remote=3600):
self.args = args
self.dirs = dirs
self.update_period = update_period
self.update_period_remote = update_period_remote
self.remote = False # Flag to update the remote
self.ind = appindicator.Indicator(
"checkgit", "", appindicator.CATEGORY_APPLICATION_STATUS)
self.ind.set_status(appindicator.STATUS_ACTIVE)
self.ind.set_attention_icon("indicator-messages-new")
self.IconMenuDictionary = {
'ahead': gtk.STOCK_GO_UP,
'diverged': gtk.STOCK_REFRESH,
'behind': gtk.STOCK_GO_DOWN,
'up-to-date': gtk.STOCK_YES,
'no-state': gtk.STOCK_HELP
}
# create a menu
menu = gtk.Menu()
ManualCheck = gtk.ImageMenuItem(gtk.STOCK_REFRESH)
ManualCheck.set_always_show_image(True)
ManualCheck.show()
ManualCheck.connect("activate", self.SetIconAndMenuRemote2)
menu.append(ManualCheck)
ManualUpdate = gtk.ImageMenuItem(gtk.STOCK_HOME)
ManualUpdate.set_always_show_image(True)
ManualUpdate.show()
ManualUpdate.connect("activate", self.PullPushAll)
ManualUpdate.connect("activate", self.SetIconAndMenuRemote2)
menu.append(ManualUpdate)
dirs_items = []
for dir in self.dirs:
label_name = self.ClearDirName(dir)
item = gtk.ImageMenuItem(gtk.STOCK_YES, label_name)
item.show()
item.set_always_show_image(True)
menu.append(item)
dirs_items.append(item)
self.dirs_items = dirs_items
quit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
quit.connect("activate", self.quit)
quit.set_always_show_image(True)
quit.show()
menu.append(quit)
self.ind.set_menu(menu)
# Update the custom labels: must be done after `set_menu`.
ManualCheck.set_label("Check status")
ManualUpdate.set_label("Pull/Push")
self.SetIconAndMenu(remote=True) # Initialise the icon
gobject.timeout_add_seconds(int(self.update_period),
self.SetIconAndMenu)
gobject.timeout_add_seconds(int(self.update_period_remote),
self.SetIconAndMenuRemote)
gtk.threads_init()
def __init__(self, project):
self.project = project
# Gconf settings
# self._settings = gconf.client_get_default()
# self._settings.add_dir(self.BASE_KEY, gconf.CLIENT_PRELOAD_NONE)
# Key to enable/disable icon glow
self._use_icon_glow = conf.get("icon_glow")
self._show_label = conf.get("show_label")
self._label_length = conf.get("label_length")
self._last_activities_days = conf.get("last_activities_days")
conf.connect('conf-changed', self.on_conf_changed)
self._activity_as_attribute = None
# Create a fake applet since HamsterApplet requires one
# applet = FakeApplet()
self.indicator = appindicator.Indicator(
"hamster-applet", "hamster-applet-inactive",
appindicator.CATEGORY_SYSTEM_SERVICES)
self.indicator.set_status(appindicator.STATUS_ACTIVE)
# Set the attention icon as per the icon_glow gconf key
self._set_attention_icon()
# Initialise the activity label with "No Activity"
self.indicator.set_label(self._get_no_activity_label())
self.activity, self.duration = None, None
self.menu = gtk.Menu()
self.activity_item = gtk.MenuItem("")
self.menu.append(self.activity_item)
# this is where you would connect your menu item up with a function:
self.activity_item.connect("activate", self.on_activate)
self.activity_label = self.activity_item.get_child()
self.activity_label.connect('style-set', self.on_label_style_set)
# show the items
self.activity_item.show()
self.stop_activity_item = gtk.MenuItem(_(u"Sto_p tracking"))
self.menu.append(self.stop_activity_item)
# this is where you would connect your menu item up with a function:
self.stop_activity_item.connect("activate",
self.on_stop_activity_activated, None)
# show the items
self.stop_activity_item.show()
self.last_activities_item = gtk.MenuItem(_(u"_Last activities"))
self.menu.append(self.last_activities_item)
# show the items
self.last_activities_item.show()
self.append_separator(self.menu)
self.earlier_activity_item = gtk.MenuItem(_(u"Add earlier activity"))
self.menu.append(self.earlier_activity_item)
# this is where you would connect your menu item up with a function:
self.earlier_activity_item.connect("activate",
self.on_earlier_activity_activated,
None)
# show the items
self.earlier_activity_item.show()
self.overview_show_item = gtk.MenuItem(_(u"Show Overview"))
self.menu.append(self.overview_show_item)
# this is where you would connect your menu item up with a function:
self.overview_show_item.connect("activate",
self.on_overview_show_activated, None)
# show the items
self.overview_show_item.show()
self.append_separator(self.menu)
self.preferences_show_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
self.menu.append(self.preferences_show_item)
# this is where you would connect your menu item up with a function:
self.preferences_show_item.connect("activate",
self.on_show_preferences_activated,
None)
# show the items
self.preferences_show_item.show()
self.append_separator(self.menu)
self.quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.menu.append(self.quit_item)
# this is where you would connect your menu item up with a function:
self.quit_item.connect("activate", gtk.main_quit, None)
# show the items
self.quit_item.show()
self.project.last_activity = None
runtime.storage.connect('activities-changed',
self.after_activity_update)
runtime.storage.connect('facts-changed', self.after_fact_update)
runtime.storage.connect('toggle-called', self.on_toggle_called)
gobject.timeout_add_seconds(
20, self.refresh_tray
) # refresh hamster every 20 seconds to update duration
def modemStateSimReady( self ):
"""
Called, when the modem signalizes the SIM data can be read.
"""
gobject.timeout_add_seconds( 1, self._sendCommands, "sim" )
def activate(self):
#self.check_birthdays()
self.timeout_id = gobject.timeout_add_seconds(24*3600,
self.check_birthdays)
def clear(self):
print "\n" * 60
self.player.set_state(gst.STATE_NULL)
gobject.timeout_add_seconds(5, self.resume_view)
install_progressbar = gtk.ProgressBar()
install_progressbar.set_size_request(-1,30)
install_progressbar.set_text("Pretending to install. Please wait...")
install_progressbar.set_fraction(0)
slideshow_container.add(install_progressbar)
slideshow_container.add(slideshow_webview)
slideshow_window.show_all()
def progress_increment(progressbar, fraction):
new_fraction = progressbar.get_fraction() + fraction
if new_fraction > 1:
progressbar.set_fraction(1.0)
install_progressbar.set_text("Finished pretending to install.")
return False
progressbar.set_fraction(new_fraction)
install_progressbar.set_text("Pretending to install... %d%%" % (new_fraction * 100))
return True
install_timer = gobject.timeout_add_seconds(2, progress_increment, install_progressbar, 0.01)
gtk.main()
#gtk.widget_pop_colormap()
#print('Cleaned up GTK colormap stuff')
class IdleNotifier(dbus.service.Object):
#=========================================================================#
"""A Dbus Object implementing org.freesmartphone.Device.IdleNotifier"""
DBUS_INTERFACE = DBUS_INTERFACE_PREFIX + ".IdleNotifier"
_instance = None
@classmethod
def instance(klass):
return klass._instance
def __init__(self, bus, index, extranodes):
self.__class__._instance = self
self.interface = self.DBUS_INTERFACE
self.path = DBUS_PATH_PREFIX + "/IdleNotifier/%s" % index
dbus.service.Object.__init__(self, bus, self.path)
logger.info("%s %s initialized. Serving %s at %s",
self.__class__.__name__, __version__, self.interface,
self.path)
self.defaultTimeouts = dict(awake=-1,
busy=-1,
idle=10,
idle_dim=20,
idle_prelock=12,
lock=2,
suspend=20)
self.timeouts = self.defaultTimeouts.copy()
self.states = "awake busy idle idle_dim idle_prelock lock suspend".split(
)
self.validStates = set(self.states)
self.allowedStates = set(self.states)
self.state = self.states[0]
configvalue = config.getValue(MODULE_NAME, "ignoreinput", "")
ignoreinput = [
int(value) for value in configvalue.split(',') if value != ""
]
self.input = {}
for i in itertools.count():
if i in ignoreinput:
logger.info("skipping input node %d due to configuration" % i)
continue
try:
f = os.open("/dev/input/event%d" % i, os.O_NONBLOCK)
except OSError, e:
logger.debug(
"can't open /dev/input/event%d: %s. Assuming it doesn't exist."
% (i, e))
break
else:
self.input[f] = "event%d" % i
logger.info("opened %d input file descriptors" % len(self.input))
# override default timeouts with configuration (if set)
for key in self.timeouts:
timeout = config.getInt(MODULE_NAME, key,
self.defaultTimeouts[key])
self.timeouts[key] = timeout
if timeout == 0:
self.allowedStates.remove(key)
logger.debug("(re)setting %s timeout to %d" %
(key, self.timeouts[key]))
self.next = None
self.timeout = 0
self.setState("busy")
if len(self.input):
self.timer = gobject.timeout_add_seconds(1, self.onTimer)
# Set window centered
splash.set_position (gtk.WIN_POS_CENTER)
# Set window above the others
splash.set_keep_above (True)
# _I_ draw the window
splash.set_app_paintable(True)
# Draw window
splash.realize()
# Set null background
splash.window.set_back_pixmap(None, False)
# Signals
splash.connect("delete-event", gtk.main_quit, None)
splash.connect_after("expose-event", window_draw, None)
splash.show()
# Fade in splash screen
fade_window(splash)
# read delay time from command line
if len(sys.argv) < 2:
delay = 3
else:
delay = int(sys.argv[1])
# Close splash screen after X seconds
gobject.timeout_add_seconds(delay, gtk.main_quit, None);
gtk.main()