def __init__(self): self.tray = gtk.StatusIcon() self.tray.connect('activate', self.refresh) # Create menu self.menu = gtk.Menu() i = gtk.MenuItem("Settings") self.settings_item = i i.show() i.connect("activate", self.ConfigurePiJuice) self.menu.append(i) i = gtk.MenuItem("About...") i.show() i.connect("activate", self.show_about) self.menu.append(i) self.tray.connect('popup-menu', self.show_menu) self.pijuice = PiJuice(1, 0x14) # Initalise and start battery display self.refresh(None) self.tray.set_visible(True) gobject.timeout_add(REFRESH_INTERVAL, self.refresh, self.tray) gobject.timeout_add(CHECK_SIGNAL_INTERVAL, self.check_signum)
def arm (self, manager): self.manager = manager props = dict(obj=self.remote.path, name=self.remote.item.name, expected=self.when.isoformat( ), **self.remote.item.fields) self.props = props new_path = PATH + '/Scheduler/Armed/' + self.hashed delay_ms = (self.when - datetime.datetime.now( )).total_seconds( ) * 1000 self.remote.bus.add_signal_receiver(self.cleanup, "Remove", dbus_interface=Trigger.OWN_IFACE, bus_name=BUS, path=new_path) # manager.bus.add_signal_receiver(self.attrs, ack=self.on_success, error=self.on_error) trigger = None try: trigger = Trigger(new_path, manager, props, self) if trigger: trigger.Armed( ) self.manager.Trigger("Arming", trigger.path) self.trigger = trigger print "DELAYING", delay_ms gobject.timeout_add(delay_ms, trigger.Fire) manager.InterfacesAdded(trigger.path, { Trigger.OWN_IFACE: props }) self.manager.Trigger("Armed", trigger.path) except: print "already exited?" raise finally: pass return trigger
def run(self): GObject.timeout_add(100, self._idle, priority=GObject.PRIORITY_HIGH) while True: Gtk.main_iteration() gevent.sleep(.001)
def _timer_transition_to_state(self, dest_state): cur_time = int(time.time()) if dest_state == Timer.STATE_IDLE: self._end_time = 0 self._set_remaining_time(self._duration_seconds) elif dest_state == Timer.STATE_RUNNING: assert self._duration_seconds >= 0 if self._state == Timer.STATE_IDLE: self._end_time = cur_time + self._duration_seconds self._set_remaining_time(self._duration_seconds) elif self._state == Timer.STATE_PAUSED: self._end_time = cur_time + self._remaining_seconds GObject.timeout_add(500, self._on_timeout) elif dest_state == Timer.STATE_PAUSED: self._set_remaining_time(self._end_time - cur_time) self._end_time = 0 elif dest_state == Timer.STATE_FINISHED: pass else: assert False self._timer_set_state(dest_state)
def add_log_message(self, client_program_name, q_domain, domain_filter, action): """Add log message to the logs window""" self._logs_window.add_log_line(client_program_name, q_domain, domain_filter, action) color = ACTION_COLOR_MAP.get(action, ACTION_COLOR_MAP['default']) GObject.timeout_add(1000, self.set_blinker, color)
def run(self, argv): GObject.threads_init() GObject.timeout_add(10, self.on_timer) self.connect("startup", self.on_startup) self.connect("activate", self.on_activate) self.connect("shutdown", self.on_shutdown) return super(Gtk3Example, self).run(argv)
def test_searchentry(self): from softwarecenter.ui.gtk3.widgets.searchentry import get_test_searchentry_window win = get_test_searchentry_window() s = "foo" win.entry.insert_text(s, len(s)) GObject.timeout_add(TIMEOUT, lambda: win.destroy()) Gtk.main()
def go_to_bookmark(self, subfilenumber, identifier): if self._sub_file_number != subfilenumber: self.__load_file(subfilenumber, timeout=100) GObject.timeout_add(100, self.__scroll_to_bookmark_position_in_file, identifier)
def calculateDiffs(self, menuItem, showNotification=True): self.setMenuEnabled(False) self.packageTitle.set_label('Calculating file diffs...') while Gtk.events_pending(): Gtk.main_iteration() selected = self.getSelectedPackages() totalDiff = 0 for package in selected: diff = self.bkup.getFileSizeDiff(package) totalDiff += diff print(self.bkup.humanPrint(diff)) humanDiff = self.bkup.humanPrint(diff) newLabel = package + ' (' + humanDiff + ' change)' print(self.packages[package].set_label(newLabel)) self.setMenuEnabled(True) self.packageTitle.set_label('Packages from bkup.yaml:') self.removeDiffLabelTime = time.time() + 60 * 5 GObject.timeout_add(60 * 1000, self.checkDiffLabelRemovalTime) if showNotification: msg = Notify.Notification.new('Calculated file diffs', 'Bkup') msg.show() return totalDiff
def _iterAction(self): ''' Iterate to the next sequence step. ''' if len(self.steps) <= self._current_step: if self._loop is not None: self._loop.quit() return action = self.steps[self._current_step] if self._verbose: print _('SEQUENCE: %s') % action try: next_action = self.steps[self._current_step + 1] except IndexError: next_action = None pyatspi.Registry.deregisterEventListener(self._onAnticipatedEvent, *self._anticipated_event_types) if isinstance(next_action, WaitAction): self._anticipated_event_types = next_action.wait_for else: self._anticipated_event_types = [] pyatspi.Registry.registerEventListener(self._onAnticipatedEvent, *self._anticipated_event_types) self._current_handler = action.connect('done', self._onStepDone) GObject.timeout_add(action.delta_time, self._doAction, action)
def __load_previous_file(self, scroll_to_end=True): if self._sub_file_number > 0: self.__load_file(self._sub_file_number - 1) if scroll_to_end is True: GObject.timeout_add(100, self.__scroll_to_end_of_loaded_file) else: self._previous_file_loaded = True
def removeTheme(self): self.threadAction = _("remove") self.threadPackage = self.plymouth.getRemovablePackageName(self.selectedRemoveTheme) if self.threadPackage: dialog = QuestionDialog(_("Remove theme"), _("Continue removing theme:\n%(theme)s") % { "theme": self.threadPackage }, self.window) go = dialog.show() if (go): self.toggleGuiElements(True) # Start apt in a separate thread self.log.write(_("Start removing theme: %(theme)s") % { "theme": self.threadPackage }, 'dpm.removeTheme', 'info') cmd = 'apt-get purge -y %s %s' % (self.force, self.threadPackage) t = ExecuteApt(self.log, cmd, self.queue) t.daemon = True t.start() self.queue.join() #self.log.write("Check every 250 miliseconds if thread is still active", 'dpm.removeTheme') GObject.timeout_add(250, self.checkAptThread) else: self.log.write(_("User cancel remove theme: %(theme)s") % { "theme": self.threadPackage }, 'dpm.removeTheme', 'info') else: title = _("%(act1)s%(act2)s theme") % { "act1": self.threadAction[0].capitalize(), "act2": self.threadAction[1:] } msg = _("The package cannot be removed: %(pck)s\nIt is part of a meta package.\nTry apt instead") % { "pck": self.selectedRemoveTheme } self.log.write(msg, 'dpm.removeTheme') MessageDialogSafe(title, msg, Gtk.MessageType.INFO, self.window).show()
def setGrubResolution(self): self.toggleGuiElements(True) self.log.write(_("Save grub resolution: %(res)s") % { "res": self.selectedGrubResolution }, 'dpm.setGrubResolution', 'info') # Start saving in a separate thread t = GrubSave(self.log, self.selectedGrubResolution) t.start() GObject.timeout_add(250, self.checkGrubThread)
def __init__(self, location): self.location = location self.view_iter = None self.drawing = DigitalClockDawing(location) self.list_store = None GObject.timeout_add(1000, self.update) print "DIGI"
def _save_selected_subtitle (self): cursor = Gdk.Cursor.new (Gdk.CursorType.WATCH) self._dialog.get_window ().set_cursor (cursor) model, rows = self._tree_view.get_selection ().get_selected_rows () if rows: subtitle_iter = model.get_iter (rows[0]) subtitle_id = model.get_value (subtitle_iter, 3) subtitle_format = model.get_value (subtitle_iter, 1) bpath = self._cache_subtitles_dir() directory = Gio.file_new_for_path (bpath) try: directory.make_directory_with_parents (None); except: pass thread = DownloadThread (self._model, subtitle_id) thread.start () GObject.idle_add (self._save_subtitles, thread, subtitle_format) self._progress.set_text (_(u'Downloading the subtitles…')) GObject.timeout_add (350, self._progress_bar_increment, thread) else: #warn user! pass
def __init__(self, *p): Gtk.Grid.__init__(self,margin=5,column_spacing=5,row_spacing=5) self._vlc_widget = VLCWidget(*p) self._vlc_widget.props.hexpand = True self._vlc_widget.props.vexpand = True self.player = self._vlc_widget.player self.attach(self._vlc_widget,0,0,5,1) for i,(stock, func) in enumerate(( (Gtk.STOCK_MEDIA_PLAY, self.player.play), (Gtk.STOCK_MEDIA_PAUSE, self.player.pause), (Gtk.STOCK_MEDIA_NEXT, self.player.next_frame), (Gtk.STOCK_MEDIA_STOP, self.player.stop), )): b = Gtk.Button(stock=stock) b.connect("clicked", self._on_click_player_command, func) b.props.hexpand = False b.props.halign = Gtk.Align.START self.attach(b,i,1,1,1) self._scale = Gtk.Scale.new_with_range(Gtk.Orientation.HORIZONTAL,0,1,0.01) self._scale.props.hexpand = True self._scale.props.draw_value = False self._scale_changing_by_us = False self._scale.connect("value-changed", self._slider_changed) self.attach(self._scale,i+1,1,1,1) self._lbl = Gtk.Label("") self._lbl.props.hexpand = True self._lbl.props.halign = Gtk.Align.END self._lbl.props.xalign = 1.0 self.attach(self._lbl,1,2,4,1) GObject.timeout_add(50,self._update_slider)
def run(self, debug=None): """ Run the main loop. """ GObject.timeout_add(50, self.select_setup) # self.select_setup() # GObject.timeout_add(500, callback) # loop = GLib.MainLoop() # loop.run() # return if debug is not None: self.debug_shell_gtk(debug) else: from gi.repository import Gtk # workaround for https://bugzilla.gnome.org/show_bug.cgi?id=622084 import signal signal.signal(signal.SIGINT, signal.SIG_DFL) # end workaround logger.debug("Entering main loop") # main_loop = GLib.MainLoop() # main_loop.run() Gtk.main()
def play(self, sender): if sender.get_active(): self.pipeline.set_file(self.filedialog.get_uri()) self.pipeline.play() GObject.timeout_add(100, self.update_position) else: self.pipeline.pause()
def __init__(self): Gtk.Window.__init__(self, title="SwDiag") self.set_border_width(10) self.set_default_size(600, 800) self.rake = HayRotaryRake() self.degrees_of_freedom = [] self.outputs = {} self.inputs = {} self.box = Gtk.Box(spacing=6) self.add(self.box) self.drawing_area = Gtk.DrawingArea() self.drawing_area.set_size_request(800, 400) self.drawing_area.connect('draw', drawSimulation, self.inputs) try: self.conn = Connector("/dev/ttyACM{i}", 9600) self.conn.register_input_observer(self) self.conn.register_log_observer(self) self.conn.register_output_observer(self) integer_id = GObject.timeout_add(50, self.read) GObject.timeout_add(10000, self.activate) except Exception as e: print(e) #self.set_geometry_hints(self.scroll_txt_log,-1,-1) self.show_all()
def focusOut(self, widegt, event, data=None): ## called 0.0004 sec (max) after focusIn (if switched between two windows) dt = now()-ui.focusTime #print('focusOut', dt) if dt > 0.05: ## FIXME self.focus = False gobject.timeout_add(2, self.focusOutDo)
def closeTab(act, save = True): if save and act.vigtk.window.get_active_document().get_modified(): act.menus["fileClose"].activate() else: act.vigtk.window.close_tab(act.vigtk.window.get_active_tab()) gobject.timeout_add(100, waitUntilDialogDone, act)
def _init_activated(self, btn, model, path): obj = model[path][self.COL_ROW_DATA] s = Gtk.Settings.get_default() GObject.timeout_add( s.get_property("gtk-timeout-initial"), self._activated_callback, btn, btn.name, obj, model, path)
def add_notification(self, icon, corner=Gtk.CornerType.TOP_LEFT, duration=_NOTIFICATION_DURATION): if not isinstance(icon, NotificationIcon): raise TypeError('icon must be a NotificationIcon.') window = NotificationWindow() screen = Gdk.Screen.get_default() if corner == Gtk.CornerType.TOP_LEFT: window.move(0, 0) elif corner == Gtk.CornerType.TOP_RIGHT: window.move(screen.get_width() - style.GRID_CELL_SIZE, 0) elif corner == Gtk.CornerType.BOTTOM_LEFT: window.move(0, screen.get_height() - style.GRID_CELL_SIZE) elif corner == Gtk.CornerType.BOTTOM_RIGHT: window.move(screen.get_width() - style.GRID_CELL_SIZE, screen.get_height() - style.GRID_CELL_SIZE) else: raise ValueError('Inalid corner: %r' % corner) window.add(icon) icon.show() window.show() self._notif_by_icon[icon] = window GObject.timeout_add(duration, lambda: self.remove_notification(icon))
def _addChild(self, iter, parent): ''' Add the new child to the given accessible. @param iter: Th iter of the row that needs a child added. @type iter: L{gtk.TreeIter} @param parent: The given row's accessible. @type parent: L{Accessibility.Accessible} ''' old_children = self.model.getChildrenAccs(iter) new_children = list(parent) if self.model.getHideLeaves(): # time for new child load its children (if it has any), # so it won't be confused with a leaf sleep(ACCESSIBLE_LOADING) new_children = self.removeLeaves(new_children) old_children = set(old_children) new_children = set(new_children) added = new_children.difference(old_children) try: new_child = added.pop() except KeyError: return row = self.model._buildRow(new_child) if new_child is None: self.model.append(iter, row) else: self.model.insert(iter, self.model.getIndexInParent(new_child), row) # We do this because an application won't have an icon loaded in # the window manager when it is first registered to at-spi if new_child == new_child.getApplication(): GObject.timeout_add(1000, self._refreshIcon, new_child)
def showGUI(self): """Show the splash screen dialog.""" imageFile = os.path.join(orca_platform.prefix, orca_platform.datadirname, orca_platform.package, "gfx", "orca-splash.png") image = Gtk.Image() image.set_from_file(imageFile) self.add(image) try: self.realize() except: debug.printException(debug.LEVEL_FINEST) self.set_transient_for(None) self.grab_focus() self.show_all() GObject.timeout_add(3000, self.hideGUI) while Gtk.events_pending(): Gtk.main_iteration() return self
def on_category_clicked(self, btn, cat): """emit the category-selected signal when a category was clicked""" def timeout_emit(): self.emit("category-selected", cat) return False GObject.timeout_add(50, timeout_emit)
def __init__(self): cream.Module.__init__(self, 'org.cream.Chronos') self.events = {} self.calendars = ordereddict() self.colors = find_colors(.57, .72, .79) self.calendar = cream.ipc.get_object('org.cream.PIM', '/org/cream/PIM/Calendar') self.calendar.search_for_calendars() self.calendar.connect_to_signal('calendar_added', self.add_calendar) self.calendar.connect_to_signal('event_added', lambda u,e: self.add_events([e])) self.calendar.connect_to_signal('event_removed', lambda u,e: self.remove_events([e])) self.calendar.connect_to_signal('event_updated', lambda u,e: self.update_events([e])) self.calendar_ui = CalendarUI() self.calendar_ui.window.connect('delete_event', lambda *x: self.quit()) self.calendar_ui.connect('calendar-state-changed', self.calendar_state_change_cb) for calendar in self.calendar.get_calendars(): self.add_calendar(calendar['uid'], calendar) def add_events(): events = self.calendar.query({}) self.add_events(events) gobject.timeout_add(1, add_events)
def __init__(self, callback=None): self.on_receive_callback = callback self._type = "rabbitmq" MM = 'majormajor' # connect to the global channels where messages are broadcasted writes = random.sample(xrange(4), 2) reads = [x for x in xrange(4) if not x in writes] self.global_write_queues = [MM + str(x) for x in writes] self.global_read_queues = [MM + str(x) for x in reads] connection = pika.BlockingConnection( pika.ConnectionParameters('localhost')) channel = connection.channel() for x in xrange(4): q = MM + str(x) channel.queue_declare(queue=q) # set up a new queue where people can message this person directly. self.read_queue = False i = 0 while self.read_queue is False: queue_name = MM + str(i) try: connection = pika.BlockingConnection( pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue=queue_name, passive=True) except: connection = pika.BlockingConnection( pika.ConnectionParameters('localhost')) self.channel = connection.channel() self.channel.queue_declare(queue=queue_name) self.read_queue = queue_name i += 1 self.all_read_queues = [self.read_queue] + self.global_read_queues[:] GObject.timeout_add(100, self._check_for_messages)
def _addChild(self, iter, parent): ''' Add the new child to the given accessible. @param iter: Th iter of the row that needs a child added. @type iter: L{gtk.TreeIter} @param parent: The given row's accessible. @type parent: L{Accessibility.Accessible} ''' old_children = set(self.model.getChildrenAccs(iter)) new_children = set(list(parent)) added = new_children.difference(old_children) try: new_child = added.pop() except KeyError: return row = self.model._buildRow(new_child) if new_child is None: self.model.append(iter, row) else: self.model.insert(iter, new_child.getIndexInParent(), row) # We do this because an application won't have an icon loaded in # the window manager when it is first registered to at-spi if new_child == new_child.getApplication(): GObject.timeout_add(1000, self._refreshIcon, new_child)
def _button_release_cb(win, event, sw): if sw.press == None: return True for i in range (0,4): if sw.press == sw.buttons_off[i].spr: sw.buttons_on[i].draw_sprite(1500) GObject.idle_add(__play_sound_cb, sw.sound_files[i], sw.sound) GObject.timeout_add(500,sw.buttons_on[i].spr.hide) if sw.playpushed is False: sw.press = None return if sw.seq[sw.counter] == i: # correct reponse sw.counter += 1 if sw.counter == sw.level*2: GObject.timeout_add(1000, _dance, sw, [i], 10, 0) sw.counter = 0 sw.level += 1 sw.activity.level_label.set_text( "%s %d" % (_("Level"),sw.level)) if sw.level*2 < len(sw.seq): GObject.timeout_add(3000, play_the_game, sw) else: # game over GObject.timeout_add(2000, _flash, sw, 7, True) sw.playpushed = False sw.level = 1 sw.seq = gen_seq(30) sw.activity.level_label.set_text( "%s %d" % (_("Level"),sw.level)) else: # incorrect response _all_gone(sw) GObject.timeout_add(1000, _all_off, sw) sw.counter = 0 sw.press = None
def icon_bell(self): """A bell signal requires we display our bell icon""" self.bellicon.show() GObject.timeout_add(1000, self.icon_bell_hide)
#prid = src.add_probe(Gst.PadProbeType.BLOCK, block, None) queue.unlink(preview) scale.set_state(Gst.State.PLAYING) queue.link(scale) scale.link_filtered(preview, preview_caps) #src.remove_probe(prid) self.pipeline.set_state(Gst.State.PLAYING) def pmsg(self, msg_bus, msg): if msg.type == Gst.MessageType.ERROR or msg.type == Gst.MessageType.EOS: ml.quit() if msg.type == Gst.MessageType.STATE_CHANGED: #print pipeline.get_state(Gst.CLOCK_TIME_NONE).state self.stats(msg_bus) c1 = Capture() c2 = Capture() GObject.timeout_add(1000, c1.addPreview) GObject.timeout_add(1000, c2.addPreview) GObject.timeout_add(2000, c1.addScaler) try: ml.run() finally: # Free resources when mainloop terminates c1.pipeline.set_state(Gst.State.NULL) c2.pipeline.set_state(Gst.State.NULL)
def solve(self): ''' Solve the puzzle by undoing moves ''' if self._move_list == []: return self._flip_them(self._move_list.pop(), append=False) GObject.timeout_add(750, self.solve)
def on_entry_changed(self, widget): if self._value_changed_timer: GObject.source_remove(self._value_changed_timer) self._value_changed_timer = GObject.timeout_add( 300, self.update_from_entry)
def resume_monitor(self): if self.resume_timeout: GObject.source_remove(self.resume_timeout) self.resume_timeout = GObject.timeout_add(2000, self.do_resume)
def on_file_changed(self, file, other, event, data): if self.file_changed_timeout: GObject.source_remove(self.file_changed_timeout) self.file_changed_timeout = GObject.timeout_add(300, self.do_reload)
def on_my_value_changed(self, widget): if self._value_changed_timer: GObject.source_remove(self._value_changed_timer) self._value_changed_timer = GObject.timeout_add( 300, self.update_settings_value)
def install_ffmpeg(self): """Called by self.run(). A modified version of self.install_ytdl, that installs FFmpeg on an MS Windows system. Creates a child process to run the installation process. Reads from the child process STDOUT and STDERR, and calls the main application with the result of the update (success or failure). """ # Show information about the update operation in the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, _('Starting update operation, installing FFmpeg'), ) # Create a new child process to install either the 64-bit or 32-bit # version of FFmpeg, as appropriate if sys.maxsize <= 2147483647: binary = 'mingw-w64-i686-ffmpeg' else: binary = 'mingw-w64-x86_64-ffmpeg' self.create_child_process(['pacman', '-S', binary, '--noconfirm'], ) # Show the system command in the Output Tab space = ' ' self.app_obj.main_win_obj.output_tab_write_system_cmd( 1, space.join(['pacman', '-S', binary, '--noconfirm']), ) # So that we can read from the child process STDOUT and STDERR, attach # a file descriptor to the PipeReader objects if self.child_process is not None: self.stdout_reader.attach_file_descriptor( self.child_process.stdout, ) self.stderr_reader.attach_file_descriptor( self.child_process.stderr, ) while self.is_child_process_alive(): # Read from the child process STDOUT, and convert into unicode for # Python's convenience while not self.stdout_queue.empty(): stdout = self.stdout_queue.get_nowait().rstrip() stdout = stdout.decode('cp1252') if stdout: # Show command line output in the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, stdout, ) # The child process has finished while not self.stderr_queue.empty(): # Read from the child process STDERR queue (we don't need to read # it in real time), and convert into unicode for python's # convenience stderr = self.stderr_queue.get_nowait().rstrip() stderr = stderr.decode('cp1252') # Ignore pacman warning messages, e.g. 'warning: dependency cycle # detected:' if stderr and not re.match('warning\:', stderr): self.stderr_list.append(stderr) # Show command line output in the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, stderr, ) # (Generate our own error messages for debugging purposes, in certain # situations) if self.child_process is None: self.stderr_list.append(_('FFmpeg installation did not start')) elif self.child_process.returncode > 0: self.stderr_list.append( _('Child process exited with non-zero code: {}').format( self.child_process.returncode, )) # Operation complete. self.success_flag is checked by # mainapp.TartubeApp.update_manager_finished if not self.stderr_list: self.success_flag = True # Show a confirmation in the the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, _('Update operation finished'), ) # Let the timer run for a few more seconds to prevent Gtk errors (for # systems with Gtk < 3.24) GObject.timeout_add( 0, self.app_obj.update_manager_halt_timer, )
def activateCb(self, app): #Global Variables (keep to a minimum) self.settings = settings.IconoSettings(sopranoGlobals.SETTINGS_DATA) self.taglookup = TrackMetaData() self.seekingnow = False #load settings self.currentview, self.winwidth, self.winheight, self.defaultexplorer, self.shuffle, self.repeat, self.showtrayicon, self.closetotray = self.settings.get_settings( ) libraryFolderlist = settings.IconoPrefs(sopranoGlobals.LIBRARY_DATA) self.SopranoDB = MusicDB( os.path.join(sopranoGlobals.CONFIGDIR, 'sopranoDB.db')) libraryFolderlist.add_radio( ('/media/Media/Music', '/media/Media/Music')) for key, value in libraryFolderlist.get_radioStations().items(): self.SopranoDB.add_folder(value) #turn on the dbus mainloop for sound menu from dbus.mainloop.glib import DBusGMainLoop DBusGMainLoop(set_as_default=True) #Start Sound Menu Support self.sopranompris = SoundMenuControls("soprano-player") self.sopranompris.signal_next = self.play_next self.sopranompris.signal_prev = self.play_prev self.sopranompris.signal_play_pause = self.play_pause self.sopranompris.signal_raise = self.toggle_window #Enable Notifications Notify.init("Soprano") self.notification = Notify.Notification.new("", "", "") #Window Creation self.builder = Gtk.Builder() filename = os.path.join('data', 'MainWindow.glade') self.builder.add_from_file(filename) self.builder.connect_signals(self) self.window = self.builder.get_object('win-main') self.window.set_default_size(self.winwidth, self.winheight) self.window.connect('delete-event', self.pre_exit) self.window.set_wmclass("Soprano Player", "Soprano Player") app.add_window(self.window) hb = self.builder.get_object('header-bar') self.window.set_titlebar(hb) #radiowindow self.aRadio = IconoRadio() #Gstreamer sink self.player = MusicPlayer() self.player.on_eos(self.on_message) #media keys setup self.mediakeys = mediakeys(self.play_prev, self.play_pause, self.play_next) timer = GObject.timeout_add(500, self.update_time_items) #trayicon self.tray = IconoTray("soprano-player-tray") self.trayshowhide = self.tray.add_menu_item(self.toggle_window, "Hide/Show") self.tray.add_seperator() self.trayplaypause = self.tray.add_menu_item(self.play_pause, "Play/Pause") self.tray.add_menu_item(self.play_next, "Next") self.tray.add_menu_item(self.play_prev, "Previous") self.tray.add_seperator() self.tray.add_menu_item(self.on_exit, "Quit") self.update_tray_icon(self.showtrayicon) # View Menu# #menuvfull = self.builder.get_object('menu-mode-full') #menuvfull.connect('activate', self.to_full_mode) #menuvmini = self.builder.get_object('menu-mode-mini') #menuvmini.connect('activate', self.to_mini_mode) #menuvplist = self.builder.get_object('menu-mode-playlist') #menuvplist.connect('activate', self.to_playlist_mode) # Quit, About Menus #menuaqt = self.builder.get_object('menu-quit') #menuaqt.connect('activate',self.on_exit) #menuabt = self.builder.get_object('menu-about') #menuabt.connect('activate', aboutBoxShow, self.window) #Edit Menu# #menuaddfolder = self.builder.get_object('menu-folderadd') #menuaddfolder.connect('activate', lambda x: self.addFolderExplorer(('Video','/media/Media/Videos'))) #menuaddfolder.connect('activate', self.show_pref_win) #menuaddradio = self.builder.get_object('menu-radioadd') #menuaddradio.connect('activate', lambda x: self.delFolderExplorer(('Video','/media/Media/Videos'))) #menuaddradio.connect('activate', self.aRadio.addStationDialog) #self.menuautopop = self.builder.get_object('menu-autopop') # Build the Gnome App Menu mainmenu = self.builder.get_object('app-menu') self.set_app_menu(mainmenu) prefs_action = Gio.SimpleAction.new("prefs", None) prefs_action.connect("activate", self.show_pref_win) self.add_action(prefs_action) radio_action = Gio.SimpleAction.new("radio", None) radio_action.connect("activate", self.aRadio.addStationDialog) self.add_action(radio_action) self.menuautopop = False autopop_action = Gio.SimpleAction.new("autopop", None) autopop_action.connect("activate", self.toggleAutoPop) self.add_action(autopop_action) view_full_action = Gio.SimpleAction.new("view-full", None) view_full_action.connect("activate", self.to_full_mode) self.add_action(view_full_action) view_playlist_action = Gio.SimpleAction.new("view-playlist", None) view_playlist_action.connect("activate", self.to_playlist_mode) self.add_action(view_playlist_action) view_mini_action = Gio.SimpleAction.new("view-mini", None) view_mini_action.connect("activate", self.to_mini_mode) self.add_action(view_mini_action) about_action = Gio.SimpleAction.new("about", None) about_action.connect("activate", aboutBoxShow, self.window) self.add_action(about_action) quit_action = Gio.SimpleAction.new("quit", None) quit_action.connect("activate", self.on_exit) self.add_action(quit_action) #playing Toolbar self.toolnext = self.builder.get_object('btn-next') self.toolnext.connect('clicked', self.play_next) self.toolprev = self.builder.get_object('btn-previous') self.toolprev.connect('clicked', self.play_prev) self.toolstop = self.builder.get_object('btn-stop') self.toolstop.connect('clicked', self.stop_play) self.toolplay = self.builder.get_object('btn-play') self.toolplay.connect('clicked', self.play_pause) self.toolSeekBar = self.builder.get_object('scl-position') self.toolSeekBar.connect('button-release-event', self.seek) self.toolSeekBar.connect('button-press-event', self.seekevent) self.toolVolume = self.builder.get_object('btn-volume') self.toolVolume.connect('value-changed', self.change_volume) #Text Displays self.titleText = self.builder.get_object('lbl-trkTitle') #self.titleText.connect('size-allocate', lambda label, size: label.set_size_request(size.width - 1, -1)) self.infoText = self.builder.get_object('lbl-trkMisc') self.lengthLabel = self.builder.get_object('lbl-length') self.elapsedLabel = self.builder.get_object('lbl-elapsed') #bottom toolbar barclr = self.builder.get_object('btn-tracklistClear') barclr.connect('clicked', self.clear_liststore) barshfl = self.builder.get_object('btn-tracklistShuffle') if self.shuffle == True: barshfl.set_active(True) barshfl.connect('clicked', self.shuffleliststore) barrpt = self.builder.get_object('btn-tracklistRepeat') if self.repeat == True: barrpt.set_active(True) barrpt.connect('toggled', self.setrepeat) #listview self.iconoListView = IconoListView() self.iconoListView.get_sw().get_child().connect( 'row-activated', self.on_activated) #self.iconoListView.get_sw().get_child().connect('button-press-event', self.on_right_click) vbox2 = self.builder.get_object('vbox2') vbox2.add(self.iconoListView.get_sw()) vbox2.reorder_child(self.iconoListView.get_sw(), 1) if os.path.exists(sopranoGlobals.TREE_DATA): GObject.idle_add(self.iconoListView.load_shelf, sopranoGlobals.TREE_DATA) #combobox self.hCombo = HeaderedComboBox() self.hCombo.connect("changed", self.on_name_combo_changed) self.builder.get_object('box-combo-explorer').add(self.hCombo) GObject.idle_add(self.setup_explorer) GObject.idle_add(self.cover_update) self.window.show_all() if self.currentview == 'playlist': menuvplist.set_active(True) self.to_playlist_mode() elif self.currentview == 'mini': menuvmini.set_active(True) self.to_mini_mode() #Notebook self.notebook = self.builder.get_object('notebook-explorer')
def install_ytdl(self): """Called by self.run(). Based on code from downloads.VideoDownloader.do_download(). Creates a child process to run the youtube-dl update. Reads from the child process STDOUT and STDERR, and calls the main application with the result of the update (success or failure). """ # Show information about the update operation in the Output Tab downloader = self.app_obj.get_downloader() self.app_obj.main_win_obj.output_tab_write_stdout( 1, _('Starting update operation, installing/updating ' + downloader), ) # Prepare the system command # The user can change the system command for updating youtube-dl, # depending on how it was installed # (For example, if youtube-dl was installed via pip, then it must be # updated via pip) cmd_list \ = self.app_obj.ytdl_update_dict[self.app_obj.ytdl_update_current] mod_list = [] for arg in cmd_list: # Substitute in the fork, if one is specified arg = self.app_obj.check_downloader(arg) # Convert a path beginning with ~ (not on MS Windows) if os.name != 'nt': arg = re.sub('^\~', os.path.expanduser('~'), arg) mod_list.append(arg) # Create a new child process using that command self.create_child_process(mod_list) # Show the system command in the Output Tab space = ' ' self.app_obj.main_win_obj.output_tab_write_system_cmd( 1, space.join(mod_list), ) # So that we can read from the child process STDOUT and STDERR, attach # a file descriptor to the PipeReader objects if self.child_process is not None: self.stdout_reader.attach_file_descriptor( self.child_process.stdout, ) self.stderr_reader.attach_file_descriptor( self.child_process.stderr, ) while self.is_child_process_alive(): # Read from the child process STDOUT, and convert into unicode for # Python's convenience while not self.stdout_queue.empty(): stdout = self.stdout_queue.get_nowait().rstrip() if stdout: if os.name == 'nt': stdout = stdout.decode('cp1252') else: stdout = stdout.decode('utf-8') # "It looks like you installed youtube-dl with a package # manager, pip, setup.py or a tarball. Please use that to # update." # "The script youtube-dl is installed in '...' which is not # on PATH. Consider adding this directory to PATH..." if re.search('It looks like you installed', stdout) \ or re.search( 'The script ' + downloader + ' is installed', stdout, ): self.stderr_list.append(stdout) else: # Try to intercept the new version number for # youtube-dl self.intercept_version_from_stdout(stdout) self.stdout_list.append(stdout) # Show command line output in the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, stdout, ) # The child process has finished while not self.stderr_queue.empty(): # Read from the child process STDERR queue (we don't need to read # it in real time), and convert into unicode for python's # convenience stderr = self.stderr_queue.get_nowait().rstrip() if os.name == 'nt': stderr = stderr.decode('cp1252') else: stderr = stderr.decode('utf-8') if stderr: # If the user has pip installed, rather than pip3, they will by # now (mid-2019) be seeing a Python 2.7 deprecation warning. # Ignore that message, if received # If a newer version of pip is available, the user will see a # 'You should consider upgrading' warning. Ignore that too, # if received if not re.search('DEPRECATION', stderr) \ and not re.search('You are using pip version', stderr) \ and not re.search('You should consider upgrading', stderr): self.stderr_list.append(stderr) # Show command line output in the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, stderr, ) # (Generate our own error messages for debugging purposes, in certain # situations) if self.child_process is None: msg = _('Update did not start') self.stderr_list.append(msg) self.app_obj.main_win_obj.output_tab_write_stdout( 1, msg, ) elif self.child_process.returncode > 0: msg = _('Child process exited with non-zero code: {}').format( self.child_process.returncode, ) self.app_obj.main_win_obj.output_tab_write_stdout( 1, msg, ) # Operation complete. self.success_flag is checked by # mainapp.TartubeApp.update_manager_finished if not self.stderr_list: self.success_flag = True # Show a confirmation in the the Output Tab self.app_obj.main_win_obj.output_tab_write_stdout( 1, _('Update operation finished'), ) # Let the timer run for a few more seconds to prevent Gtk errors (for # systems with Gtk < 3.24) GObject.timeout_add( 0, self.app_obj.update_manager_halt_timer, )
def __init__(self, bus, index, service): Characteristic.__init__(self, bus, index, self.BATTERY_LVL_UUID, ['read', 'notify'], service) self.notifying = False self.battery_lvl = 100 GObject.timeout_add(5000, self.drain_battery)
thymio = Thymio() def avancer(vitesse, temps): thymio.setMotors(vitesse, vitesse) time.sleep(temps) def tournerAngle(angle): if angle <= 0: thymio.setMotors(300, -300) time.sleep(abs(angle) / 112) if angle > 0: thymio.setMotors(-300, 300) time.sleep(abs(angle) / 112) def avancerCourbe(vitessegauche, vitessedroite, temps): thymio.setMotors(vitessegauche, vitessedroite) time.sleep(temps) def arret(): thymio.setMotors(0, 0) avancer(300, 2) tournerAngle(180) avancerCourbe(1000, 1000, 2) arret() loop = GObject.MainLoop() handle = GObject.timeout_add(1000, Braitenberg) loop.run()
def mkdir(self, path): #This will "schedule" the internal function to be called later ret = GObject.timeout_add(0, self._mkdir, path) return ret >= 0
def set_timeout(self, timeout): GObject.timeout_add(timeout, self.stop)
def delay_destroy_window(window, delay): GObject.timeout_add(int(delay * 1000), _window_destroy_event, window)
def _counter(self): ''' Display game_time as hours:minutes:seconds. ''' self._game_time_seconds += 1 self._game_time = convert_seconds_to_minutes(self._game_time_seconds) self._set_label(self._game_time) self._timeout_id = GObject.timeout_add(1000, self._counter)
def after_show(*args): def f(): self.move_to_monitor(self.options.monitor) self.prepare_next_data() self.next() GObject.timeout_add(200, f)
def get_path_contents(self, path): #This will "schedule" the internal function to be called later ret = GObject.timeout_add(0, self._get_path_contents, path) return ret >= 0
def start(self): self.timeout_id = GObject.timeout_add(self.timeout_secs * 1000, self.handler, *self.args)
def __nick_changed_cb(self, widget, data=None): if self._nick_sid: GObject.source_remove(self._nick_sid) self._nick_sid = GObject.timeout_add(self._APPLY_TIMEOUT, self.__nick_timeout_cb, widget)
def handle_status(self, origin, status): """Activates or deactivates the buttons depending on the new status""" record = self.gui.get_object("recbutton") pause = self.gui.get_object("pausebutton") stop = self.gui.get_object("stopbutton") helpb = self.gui.get_object("helpbutton") editb = self.gui.get_object("editbutton") prevb = self.gui.get_object("previousbutton") swapb = self.gui.get_object("swapbutton") if status == INIT_STATUS: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) swapb.set_sensitive(False) elif status == PREVIEW_STATUS: record.set_sensitive((self.allow_start or self.allow_manual)) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) swapb.set_sensitive(True) elif status == RECORDING_STATUS: GObject.timeout_add(500, self.recording_info_timeout, self.gui.get_object("recording1"), self.gui.get_object("recording3")) record.set_sensitive(False) pause.set_sensitive(self.allow_pause and self.recorder.is_pausable()) stop.set_sensitive((self.allow_stop or self.allow_manual)) helpb.set_sensitive(True) prevb.set_sensitive(False) swapb.set_sensitive(False) editb.set_sensitive((self.recorder.current_mediapackage and self.recorder.current_mediapackage.manual) or False) elif status == PAUSED_STATUS: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) prevb.set_sensitive(False) helpb.set_sensitive(False) editb.set_sensitive(False) elif status == ERROR_STATUS: record.set_sensitive(False) pause.set_sensitive(False) stop.set_sensitive(False) helpb.set_sensitive(True) prevb.set_sensitive(True) editb.set_sensitive(False) if self.focus_is_active: self.launch_error_message() if status == PAUSED_STATUS: GLib.idle_add(self.show_pause_dialog) else: if self.pause_dialog: GLib.idle_add(self.hide_pause_dialog) # Change status label if status in STATUSES: self.view.set_displayed_row(Gtk.TreePath(STATUSES.index(status))) else: logger.error( "Unable to change status label, unknown status {}".format( status)) # Close error dialog if status not in [ERROR_STATUS] and self.error_dialog: self.destroy_error_dialog()
#!/usr/bin/python3 from gi.repository import GObject import os import spp_server def my_read_cb(value): print('my callback: {}'.format(value)) def my_write_cb(my_server): cpu_temp = os.popen('vcgencmd measure_temp').readline() if my_server.fd_available(): my_server.write_spp('{}'.format( float(cpu_temp.replace('temp=', '').replace("'C\n", '')))) print('Sending: {}'.format( float(cpu_temp.replace('temp=', '').replace("'C\n", '')))) return True if __name__ == '__main__': my_spp_server = spp_server.SPP(my_read_cb) GObject.timeout_add(1000, my_write_cb, my_spp_server) my_spp_server.start()
def _timer_schedule(self): self._invalidate_current_timer() GObject.timeout_add(int(round(self._wait_seconds * 1000)), self._timer_check_run, self._current_timer_id)
def __init__(self, package=None): logger.info("Creating Recording Area") Gtk.Box.__init__(self) builder = Gtk.Builder() builder.add_from_file(get_ui_path('recorder.glade')) release = builder.get_object("release_label") release.set_label(get_footer()) # TEST self.repo = context.get_repository() self.dispatcher = context.get_dispatcher() self.worker = context.get_worker() self.conf = context.get_conf() self.recorder = context.get_recorder() self.recorder.set_create_drawing_areas_func(self.create_drawing_areas) self.start_recording = False self.font = None self.scheduled_recording = False self.focus_is_active = False self.net_activity = None self.error_dialog = None self.close_before_response_action = False # BUILD self.recorderui = builder.get_object("recorderbox") self.main_area = builder.get_object("videobox") self.vubox = builder.get_object("vubox") self.gui = builder # VUMETER self.rangeVum = 50 self.thresholdVum = self.conf.get_float('audio', 'min') self.mute = False self.stereo = True self.vumeterL = builder.get_object("progressbarL") self.vumeterR = builder.get_object("progressbarR") self.label_channels = builder.get_object("label_channels") self.low_audio = False self.lowaudio_threshold = self.conf.get_float('lowaudio', 'lowaudio_threshold') # SWAP if not self.conf.get_boolean('basic', 'swapvideos'): self.gui.get_object("swapbutton").destroy() self.swap = False # STATUS self.view = self.set_status_view() hbox1 = self.gui.get_object('hbox1') hbox1.add(self.view) self.dispatcher.connect_ui("init", self.check_status_area) self.dispatcher.connect_ui("init", self.check_net, None) self.dispatcher.connect_ui("opencast-status", self.check_net) # UI self.pack_start(self.recorderui, True, True, 0) self.pause_dialog = None # Event Manager self.dispatcher.connect_ui("recorder-vumeter", self.set_vumeter) self.dispatcher.connect_ui("view-changed", self.event_change_mode) self.dispatcher.connect_ui("recorder-status", self.handle_status) self.dispatcher.connect_ui("recorder-ready", self.reset_mute) # STATES self.previous = None # PERMISSIONS self.allow_pause = self.conf.get_permission("pause") self.allow_start = self.conf.get_permission("start") self.allow_stop = self.conf.get_permission("stop") self.allow_manual = self.conf.get_permission("manual") self.allow_overlap = self.conf.get_permission("overlap") self.help_main_str = self.conf.get('help', 'main') self.help_text_str = self.conf.get('help', 'text') # OTHER builder.connect_signals(self) self.net_activity = self.conf.get_boolean('ingest', 'active') self.pausedialog_size = self.conf.get_int('basic', 'pausedialog_size', default=15) if self.pausedialog_size < 5: self.pausedialog_size = 5 elif self.pausedialog_size > 100: self.pausedialog_size = 100 self.proportion = 1 #TIMEOUTS deps = self.update_scheduler_deps() GObject.timeout_add(500, self.update_scheduler_timeout, *deps) self.update_clock_timeout(self.gui.get_object("local_clock")) GObject.timeout_add(10000, self.update_clock_timeout, self.gui.get_object("local_clock"))
def grab_focus(self): def cb(*args): self.embed.grab_focus() GObject.timeout_add(10, cb)
def _find_cb(self, widget, data): # This loop makes sure that we only call _find every 500 ms . if self.timer_id: # We destroy the last event source and create another one. GObject.source_remove(self.timer_id) self.timer_id = GObject.timeout_add(500, self._find, widget, data)
def message(self, msg, timeout=1500): self.stop() self.set_label(msg) self.set_cancellable(False) GObject.timeout_add(timeout, self.finalize)
def _check_for_notifications(self): print 'Checking Settings notifications' if not self.notifying: return GObject.timeout_add(1000, self.notify_handset)
def blink(self): GObject.timeout_add(75, self.on_blink_tick)
def start_progress_pulse(self): if self.pulse_timer > 0: return self.progress.pulse() self.pulse_timer = GObject.timeout_add(1050, self.progress_pulse_tick)