예제 #1
0
 def start_game(self, *args):
     try:
         gobject.source_remove(self.timer)
     except:
         pass
     self.start_time = time.time()
     self.timer = gobject.timeout_add(1000, self.increment_time)
예제 #2
0
	def cancel_clicked(self,widget,temp=False):
		
		newtree=devede_other.create_tree(self,"wcancel_job_dialog",self.gladefile,False)
		window=newtree.get_object("wcancel_job_dialog")
		window.show()
		value=window.run()
		window.hide()
		window.destroy()
		if value!=-5: # no
			return True

		self.runner.cancel()
		self.runner.wait_end()
		gobject.source_remove(self.timer)
		self.window.hide()
		self.window.destroy()
		newtree=devede_other.create_tree(self,"waborted_dialog",self.gladefile,False)
		window=newtree.get_object("waborted_dialog")
		window.show()
		window.run()
		window.hide()
		window.destroy()
		window=None
		gc.collect()
		(self.main_window_callback)() # show the main window
		return True
예제 #3
0
 def deschedule(self):
    if not self.id:
       return
    gobject.source_remove(self.id)
    self.id = 0
    self.active = False
    self.scheduled.remove(self)
예제 #4
0
	def stop(self, data=None):
		if self.id_source: 
			gobject.source_remove(self.id_source)
		self.id_source = None
		if self.scroll_source:
			gobject.source_remove(self.scroll_source)
		self.scroll_source = None
예제 #5
0
 def __do_save(self, status):
     if self.__save_text_id > 0:
         gobject.source_remove(self.__save_text_id)
     if not self.__modified:
         self.__show_msg(_("Already saved"))
         return            
     self.__idle_save_text(status)
예제 #6
0
    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)
예제 #7
0
 def stop_refresh_file_list(self):
     if self.subprocess != None and self.subprocess.poll() == None:
         # close the pipe, kill the child
         self.subprocess.stdout.close()
     if self.idle_id != None:
         gobject.source_remove(self.idle_id)
     self.subprocess = None
예제 #8
0
    def _next_round_robin_buddy(self, recd):
        logger.debug('meshNextRoundRobinBuddy')
        if recd.meshReqCallbackId:
            gobject.source_remove(recd.meshReqCallbackId)
            recd.meshReqCallbackId = 0

        # delete any stub of a partially downloaded file
        path = recd.getMediaFilepath()
        if path and os.path.exists(path):
            os.remove(path)

        good_buddy_obj = None
        buds = self.activity._shared_activity.get_joined_buddies()
        for buddy_obj in buds:
            buddy = util.sha_data(buddy_obj.props.key)
            buddy = util.printable_hash(buddy)
            if recd.triedMeshBuddies.count(buddy) > 0:
                logger.debug('mnrrb: weve already tried bud ' + buddy_obj.props.nick)
            else:
                logger.debug('mnrrb: ask next buddy: ' + buddy_obj.props.nick)
                good_buddy_obj = buddy_obj
                break

        if good_buddy_obj:
            buddy = util.sha_data(good_buddy_obj.props.key)
            buddy = util.printable_hash(buddy)
            self._req_recd_from_buddy(recd, buddy, good_buddy_obj.props.nick)
        else:
            logger.debug('weve tried all buddies here, and no one has this recd')
            recd.meshDownloading = False
            recd.triedMeshBuddies = []
            recd.triedMeshBuddies.append(Instance.keyHashPrintable)
            self.activity.update_download_progress(recd)
예제 #9
0
    def _check_recd_request(self, recd):
        #todo: add category for "not active activity, so go ahead and delete"

        if recd.downloadedFromBuddy:
            logger.debug('_meshCheckOnRecdRequest: recdRequesting.downloadedFromBuddy')
            if recd.meshReqCallbackId:
                gobject.source_remove(recd.meshReqCallbackId)
                recd.meshReqCallbackId = 0
            return False
        if recd.deleted:
            logger.debug('_meshCheckOnRecdRequest: recdRequesting.deleted')
            if recd.meshReqCallbackId:
                gobject.source_remove(recd.meshReqCallbackId)
                recd.meshReqCallbackId = 0
            return False
        if recd.meshDownloadingProgress:
            logger.debug('_meshCheckOnRecdRequest: recdRequesting.meshDownloadingProgress')
            #we've received some bits since last we checked, so keep waiting...  they'll all get here eventually!
            recd.meshDownloadingProgress = False
            return True
        else:
            logger.debug('_meshCheckOnRecdRequest: ! recdRequesting.meshDownloadingProgress')
            #that buddy we asked info from isn't responding; next buddy!
            #self.meshNextRoundRobinBuddy( recdRequesting )
            gobject.idle_add(self._next_round_robin_buddy, recd)
            return False
예제 #10
0
 def _disconnect(self):
     if self._iowatchevent >= 0:
         gobject.source_remove(self._iowatchevent)
         self._iowatchevent = -1
     if self._sock:
         self._sock.close()
         self._sock = None
예제 #11
0
    def establish_connection(self, force=False):
        if self._sock:
            if force:
                self._disconnect()
            else:
                return True

        # attempt connection, we know we are disconnected at this point
        if self._connect():
            # allow the frontend to see that we may have stale data
            self.status['epoch'] = self.status['epoch'] + 1
            # stop our timer connect event if it exists
            if self._connectevent >= 0:
                gobject.source_remove(self._connectevent)
                self._connectevent = -1
            # set up our select-like watcher on our input
            eventid = gobject.io_add_watch(self._sock,
                    gobject.IO_IN | gobject.IO_PRI | gobject.IO_ERR |
                    gobject.IO_HUP, self._processinput)
            self._iowatchevent = eventid
            # we've verified the connection, get powered on status
            self.querypower()
            return True
        else:
            # connection failed, set up our timer connect event if it doesn't
            # already exist
            if self._connectevent < 0:
                # attempt again in 2 seconds
                eventid = gobject.timeout_add(2000, self.establish_connection)
                self._connectevent = eventid
            return True
예제 #12
0
 def filter_changed(self, filter_bar):
     # Restart the timer to start the filter.
     if self.filter_timeout_id:
         gobject.source_remove(self.filter_timeout_id)
     self.filter_timeout_id = gobject.timeout_add(
             self.FILTER_DELAY, self.filter_hosts,
             filter_bar.get_filter_string())
예제 #13
0
  def end(self):
    # Remove all the timer first
    if self.waterlevel_timer :
      gobject.source_remove(self.waterlevel_timer)

    # Remove the root item removes all the others inside it
    self.rootitem.remove()
예제 #14
0
	def mouse_up(self, event):
		if event.button == LEFT_BUTTON:
			gobject.source_remove(self.timer)
			self.end = [event.x, event.y]
			self.move = False
			if not self.canvas.resize_marker == 9:
				self.canvas.renderer.hide_move_frame()
				if self.moved:
					self.trafo = self._calc_trafo(event)
					self.api.transform_selected(self.trafo, self.copy)
				self.moved = False
				self.copy = False
				self.start = []
				self.end = []
				point = self.canvas.win_to_doc([event.x, event.y])
				if not self.selection.is_point_over_marker(point):
					self.canvas.restore_mode()
			else:
				self._draw_center()
				self.moved = False
				self.copy = False
				self.start = []
				self.end = []

		if event.button == RIGHT_BUTTON and self.moved:
			self.copy = True
			self.set_cursor()
예제 #15
0
파일: login.py 프로젝트: Kjir/amsn2
    def __show_boxes(self, login):
        for box in self.get_children():
            self.remove(box)
        self.login = login
        if login:
            self.pack_start(self.fixed_boxes[0])
            self.pack_start(self.connecting_boxes[0])
            self.pack_start(self.connecting_boxes[1])
            self.pack_start(self.fixed_boxes[1])

            for box in self.connecting_boxes:
                box.show()
            self.pgbar.show()

            self.login_button.set_label(gtk.STOCK_DISCONNECT)
            self.timer = gobject.timeout_add(40, self.__animation)

        else:
            self.pack_start(self.input_boxes[0])
            self.pack_start(self.fixed_boxes[0])
            self.pack_start(self.input_boxes[1])
            self.pack_start(self.input_boxes[2])
            self.pack_start(self.fixed_boxes[1])

            # TODO: set the account's dp
            _, filename = self._theme_manager.get_dp("dp_amsn")
            self.dp.set_from_file(filename)

            self.login_button.set_label(gtk.STOCK_CONNECT)
            if self.timer is not None:
                gobject.source_remove(self.timer)
예제 #16
0
	def __remove_timer(self):
		try:
			from gobject import source_remove
			source_remove(self.__timer)
		except AttributeError:
			pass
		return False
예제 #17
0
	def mouse_up(self, event):
		if self.move and event.button == LEFT_BUTTON:
			gobject.source_remove(self.timer)
			new = [event.x, event.y]
			if event.state & gtk.gdk.CONTROL_MASK:
				change = [new[0] - self.start[0], new[1] - self.start[1]]
				if abs(change[0]) > abs(change[1]):
					new[1] = self.start[1]
				else:
					new[0] = self.start[0]
			self.end = new
			self.canvas.renderer.hide_move_frame()
			self.move = False
			if self.moved:
				self.trafo = self._calc_trafo(self.start, self.end)
				bbox = self.presenter.selection.bbox
				self.trafo = self._snap(bbox, self.trafo)
				self.api.transform_selected(self.trafo, self.copy)
			elif event.state & gtk.gdk.SHIFT_MASK:
				self.canvas.select_at_point(self.start, True)
				if not self.selection.is_point_over(self.start):
					self.canvas.restore_mode()
			if self.copy:
				self.canvas.restore_cursor()
			self.moved = False
			self.copy = False
			self.start = []
			self.end = []

		elif self.moved and event.button == RIGHT_BUTTON:
			self.copy = True
			cursor = self.app.cursors[modes.COPY_MODE]
			self.canvas.set_temp_cursor(cursor)
예제 #18
0
	def disconnect_handlers (self):
		self.disconnect(self.sc_id)
		self.disconnect(self.sa_id)
		self.icon_theme.disconnect(self.tc_id)
		for id in self.resize_id, self.fade_id, self.anim_id:
			if id != 0:
				gobject.source_remove (id)
예제 #19
0
파일: hatariui.py 프로젝트: r-type/hatari
 def run(self, widget = None):
     if not self.killdialog.run(self.hatari):
         return
     if self.io_id:
         gobject.source_remove(self.io_id)
     args = ["--configfile"]
     # whether to use Hatari config or unsaved Hatari UI config?
     if self.config.is_changed():
         args += [self.config.save_tmp(self.tmpconfpath)]
     else:
         args += [self.config.get_path()]
     if self.memstate:
         args += self.memstate
     # only way to change boot order is to specify disk on command line
     if self.floppy:
         args += self.floppy
     if self.hatariwin:
         size = self.hatariwin.window.get_size()
         self.hatari.run(args, self.hatariwin.window)
         # get notifications of Hatari window size changes
         self.hatari.enable_embed_info()
         socket = self.hatari.get_control_socket().fileno()
         events = gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR
         self.io_id = gobject.io_add_watch(socket, events, self._socket_cb)
         # all keyboard events should go to Hatari window
         self.hatariwin.grab_focus()
     else:
         self.hatari.run(args)
예제 #20
0
파일: higspinner.py 프로젝트: mogigoma/nmap
    def pause(self):
        """Pauses the animation"""
        if self.timer_task != 0:
            gobject.source_remove(self.timer_task)

        self.timer_task = 0
        self.queue_draw()
예제 #21
0
 def _set_repeat(self, delay=None, interval=None):
     """Set the key-repetition frequency for held-down keys"""
     if delay is not None and self.__repeat[0] is None:
         self.__tick_id = gobject.timeout_add(10, self._tick)
     elif delay is None and self.__repeat[0] is not None:
         gobject.source_remove(self.__tick_id)
     self.__repeat = (delay, interval)
예제 #22
0
 def serve_stop(self):
     self.closeall_connections()
     
     if self.io_watch_tag:
         gobject.source_remove(self.io_watch_tag)
     
     self.close_connection(self.session)
예제 #23
0
    def handle_disconnection(self, serversocket, condition):
        """
        Handles the shutdown of connections. When the serversocket signals the
        HUP condition.  The handler disconnects from the mainloop by returning
        false.

        This method is called when the connection was shutdown from the
        otherside of the connection. The data handler (L{handle_incoming_data})
        for incoming data is disconnected and the disconnect signal is fired. 
        
        If we are in connectable or filtered mode, we will reattach the
        serversocket watch for gtk.IO_IN with L{handle_connection}) as handler.

        @type   self:           BTServer
        @param  self:           The BTServer object responsible for handling the connection
        @type   serversocket:   bluetooth.BluetoothSocket
        @param  serversocket:   A bluetooth socket responsible for handling incoming connections (server side)
        @type   condition:      integer (gobject.Enum)
        @param  condition:      The condition of the serversocket which caused the handler to be called
                                should always be gobject.IO_HUP (=16)
        @rtype:         bool
        @return:        always False, as we only allow one concurrent connection
        """
        gobject.source_remove(self.client_io_watch)
        self.server_io_watch = None
        self.client_io_watch = None
        self.client_sock = None
        self.emit("disconnect", self.connected[0], self.connected[1])
        self.connected = None
        if self.connectable == 'yes' or self.connectable == 'filtered':
            self.server_io_watch = gobject.io_add_watch(self.server_sock, gobject.IO_IN, self.handle_connection)
            bluetooth.advertise_service(self.server_sock, self.name, self.serverid)
        return False
예제 #24
0
 def setStopCheck(self, active):
   "Set/unset timeout check for running processes"
   if active:
     self.timeoutCheck = gobject.timeout_add(500, self.checkIfPlaying)
   else:
     gobject.source_remove(self.timeoutCheck)
     self.timeoutCheck = None
예제 #25
0
파일: progress.py 프로젝트: Vegasq/gpodder
    def _create_progress(self):
        self.dialog = gtk.MessageDialog(self.parent, \
                0, 0, gtk.BUTTONS_CANCEL, self.subtitle or self.title)
        self.dialog.set_modal(True)
        self.dialog.connect('delete-event', self._on_delete_event)
        self.dialog.set_title(self.title)
        self.dialog.set_deletable(self.cancellable)

        # Avoid selectable text (requires PyGTK >= 2.22)
        if hasattr(self.dialog, 'get_message_area'):
            for label in self.dialog.get_message_area():
                if isinstance(label, gtk.Label):
                    label.set_selectable(False)

        self.dialog.set_response_sensitive(gtk.RESPONSE_CANCEL, \
                self.cancellable)

        self.progressbar = gtk.ProgressBar()
        self.progressbar.set_ellipsize(pango.ELLIPSIZE_END)

        # If the window is shown after the first update, set the progress
        # info so that when the window appears, data is there already
        if self._initial_progress is not None:
            self.progressbar.set_fraction(self._initial_progress)
        if self._initial_message is not None:
            self.progressbar.set_text(self._initial_message)

        self.dialog.vbox.add(self.progressbar)
        self.indicator = SpinningProgressIndicator()
        self.dialog.set_image(self.indicator)
        self.dialog.show_all()

        gobject.source_remove(self.source_id)
        self.source_id = gobject.timeout_add(self.INTERVAL, self._update_gui)
        return False
예제 #26
0
파일: buto.j0hn.py 프로젝트: j0hn/buto
    def moveEnemies(self):
        for row in self.grid[::-1]:
            for label in row[::-1]:
                if label.enemie:
                    if label.posX == self.posX and label.posY == self.posY:
                        self.restart()
                        return  # game over
                    if label.posX == 9:
                        destX = 0
                        destY = label.posY + 1

                        gobject.source_remove(self.moveEnemieTimeout)
                        if self.enemiesSpeed > 50:
                            self.enemiesSpeed -= 5
                        self.moveEnemieTimeout = gobject.timeout_add(self.enemiesSpeed, self.moveEnemies)

                    else:
                        destX = label.posX + 1
                        destY = label.posY

                    label.enemie = False
                    label.set_label(BLANK)

                    nextLabel = self.grid[destY][destX]
                    nextLabel.set_label(ENEMIE)
                    nextLabel.enemie = True

        return True
예제 #27
0
 def __handle_image_load(self, url, surface):
     if url != self.__current_url:
         return
     
     self._logger.debug("loaded url=%s", url)
     self.emit("loaded", True)
     
     req_changed = False
     if self.__surface:
         old_width = self.__surface.get_width()
         old_height = self.__surface.get_height()
         if old_width != surface.get_width() or old_height != surface.get_height():
             req_changed = True
     else:
         req_changed = True
     
     self.__transition_count = 0
     if self.__transition_idle_id > 0:
         gobject.source_remove(self.__transition_idle_id)
     self.__transition_idle_id = gobject.timeout_add(100, self.__idle_step_transition)
     self.__prev_surface = self.__surface
     self.__surface = surface            
         
     if req_changed:
         self.emit_request_changed()
     
     self.emit_paint_needed(0, 0, -1, -1)
    def update(self, action=None):
        self.set_label(self.last_left, text_color='green')
        time.sleep(3)
	timeout = self.timeout
        try:
            stats=self.get_stats()
            self.last_left=int(stats['traffic_left'])
        except Exception:
            print "Update problem ... Last Left: %s" % self.last_left            
            self.set_label(self.last_left, text_color='red')
            self.traffic_left_label.set_label("Traffic Left: N/A")
            self.money_left_label.set_label("Money:  N/A")
            self.ip_label.set_label("IP: N/A")
	    timeout = 10*60*1000 #10 minutes
        else:
            print "Updating... Left: %s" % self.last_left
            self.set_label(self.last_left)
            self.traffic_left_label.set_label("Traffic Left: %s Mb" % self.last_left)
            self.money_left_label.set_label("Money: %s" % stats['money_left'])
            self.ip_label.set_label("IP: %s" % stats['ip'])
        try:
            gobject.source_remove(self.source_id)
        except Exception:
            pass
        self.source_id = gobject.timeout_add(timeout, self.update)
예제 #29
0
 def process_buffering_stats(self, message):
     if not self.started_buffering:
         self.started_buffering = True
         if self.fill_timeout_id:
             gobject.source_remove(self.fill_timeout_id)
         self.fill_timeout_id = gobject.timeout_add(200,
                                                    self.buffering_timeout)
예제 #30
0
파일: emesene.py 프로젝트: bah/emesene
    def close_session(self, do_exit=True):
        '''close session'''

        if self.timeout_id:
            gobject.source_remove(self.timeout_id)
            self.timeout_id = None

        if self.session is not None:
            self.session.quit()

        self.save_extensions_config()
        self._save_login_dimensions()

        if self.session is not None:
            self.session.save_config()
            self.session = None

        self.config.save(self.config_path)

        if self.conversations:
            self.conversations.get_parent().hide()
            self.conversations = None

        if do_exit:
            if self.tray_icon is not None:
                self.tray_icon.set_visible(False)
            self.window.hide()
            self.window = None

            while gtk.events_pending():
                gtk.main_iteration(False)

            sys.exit(0)
예제 #31
0
파일: Timer.py 프로젝트: cemeiq/Bichos
 def new_handle(self, reset):
     if self.actualizador:
         gobject.source_remove(self.actualizador)
         self.actualizador = False
     if reset:
         self.actualizador = gobject.timeout_add(1000, self.__handle)
예제 #32
0
 def _timer_stop(self):
     if self._timer is not None:
         gobject.source_remove(self._timer)
         self._timer = None
예제 #33
0
 def destroy(self):
     #gtk.DrawingArea.destroy(self)
     self.close_event()
     if self._idle_draw_id != 0:
         gobject.source_remove(self._idle_draw_id)
예제 #34
0
파일: asyncjobs.py 프로젝트: zenny/pysheng
 def cancel(self):
     self.cancel_event.set()
     gobject.source_remove(self._thread_id)
예제 #35
0
파일: asyncjobs.py 프로젝트: zenny/pysheng
 def pause(self):
     gobject.source_remove(self.source_id)
     self.elapsed_time += time.time() - self.start_time
예제 #36
0
파일: asyncjobs.py 프로젝트: zenny/pysheng
 def cancel(self):
     gobject.source_remove(self.source_id)
예제 #37
0
 def interrupt(self):
     """Force the generator to stop running.
     """
     if self.is_alive():
         gobject.source_remove(self._idle_id)
         self._idle_id = 0
예제 #38
0
 def delete_event(self, widget, event, data=None):
     pygame.mixer.music.stop()
     pygame.quit()
     gobject.source_remove(self.source_id)
     gtk.main_quit()
     return False
예제 #39
0
    def _on_search_text_changed(self, entry):
        if self._search_timeout:
            gobject.source_remove(self._search_timeout)

        self._search_timeout = gobject.timeout_add(self.SEARCH_DELAY,
                                                   self.update_search)
    def load_clicked(self, widget, data=None):
        if self.cbfilter.get_model()[self.cbfilter.get_active()][0] == (_("Please select site")):
            self.progressbar.set_text(_("Please select site"))
            return
        stored = None
        dups = None
        partial = None
        errs = None
        ttime = None
        # Does the lock acquisition need to be more sophisticated for multiple dirs?
        # (see comment above about what to do if pipe already open)
        if self.settings['global_lock'].acquire(wait=False, source="GuiBulkImport"):   # returns false immediately if lock not acquired
            #try:
                print _("\nGlobal lock taken ...")
                self.progressbar.set_text(_("Importing..."))
                self.progressbar.pulse()
                while gtk.events_pending(): # see http://faq.pygtk.org/index.py?req=index for more hints (3.7)
                    gtk.main_iteration(False)
                self.timer = gobject.timeout_add(100, self.dopulse)

                #    get the dir to import from the chooser
                selected = self.chooser.get_filenames()

                #    get the import settings from the gui and save in the importer
                self.importer.setHandCount(int(self.spin_hands.get_text()))
                self.importer.setQuiet(self.chk_st_st.get_active())
                self.importer.setThreads(int(self.spin_threads.get_text()))
                self.importer.setHandsInDB(self.n_hands_in_db)
                cb_model = self.cb_dropindexes.get_model()
                cb_index = self.cb_dropindexes.get_active()
                cb_hmodel = self.cb_drophudcache.get_model()
                cb_hindex = self.cb_drophudcache.get_active()

                #self.lab_info.set_markup('<span foreground="blue">Importing ...</span>') # uses pango markup!

                if cb_index:
                    self.importer.setDropIndexes(cb_model[cb_index][0])
                else:
                    self.importer.setDropIndexes("auto")
                if cb_hindex:
                    self.importer.setDropHudCache(cb_hmodel[cb_hindex][0])
                else:
                    self.importer.setDropHudCache("auto")
                sitename = self.cbfilter.get_model()[self.cbfilter.get_active()][0]
                #self.importer.setFailOnError(self.chk_fail.get_active())
                if self.is_archive.get_active():
                    if sitename == "PokerStars":
                        self.importer.setStarsArchive(True)
                    if sitename == "Full Tilt Poker":
                        self.importer.setFTPArchive(True)

                for selection in selected:
                    self.importer.addBulkImportImportFileOrDir(selection, site = sitename)
                self.importer.setCallHud(self.cb_testmode.get_active())
                self.importer.bHudTest = self.cb_testmode.get_active()
                starttime = time()
#                try:
                (stored, dups, partial, errs, ttime) = self.importer.runImport()
#                except:
#                    print "*** EXCEPTION DURING BULKIMPORT!!!"
#                    raise Exceptions.FpdbError
#                finally:
                gobject.source_remove(self.timer)

                ttime = time() - starttime
                if ttime == 0:
                    ttime = 1
                    
                completionMessage = _('Bulk import done: Stored: %d \tDuplicates: %d \tPartial: %d \tErrors: %d in %s seconds - %.0f/sec')\
                    % (stored, dups, partial, errs, ttime, (stored+0.0) / ttime)
                print completionMessage
                log.info(completionMessage)

                self.importer.clearFileList()
                
                if self.n_hands_in_db == 0 and stored > 0:
                    self.cb_dropindexes.set_sensitive(True)
                    self.cb_dropindexes.set_active(0)
                    self.lab_drop.set_sensitive(True)
                    self.cb_drophudcache.set_sensitive(True)
                    self.cb_drophudcache.set_active(0)
                    self.lab_hdrop.set_sensitive(True)

                self.progressbar.set_text(_("Import Complete"))
                self.progressbar.set_fraction(0)
            #except:
                #err = traceback.extract_tb(sys.exc_info()[2])[-1]
                #print "*** BulkImport Error: "+err[2]+"("+str(err[1])+"): "+str(sys.exc_info()[1])
            #self.settings['global_lock'].release()
                self.settings['global_lock'].release()
        else:
            print _("bulk import aborted - global lock not available")
예제 #41
0
 def disable(self):
     # Clear old tags
     self.buffer.remove_tag(self.search_tag, self.buffer.get_start_iter(),
                            self.buffer.get_end_iter())
     if self.changed_source is not None:
         gobject.source_remove(self.changed_source)
예제 #42
0
 def _watch_remove(self):
     if self._source_id is not None:
         gobject.source_remove(self._source_id)
         self._source_id = None
         self._source_condition = 0
예제 #43
0
    def __on_tap_hold(self, px, py):

        if (self.__zoom_handler):
            gobject.source_remove(self.__zoom_handler)
        self.__zoom_handler = gobject.timeout_add(50, self.__on_zoom_gesture,
                                                  -1)
예제 #44
0
파일: pyglfm.py 프로젝트: pglen/pgpygtk
 def __timeout_remove(self):
     if self.__timeout_id != 0:
         gobject.source_remove(self.__timeout_id)
         self.__timeout_id = 0
예제 #45
0
 def enable(self):
     if self.timer is None:
         raise AssertionError("disable() must be called before enable()")
     gobject.source_remove(self.timer)
     self.timer = None
예제 #46
0
 def on_finished(self):
     if self.dialog is not None:
         self.dialog.destroy()
     gobject.source_remove(self.source_id)
예제 #47
0
 def cleanup_callback(self, win):
     if self.timeout_id is not None:
         gobject.source_remove(self.timeout_id)
         self.timeout_id = None
예제 #48
0
    def __on_release(self, px, py, kscr):

        kscr.set_enabled(True)

        if (self.__zoom_handler):
            gobject.source_remove(self.__zoom_handler)
예제 #49
0
 def play_sim(self):
     gobject.source_remove(
         self.sim_event_source
     )  # this ensures multiple calls to play_sim do not speed up the simulator
     self._run_sim()
     self.viewer.control_panel_state_playing()
예제 #50
0
 def cancel_pulse(self):
     """ Stop pulsing the progress bar, if it is pulsing.
     """
     if self.pulse_timer:
         gobject.source_remove(self.pulse_timer)
         self.pulse_timer = 0
예제 #51
0
  def click_animation_stop(self):
    """ Stops the mouse click animation """
    assert(self.__is_click_animation_playing())

    gobject.source_remove(self.timer_click)
    self.timer_click = None
예제 #52
0
 def pause_sim(self):
     gobject.source_remove(self.sim_event_source)
     self.viewer.control_panel_state_paused()
예제 #53
0
 def dormir(self):
     """para de contar minutos"""
     self.ind.set_icon("face-tired")
     gobject.source_remove(self.timeout_id)
     self.ind.set_label('')
     self.ind.set_status(appindicator.STATUS_ACTIVE)
예제 #54
0
 def end_sim(self, alert_text=''):
     gobject.source_remove(self.sim_event_source)
     self.viewer.control_panel_state_finished(alert_text)
예제 #55
0
 def time_stop(self, play):
     """Stop play pressed"""
     if self.playTimer:
         gobject.source_remove(self.playTimer)
         self.playTimer = None
예제 #56
0
  def scroll_animation_stop(self):
    """ Stops the mouse wheel scroll animation """
    assert(self.__is_scroll_animation_playing())

    gobject.source_remove(self.timer_scroll)
    self.timer_scroll = None
예제 #57
0
 def restart_timer(self):
     print "timer reset"
     gobject.source_remove(self.timer_source_id)
     self.timer_source_id = gobject.timeout_add(self.RATE_OF_CALLBACK,
                                                self.timeout_callback)
예제 #58
0
 def _abortScheduledCheck(self):
     if self._idleId != -1:
         gobject.source_remove(self._idleId)
         self._idleId = -1
예제 #59
0
def after_cancel(t):
    if t is not None:
        gobject.source_remove(t)
예제 #60
0
 def fade_start(self):
     """start fading timer"""
     self.fade_level = 1.0
     if self.idle:
         gobject.source_remove(self.idle)
     self.idle = gobject.timeout_add(25, self.fade_out)