python类source_remove()的实例源码

def new_question(self):
        """returns:
            self.ERR_PICKY : if the question is not yet solved and the
            teacher is picky (== you have to solve the
            question before a new is asked).
            self.OK : if a new question was created.
            self.ERR_NO_ELEMS : if no elements are set to be practised.
            """
        if self.m_timeout_handle:
            GObject.source_remove(self.m_timeout_handle)
            self.m_timeout_handle = None

        if self.get_bool('config/picky_on_new_question') \
            and self.q_status in [self.QSTATUS_NEW, self.QSTATUS_WRONG]:
                return self.ERR_PICKY

        self.q_status = self.QSTATUS_NO
        if not self.m_P.header.solmisation_elements:
            return self.ERR_NO_ELEMS
        self.m_question = []
        for x in range(self.get_int("num_notes")):
            self.m_question.append(random.choice(self.m_P.header.solmisation_elements))
        self.q_status = self.QSTATUS_NEW
        self.m_transp = random.randint(-5, 6)
        return self.OK

def new_question(self):
        """
        UI will never call this function unless we have a usable lessonfile.
        """
        if self.m_timeout_handle:
            GObject.source_remove(self.m_timeout_handle)
            self.m_timeout_handle = None

        if solfege.app.m_test_mode:
            self.m_P.next_test_question()
            self.q_status = self.QSTATUS_NEW
            return self.OK

        if self.get_bool('config/picky_on_new_question') \
                 and self.q_status in [self.QSTATUS_NEW, self.QSTATUS_WRONG]:
            return Teacher.ERR_PICKY

        self.q_status = self.QSTATUS_NO

        assert self.m_P
        self.m_P.select_random_question()
        self.q_status = self.QSTATUS_NEW
        return self.OK

def new_question(self):
        """
        Return a true value if a new question was created otherwise false.
        """
        if self.m_timeout_handle:
            GObject.source_remove(self.m_timeout_handle)
            self.m_timeout_handle = None

        if self.get_bool('config/picky_on_new_question') \
                 and self.q_status in [self.QSTATUS_NEW, self.QSTATUS_WRONG]:
            return Teacher.ERR_PICKY

        first = self.get_list('first_interval_up')
        if self.get_string('first_interval_type') == 'melodic':
            first = first + map(lambda a: -a, self.get_list('first_interval_down'))
        last = self.get_list('last_interval_up')
        if self.get_string('last_interval_type') == 'melodic':
            last = last + map(lambda a: -a, self.get_list('last_interval_down'))
        if not (first and last):
            return self.ERR_CONFIGURE
        self.m_intervals = [random.choice(first), random.choice(last)]
        self.m_tonikas = [mpd.MusicalPitch().randomize("f", "f'"),
                          mpd.MusicalPitch().randomize("f", "f'")]
        self.q_status = self.QSTATUS_NEW
        return self.OK

def flash(self, txt, **kwargs):
        """Display a message that is automatically removed after some time.
        If we flash a new message before the old flashed message are removed,
        we old flashed message are removed.
        """
        if self.__timeout:
            GObject.source_remove(self.__timeout)
        self.display(txt, **kwargs)

        def f(self=self):
            self.__timeout = None
            if self.__stack:
                self.display(self.__stack[-1][0], **self.__stack[-1][1])

            else:
                self.empty()
        self.__timeout = GObject.timeout_add(2000, f)

def _mic_level_watcher(self, bus, message, *args):
        structure = message.get_structure()
        peak = structure.get_value('peak')[0]
        self._log.info("Peak level %s", peak)
        if peak > SILENCE_DETECTION_RANGE[0] and not self.speaking_started:
            self.audio_from_mic = queue.Queue()
            self._log.info("Speaking started into queue %s", self.audio_from_mic)
            self.speaking_started = True
            if self._listening_timeout_timer:
                GObject.source_remove(self._listening_timeout_timer)
            self.speaking_finished_event = threading.Event()
            self.RecognizeCallback(self.audio_from_mic,
                                   self._mic_pipeline.dialogid,
                                   self.speaking_finished_event)
        if peak < SILENCE_DETECTION_RANGE[1] and self.speaking_started:
            self.silence_count += 1
            if self.silence_count > 2:
                self._log.info("Speaking finished")
                self.speaking_started = False
                self.silence_count = 0
                self._mic_pipeline.set_state(Gst.State.PAUSED)
                self.speaking_finished_event.set()
                aplay(ACK_BEEP, _bg=True)

        return True

def _set_repeat(self, delay=None, interval=None):
        if delay is not None and self.__repeat[0] is None:
            self.__tick_id = GObject.timeout_add(10, self._tick_cb)
        elif delay is None and self.__repeat[0] is not None:
            GObject.source_remove(self.__tick_id)
        self.__repeat = (delay, interval)

def set_refresh_interval(self, widget):
        """
        Set new refresh interval and remove existing
        timeout if already exist.
        """
        interval = int(widget.get_name())
        if interval != self.config.get('refresh_interval'):
            GObject.source_remove(self.services['timeout'])
            self.run_background(interval)
            self.cfg_cls.set_key('refresh_interval', interval)

def quit(self, widget):
        if self.services['timeout']:
            GObject.source_remove(self.services['timeout'])
        os.unlink(self.cfg_cls.LOCKFILE)
        Gtk.main_quit()

def on_songs_start_change(self, widget, event):
        if self._timer:
            GObject.source_remove(self._timer)
            self._timer = None

def set_play(self, pos, time):
        if self._timer is not None:
            GObject.source_remove(self._timer)
            self._timer = None
        tracks = self._current_album.get_tracks()
        for index in range(0, pos):
            time = time + tracks[index].get_length()

        self._songs_scale.set_value(time+1)
        self._timer = GObject.timeout_add(1000, self._playing)

def set_pause(self):
        if self._timer is not None:
            GObject.source_remove(self._timer)
            self._timer = None

def end_practise(self):
        if self.m_timeout_handle:
            GObject.source_remove(self.m_timeout_handle)
            self.m_timeout_handle = None
        self.q_status = self.QSTATUS_NO
        soundcard.synth.stop()

def new_question(self):
        """returns:
               self.ERR_PICKY : if the question is not yet solved and the
                                   teacher is picky (== you have to solve the
                                   question before a new is asked).
               self.OK : if a new question was created.
               self.ERR_NO_ELEMS : if no elements are set to be practised.
        """
        if self.m_timeout_handle:
            GObject.source_remove(self.m_timeout_handle)
            self.m_timeout_handle = None

        if self.get_bool('config/picky_on_new_question') \
                 and self.q_status in [self.QSTATUS_NEW, self.QSTATUS_WRONG]:
            return self.ERR_PICKY

        self.q_status = self.QSTATUS_NO

        norest_v = []
        v = []
        for x in self.m_P.header.rhythm_elements:
            if not (const.RHYTHMS[x][0] == "r"
                    and self.get_bool("not_start_with_rest")):
                norest_v.append(x)
            v.append(x)

        if not v:
            return self.ERR_NO_ELEMS

        if not norest_v:
            return self.ERR_NO_ELEMS
        self.m_question = [random.choice(norest_v)]
        for x in range(1, self.get_int("num_beats")):
            self.m_question.append(random.choice(v))
        self.q_status = self.QSTATUS_NEW
        return self.OK

def on_end_practise(self):
        #Gtk.idle_remove(self.__idle_tag)
        GObject.source_remove(self.__idle_tag)
        soundcard.solfege_c_midi.dsp_close()

def create_holders(self):
        """
        create those |__| that represents one beat
        """
        if self.__timeout:
            GObject.source_remove(self.__timeout)
        self.clear()
        for x in range(self.m_num_beats):
            self.g_box.pack_start(gu.create_png_image('holder'), False, False, 0)
        self.m_data = []

def create_holders(self):
        """
        create those |__| that represents one beat
        """
        if self.__timeout:
            GObject.source_remove(self.__timeout)
        self.clear()
        for x in range(self.m_num_notes):
            self.g_box.pack_start(gu.create_png_image('holder'), False, False, 0)
        self.m_data = []

def display(self, txt, **kwargs):
        self.empty()
        r = re.compile("(\{\w+\})") # Unicode??
        self.set_size_request(-1, -1)
        for child in r.split(txt):
            m = r.match(child)
            if m:
                varname = child[1:][:-1]
                from solfege import lessonfilegui

                if isinstance(kwargs[varname], basestring):
                    w = Gtk.Label(label=kwargs[varname])
                    w.set_name("FlashBarLabel")

                else:
                    w = lessonfilegui.new_labelobject(kwargs[varname])

            elif child: # don't create label for empty string
                w = Gtk.Label(label=child)
                w.set_name("FlashBarLabel")
            self.__content.pack_start(w, False, False, 0)
            w.show()
        self.m_sx = max(self.size_request().width, self.m_sx)
        self.m_sy = max(self.size_request().height, self.m_sy)
        self.set_size_request(self.m_sx, self.m_sy)

        if self.__timeout:
            GObject.source_remove(self.__timeout)
            self.__timeout = None

def on_up_release(self, eb, ev):
        if self.m_timeout:
            GObject.source_remove(self.m_timeout)
            self.m_timeout = None

def on_down_press(self, eb, ev):
        if self.m_timeout:
            GObject.source_remove(self.m_timeout)
            self.m_timeout = None

        if ev.type == Gdk.EventType.BUTTON_PRESS:

            if self.m_value > 0:
                self.down()

            if self.m_value > 0:
                self.m_timeout = GObject.timeout_add(DELAY1, self.on_down_timeout)

def on_down_release(self, eb, ev):
        if self.m_timeout:
            GObject.source_remove(self.m_timeout)
            self.m_timeout = None

def askInstallPackage(self, package, summary, description, homepage):
        # populate the dialog
        dia = self.dia
        dia_xml = self.dia_xml
        header = _("Install additional software?")
        body = _("Do you want to install package '%s'?") % package
        dia.set_title('')
        header_label = dia_xml.get_object('header_label')
        header_label.set_markup("<b><big>%s</big></b>" % header)
        body_label = dia_xml.get_object('body_label')
        body_label.set_label(body)
        description_text_view = dia_xml.get_object('description_text_view')
        tbuf = Gtk.TextBuffer()
        desc = "%s\n\n%s" % (summary, Helpers.format_description(description))
        tbuf.set_text(desc)
        description_text_view.set_buffer(tbuf)
        dia.set_icon(Gtk.IconTheme.get_default().load_icon('package-x-generic', 16, False))

        # check if another package manager is already running
        # FIXME: just checking for the existance of the file is
        #        not sufficient, it need to be tested if it can
        #        be locked via apt_pkg.get_lock()
        #        - but that needs to run as root
        #        - a dbus helper might be the best answer here
        #args = (update_button_status, dia_xml.get_object("yes_button"),
        #    dia_xml.get_object("infolabel"))
        #args[0](*args[1:])
        #timer_id = GObject.timeout_add(750, *args )

        # show the dialog
        res = dia.run()
        #GObject.source_remove(timer_id)
        if res != Gtk.ResponseType.YES:
            dia.hide()
            return False

        return True

    # progress etc

def _update(self, widget, data=None):
        # 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._refresh, widget, data)

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 _set_repeat(self, delay=None, interval=None):
        if delay is not None and self.__repeat[0] is None:
            self.__tick_id = GObject.timeout_add(10, self._tick_cb)
        elif delay is None and self.__repeat[0] is not None:
            GObject.source_remove(self.__tick_id)
        self.__repeat = (delay, interval)

def Stop (self):
      gobject.source_remove (self.handle)
      self.active = False
      self.handle = None

def __update_refresh_rate(self, menuitem, minutes):
        if menuitem.get_active():
            GObject.source_remove(self.refresh_source)
            self.refresh_source = GObject.timeout_add(minutes * 60 * 1000, self.__update_price)

def stop_timeout(self):

    try:
        if self.timeout_id:
            GObject.source_remove(self.timeout_id)
            self.timeout_id = 0
    except: pass

    return True

def stop_ac_timeout(self, query, liststore):

        try:
            if self.ac_timeout_id:
                GObject.source_remove(self.ac_timeout_id)
                self.ac_timeout_id = 0
        except ValueError: pass
        except: pass

        if query and liststore: autocomplete(query, liststore)

        return True

def _set_repeat(self, delay=None, interval=None):
        if delay is not None and self.__repeat[0] is None:
            self.__tick_id = GObject.timeout_add(10, self._tick_cb)
        elif delay is None and self.__repeat[0] is not None:
            GObject.source_remove(self.__tick_id)
        self.__repeat = (delay, interval)

def pointer_position_watch(self, widget, event):
        if self.gui_window_fullscreen == False:
            return

        if self.fullscreen_hide_pointer_id != None:
            GObject.source_remove(self.fullscreen_hide_pointer_id)

        self.fullscreen_show_pointer()
        self.fullscreen_hide_pointer_id = GObject.timeout_add(3000, self.fullscreen_hide_pointer)

        if event.y < 20:
            self.gui_toolbar.show()
        else:
            self.gui_toolbar.hide()