示例#1
0
    def plot(self, keys, data, stack_keys=None):
        """Draw chart with given data"""
        self.keys, self.data, self.stack_keys = keys, data, stack_keys

        self.show()

        if not data:  # if there is no data, let's just draw blank
            self.redraw_canvas()
            return

        min, self.max_value = get_limits(data)

        if not self.current_max:
            self.current_max = graphics.Integrator(0)
        self.current_max.target(self.max_value)

        self._update_targets()

        if self.animate:
            if not self.moving:  # if we are moving, then there is a timeout somewhere already
                gobject.timeout_add(1000 / self.framerate, self._interpolate)
        else:

            def finish_all(integrators):
                for i in range(len(integrators)):
                    if type(integrators[i]) == list:
                        finish_all(integrators[i])
                    else:
                        integrators[i].finish()

            finish_all(self.integrators)
            self.current_max.finish()

            self.redraw_canvas()
示例#2
0
    def __create_widgets(self):
        """
        """
        self.__vbox = BWVBox()

        self.__cartesian_radio = gtk.RadioButton(None, _("Cartesian"))
        self.__polar_radio = gtk.RadioButton(self.__cartesian_radio, _("Polar"))
        self.__cartesian_radio.connect("toggled", self.__change_system, INTERPOLATION_CARTESIAN)
        self.__polar_radio.connect("toggled", self.__change_system, INTERPOLATION_POLAR)

        self.__system_box = BWHBox()
        self.__system_box.bw_pack_start_noexpand_nofill(self.__polar_radio)
        self.__system_box.bw_pack_start_noexpand_nofill(self.__cartesian_radio)

        self.__frames_box = BWHBox()
        self.__frames_label = gtk.Label(_("Frames"))
        self.__frames_label.set_alignment(0.0, 0.5)
        self.__frames = gtk.Adjustment(self.radialnet.get_number_of_frames(), 1, 1000, 1)
        self.__frames.connect("value_changed", self.__change_frames)
        self.__frames_spin = gtk.SpinButton(self.__frames)
        self.__frames_box.bw_pack_start_expand_fill(self.__frames_label)
        self.__frames_box.bw_pack_start_noexpand_nofill(self.__frames_spin)

        self.__vbox.bw_pack_start_noexpand_nofill(self.__frames_box)
        self.__vbox.bw_pack_start_noexpand_nofill(self.__system_box)

        self.bw_add(self.__vbox)

        gobject.timeout_add(REFRESH_RATE, self.__update_animation)
示例#3
0
    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(5000, 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()
示例#4
0
文件: UI.py 项目: nzjrs/conduit
    def show(self):
        """
        Builds the splashscreen and connects the splash window to be destroyed 
        via a timeout callback in L{SplashScreen.DELAY}msec time.

        The splash can also be destroyed manually by the application
        """
        self.wSplash = gtk.Window(gtk.WINDOW_POPUP)
        self.wSplash.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_SPLASHSCREEN)
        self.wSplash.set_decorated(False)

        wSplashScreen = gtk.Image()
        wSplashScreen.set_from_file(os.path.join(conduit.SHARED_DATA_DIR,"conduit-splash.png"))

        # Make a pretty frame
        wSplashFrame = gtk.Frame()
        wSplashFrame.set_shadow_type(gtk.SHADOW_OUT)
        wSplashFrame.add(wSplashScreen)
        self.wSplash.add(wSplashFrame)

        # OK throw up the splashscreen
        self.wSplash.set_position(gtk.WIN_POS_CENTER)
        
        #The splash screen is destroyed automatically (via timeout)
        #or when the application is finished loading
        self.destroyed = False

        self.wSplash.show_all()
        # ensure it is rendered immediately
        while gtk.events_pending():
            gtk.main_iteration() 
        # The idle timeout handler to destroy the splashscreen
        gobject.timeout_add(SplashScreen.DELAY,self.destroy)
示例#5
0
	def SystemStateHandler(self,state_name):
		## clearing object started flags
		current_state = self.Get(DBUS_NAME,"current_state")
		try:
			for obj_path in System.EXIT_STATE_DEPEND[current_state]:
				System.EXIT_STATE_DEPEND[current_state][obj_path] = 0
		except:
			pass

		print "Running System State: "+state_name
		if (self.system_states.has_key(state_name)):
			for name in self.system_states[state_name]:
				self.start_process(name)
		
		if (state_name == "BMC_INIT"):
			## Add poll for heartbeat
	    		gobject.timeout_add(HEARTBEAT_CHECK_INTERVAL, self.heartbeat_check)
		
		try:	
			cb = System.ENTER_STATE_CALLBACK[state_name]
			for methd in cb.keys():
				obj = bus.get_object(cb[methd]['bus_name'],cb[methd]['obj_name'])
				method = obj.get_dbus_method(methd,cb[methd]['interface_name'])
				method()
		except:
			pass

		self.Set(DBUS_NAME,"current_state",state_name)
示例#6
0
文件: scanrun.py 项目: HamzaKo/w3af
    def __init__(self, w3af):
        super(URLsGraph, self).__init__()
        self.w3af = w3af

        self.toolbox = gtk.HBox()
        b = entries.SemiStockButton("", gtk.STOCK_ZOOM_IN, 'Zoom In')
        b.connect("clicked", self._zoom, "in")
        self.toolbox.pack_start(b, False, False)
        b = entries.SemiStockButton("", gtk.STOCK_ZOOM_OUT, 'Zoom Out')
        b.connect("clicked", self._zoom, "out")
        self.toolbox.pack_start(b, False, False)
        b = entries.SemiStockButton("", gtk.STOCK_ZOOM_FIT, 'Zoom Fit')
        b.connect("clicked", self._zoom, "fit")
        self.toolbox.pack_start(b, False, False)
        b = entries.SemiStockButton("", gtk.STOCK_ZOOM_100, 'Zoom 100%')
        b.connect("clicked", self._zoom, "100")
        self.toolbox.pack_start(b, False, False)
        self.pack_start(self.toolbox, False, False)
        self.toolbox.set_sensitive(False)

        # no graph yet
        self.widget = gtk.Label(_("No info yet"))
        self.widget.set_sensitive(False)

        self.nodos_code = []
        self._somethingnew = False
        self.pack_start(self.widget)
        self.show_all()

        gobject.timeout_add(500, self._draw_start)
示例#7
0
 def save_file(self, widget):
     if self.editor.modificado():
         self.save_button.set_sensitive(False)
         self.editor.save_file()
         filename = self.editor.current_file()
         self.alert(filename, "Archivo guardado.")
         gobject.timeout_add(1500, self.check_modified)
示例#8
0
 def play(self):
     self.player.set_state(gst.STATE_PLAYING)
     self.is_playing = True
     self.play_button.set_stock_id(gtk.STOCK_MEDIA_PAUSE)
     #Make sure position is updated regularly
     gobject.timeout_add(500, self._update_position)
     self.debug("Preview started")
示例#9
0
    def __init__(self, timer):
        """
            Initiate the interface
        """
        self.timer = timer
        self.current_status = 0
        self.break_count = 0

        self.status_icon = gtk.StatusIcon()
        self.status_icon.set_from_file(WORK_ICON)
        self.menu = gtk.Menu()
        self.quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
        self._create_menu()
        self.status_icon.set_visible(True)

        self.dialog = gtk.MessageDialog(
            parent=None,
            flags=gtk.DIALOG_MODAL,
            type=gtk.MESSAGE_WARNING,
            buttons=gtk.BUTTONS_CLOSE)

        self.image = gtk.Image()
        self.image.set_from_file(REST_ICON)
        self.dialog.set_title('Pomodoro4linux')
        self.dialog.set_image(self.image)
        self.dialog.set_keep_above(True)
        self.start_timer()

        timeout_add(1000, self.update_timer)
def burn(button, filename):
    global GBLprocess
    global GBLline
    global GBLoutput
    global GBLtimeStartedBurn
    
    print 'burning ' + filename
    
    showProgressWindow()
    
    # close the 'ready to burn' window
    parentWindow = button.get_parent_window()
    parentWindow.destroy()
    
    #command = globals.BURNINGPROGRAM, 'dev=' + globals.DEVICE, "gracetime=0", "blank=fast"
    command = globals.BURNINGPROGRAM, 'dev=' + globals.DEVICE, 'gracetime=0', '-tao', '-v', '-eject', filename
    
    GBLprocess = subprocess.Popen(command, 0, "wodim", subprocess.PIPE, 
                               subprocess.PIPE, subprocess.STDOUT)
    
    flags = fcntl.fcntl(GBLprocess.stdout, fcntl.F_GETFL)
    fcntl.fcntl(GBLprocess.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
    
    GBLline = ''
    GBLoutput = []
    GBLtimeStartedBurn = datetime.datetime.now()
    
    # have gtk call updateProgress every second
    gobject.timeout_add(1000, updateProgress)
示例#11
0
	def click_button(self, widget, data=None):
		if self.username.get_text_length() != 0 and self.password.get_text_length() != 0:
			self.params['username']=self.username.get_text()
			self.params['password']=self.password.get_text()
			
			if self.status=="login":
				self.doLogout()
				
			elif self.status=="logout":
				self.doLogin()
				gobject.timeout_add(150000,self.keepalive)
				
			elif self.status=="new":
				self.chkLogin()
				self.button.set_label('Logout')
				gobject.timeout_add(150000,self.keepalive)
						
		#	if self.chkLogin():
		#		print self.responsedata
		#	else:
		#		msgpop=gtk.MessageDialog(parent=None, flags=gtk.DIALOG_DESTROY_WITH_PARENT, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_CLOSE, message_format="Some error occured")
		#		msgpop.run()
		#		msgpop.destroy()
			
		else:
			msgpop=gtk.MessageDialog(parent=None, flags=gtk.DIALOG_DESTROY_WITH_PARENT, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_CLOSE, message_format="Need password and username fields")
			msgpop.run()
			msgpop.destroy()
示例#12
0
 def display_warning(self, text, callback=None):
     """Displays a warning to the user in the status bar"""
     if text not in self.current_warnings:
         item = self.add_item(
             stock=gtk.STOCK_DIALOG_WARNING, text=text, callback=callback)
         self.current_warnings.append(text)
         gobject.timeout_add(3000, self.remove_warning, item)
示例#13
0
 def btncancel_clicked_cb(self, widget):
     """Callback used when cancelling the indexing process"""
     self._dbmanager.stop = True
     self._pbar.set_text("Indexing process of " + self._path + 
                         " cancelled.")
     gobject.timeout_add(1000, self.hide_progressbar)
     gobject.timeout_add(2000, self._mainhandler.remove_scan, self)
示例#14
0
 def print_output(self):
     """Populates the directory tree treestore.
     
     This method is called after the indexing process finishes.
     First it populates the left treestore with all the dirs from the
     indexing process. Then does the needed thingies in the GUI to
     keep it consistent.
     """
     
     self._is_scanning = False
     was_scanned = self._dbmanager.create_metadir()
     self._dbmanager.set_root_node()
     rootselect = Directory.select(Directory.q.relpath == "/",
                                   connection = self._conn)
     root = rootselect[0]
     self._root = root
     self._mainhandler.populate_catalog_list()
     if self._root is not None:
         self._mainhandler.root = self._root
         self._rootiter = self._tsdirtree.append(None,
                                                 ['drive-harddisk',
                                                  self._root.name + 
                                                  " (" + 
                                                  self._root.strsize + 
                                                  ")",
                                                  self._root.__str__()])
         #self.append_directories(self._rootiter, self._root)
         t = threading.Thread(target=self.append_directories, args=(self._rootiter, self._root))
         t.start()
         gobject.timeout_add(2000, self.hide_progressbar)
     self._mainhandler.set_buttons_sensitivity(True)
     
     if was_scanned == 0:
         notification = pynotify.Notification("Indexing finished", "Indexing of " + root.name + " has finished successfully.")
         notification.show()
示例#15
0
 def _turn_on(self):
     devnull = open('/dev/null', 'w')
     p = subprocess.Popen(['xscreensaver', '-nosplash'],
                          stdin=subprocess.PIPE,
                          stdout=devnull, stderr=devnull)
     p.stdin.close()
     gobject.timeout_add(1000, self.refresh_on_status)
示例#16
0
 def scrub(self, context, finalTime, finalPriority, steps=10):
     self.context = context
     self.time = finalTime
     self.priority = finalPriority
     self.count = 0
     self.steps = steps
     gobject.timeout_add(self.delay, self._scrubTimeoutCb)
示例#17
0
 def _turn_off(self):
     p = subprocess.Popen(['xscreensaver-command', '-exit'],
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.STDOUT)
     p.communicate()
     gobject.timeout_add(500, self.refresh_on_status)
示例#18
0
    def checkAnswerTextMatchingGame(self, widget=None, target=None, event=None):
        '''
        check to see if the student pressed the correct answer. If so, increment
        textMatchingScore. Display appropriate face (happy or sad) for 800 ms.
        '''
        if not ready(self, timeouttime=1000):
            return
        if target.get_data('sectionNum') == self.currentTextSelection[1] and \
            self.currentTextSelection in self.textPromptsRemaining:
            self.textMatchingScore += 1
            self.sectionsAnsweredCorrectlyTextMatchingGame.append(target.get_data('sectionNum'))
            pic = ExploreActivityResourcesFilepath + 'happyFace.png'
            self.textPromptsRemaining.remove(self.currentTextSelection)
            self.timers.append(gobject.timeout_add(810, self.display_level))

        else:
            pic = ExploreActivityResourcesFilepath + 'sadFace.png'

        if hasattr(self, 'responsePic'):
            self.responsePic.remove()

        self.responsePic = goocanvas.Image(
        parent=self.rootitem,
        pixbuf=gcompris.utils.load_pixmap(pic),
        x=200,
        y=50
        )
        self.timers.append(gobject.timeout_add(800, self.clearPic))
示例#19
0
文件: scanrun.py 项目: HamzaKo/w3af
    def __init__(self, w3af, grapher):
        self.w3af = w3af
        self.grapher = grapher

        # simple empty Tree Store
        self.treestore = gtk.TreeStore(str)
        gtk.TreeView.__init__(self, self.treestore)
        self.connect('button-release-event', self.popup_menu)
        self.connect('button-press-event', self._doubleClick)

        # the TreeView column
        tvcolumn = gtk.TreeViewColumn('URLs')
        tvcolumn.set_sort_column_id(0)
        cell = gtk.CellRendererText()
        tvcolumn.pack_start(cell, True)
        tvcolumn.add_attribute(cell, "text", 0)
        self.append_column(tvcolumn)

        # this tree structure will keep the parents where to insert nodes
        self.treeholder = {}

        # get the queue and go live
        self.urls = IteratedURLList()
        gobject.timeout_add(750, self.add_url().next)
        self.show()
示例#20
0
    def checkAnswerSoundMatchingGame(self, widget=None, target=None, event=None):
        '''
        check to see if the location the student chose corresponds to the
        currently playing sound clip. increment score accordingly
        '''
        if not ready(self, timeouttime=1000): # precents kids from double clicking too quickly
            return
        if target.get_data('sectionNum') == self.currentMusicSelection[1] and \
            self.currentMusicSelection in self.soundClipsRemaining:
            self.soundMatchingScore += 1
            self.sectionsAnsweredCorrectlySoundMatchingGame.append(target.get_data('sectionNum'))
            pic = ExploreActivityResourcesFilepath + 'happyFace.png'
            self.soundClipsRemaining.remove(self.currentMusicSelection)
            self.timers.append(gobject.timeout_add(810, self.display_level))

        else:
            pic = ExploreActivityResourcesFilepath + 'sadFace.png'

        if hasattr(self, 'responsePic'):
            self.responsePic.remove()

        self.responsePic = goocanvas.Image(
        parent=self.rootitem,
        pixbuf=gcompris.utils.load_pixmap(pic),
        x=200,
        y=50
        )
        self.timers.append(gobject.timeout_add(800, self.clearPic))
示例#21
0
    def __init__(self, control):
        self.control = control

        self.menu_items = {}

        check_interval = 5 * 60 * 1000
        
        """Set-up Menu"""
        self.menu = gtk.Menu()
        self.menu.append(gtk.SeparatorMenuItem())
        self.about_item = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
        self.menu.append(self.about_item)
        self.quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
        self.menu.append(self.quit_item)

        self.quit_item.connect('activate', gtk.main_quit)

        """Set-up Status Icon"""
        self.status_icon = gtk.status_icon_new_from_file('no_new.ico')
        self.status_icon.set_visible(True)
        
        self.status_icon.connect(   'popup-menu', 
                                    self.control.on_menu_popup,
                                    self.menu)

        self.status_icon.connect('activate', self.control.go_to_inbox)

        self.control.check_mail(self.menu, self.menu_items,
                                self.status_icon)
        
        gobject.timeout_add(check_interval, self.control.check_mail,
                            self.menu, self.menu_items,
                            self.status_icon)
示例#22
0
 def on_processlist_refresh_value_change(self, button):
     value = button.get_value()
     if self.processlist_timer_running:
         return
     self.processlist_timer_running = True
     self.processlist_timer_interval = value
     gobject.timeout_add(int(value * 1000), self.on_processlist_refresh_timeout, button)
示例#23
0
def sleep_within_loop(duration):
    main_loop = gobject.MainLoop()
    gobject.timeout_add(duration * 1000, main_loop.quit)
    # NOTE: I am not sure why, but I need add this
    # dumb thing to run _process method of LibLarch
    gobject.idle_add(lambda: True)
    main_loop.run()
示例#24
0
    def start(self):
        """
          Starts the server. Call this after the handlers have been set.
        """

        import utils
        utils.makedirs(SOCKET_PATH)
        serversock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        sockfile = os.path.join(SOCKET_PATH, DISPLAY)
        try:
            serversock.bind(sockfile)
        except socket.error:
            try:
                os.remove(sockfile)
            except OSError:
                log("Couldn't remove dead socket file \"%s\"." % sockfile)
                sys.exit(1)
            try:
                serversock.bind(sockfile)
            except socket.error:
                log("Couldn't bind to socket. Aborting.")
                sys.exit(1)

        serversock.listen(3)
        serversock.setblocking(False)

        atexit.register(self.__shutdown, serversock, sockfile)

        gobject.timeout_add(100, self.__server_handler, serversock, sockfile)
示例#25
0
    def __init__(self, name, value, update, increment=1):
        """
        """
        gtk.DrawingArea.__init__(self)

        self.__variable_name = name
        self.__value = value
        self.__update = update
        self.__increment_pass = increment

        self.__radius = 6
        self.__increment_time = 100

        self.__pointer_position = 0
        self.__active_increment = False

        self.__last_value = self.__value()

        self.connect("expose_event", self.expose)
        self.connect("button_press_event", self.button_press)
        self.connect("button_release_event", self.button_release)
        self.connect("motion_notify_event", self.motion_notify)

        self.add_events(
            gtk.gdk.BUTTON_PRESS_MASK
            | gtk.gdk.BUTTON_RELEASE_MASK
            | gtk.gdk.MOTION_NOTIFY
            | gtk.gdk.POINTER_MOTION_HINT_MASK
            | gtk.gdk.POINTER_MOTION_MASK
        )

        gobject.timeout_add(REFRESH_RATE, self.verify_value)
示例#26
0
 def run(self):
     """Start Nex"""
     splash = Splash(self.appath)
     splash.show_all()
     gobject.timeout_add(1000, splash.hide)  # 5*1000 miliseconds
     gobject.idle_add(self.setup_app)
     gtk.main()
示例#27
0
    def __create_widgets(self):
        """
        """
        self.__liststore = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING)

        self.__liststore.append([None, OPTIONS[0]])
        self.__liststore.append([None, OPTIONS[1]])
        self.__liststore.append([None, OPTIONS[2]])
        self.__liststore.append([None, OPTIONS[3]])
        self.__liststore.append([None, OPTIONS[4]])
        self.__liststore.append([None, OPTIONS[5]])
        self.__liststore.append([None, OPTIONS[6]])

        self.__cell_toggle = gtk.CellRendererToggle()
        self.__cell_toggle.set_property("activatable", True)
        self.__cell_toggle.connect("toggled", self.__change_option, self.__liststore)

        self.__column_toggle = gtk.TreeViewColumn("", self.__cell_toggle)
        self.__column_toggle.add_attribute(self.__cell_toggle, "active", 0)

        self.__cell_text = gtk.CellRendererText()

        self.__column_text = gtk.TreeViewColumn(None, self.__cell_text, text=1)

        self.__treeview = gtk.TreeView(self.__liststore)
        self.__treeview.set_enable_search(True)
        self.__treeview.set_search_column(1)
        self.__treeview.set_headers_visible(False)
        self.__treeview.append_column(self.__column_toggle)
        self.__treeview.append_column(self.__column_text)

        self.add_with_viewport(self.__treeview)

        gobject.timeout_add(REFRESH_RATE, self.__update_options)
示例#28
0
    def __fill_treeviews (self):
        custom_blacklist_model = self.custom_blacklist_treeview.get_model()
        custom_blacklist_model.clear()

        custom_whitelist_model = self.custom_whitelist_treeview.get_model()
        custom_whitelist_model.clear()

        packaged_blacklist_model = self.packaged_blacklist_treeview.get_model()
        packaged_blacklist_model.clear()

        filters = self.dbus_client.list_custom_filters (self.__selected_user_id)
        for filter_id, filter_name, filter_description, filter_regex, is_black in filters:
            if is_black:
                custom_blacklist_model.append ((filter_id, "<b>%s</b>\n   %s" % (filter_name, filter_description), filter_name, filter_description, filter_regex))
            else:
                custom_whitelist_model.append ((filter_id, "<b>%s</b>\n   %s" % (filter_name, filter_description), filter_name, filter_description, filter_regex))
        
        
        for filter_id in self.dbus_client.list_pkg_filters () :
            metadata = self.dbus_client.get_pkg_filter_metadata(filter_id)
            filter_name = _("Unknown Blacklist Name") if not metadata.has_key("name") else metadata["name"]
            filter_description = "" if not metadata.has_key("provider") else metadata["provider"]
            
            packaged_blacklist_model.append ((filter_id, "<b>%s</b>\n   %s" % (filter_name, filter_description)))

        gobject.timeout_add(1, self.__update_packaged_blacklist_model)
示例#29
0
    def run(self):
        #
        #    Main text
        #
        text = ('Thank you for reporting your bugs, it helps us improve our'
                ' scanning engine. If you want to get involved with the project'
                ' please send an email to our <a href="mailto:%s">mailing list'
                ' </a>.')
        text %= '[email protected]'
        # All these lines are here to add a label instead of the easy "set_
        # markup" in order to avoid a bug where the label text appears selected
        msg_area = self.get_message_area()
        [msg_area.remove(c) for c in msg_area.get_children()]
        label = gtk.Label()
        label.set_markup(text)
        label.set_line_wrap(True)
        label.select_region(0, 0)
        msg_area.pack_start(label)

        self.worker = bug_report_worker(
            self.bug_report_function, self.bugs_to_report)
        self.worker.start()
        gobject.timeout_add(200, self.add_result_from_worker)

        self.status_hbox = gtk.HBox()

        #
        #    Empty markup for the ticket ids
        #
        self.link_label = gtk.Label('')
        self.link_label.set_line_wrap(True)
        self.link_label.set_use_markup(True)
        self.status_hbox.pack_end(self.link_label)

        #
        #    Throbber, only show while still running.
        #

        self.throbber = Throbber()
        self.throbber.running(True)
        self.status_hbox.pack_end(self.throbber)

        #
        #    Check, hidden at the beginning
        #    http://www.pygtk.org/docs/pygtk/gtk-stock-items.html
        #
        self.done_icon = gtk.Image()
        self.done_icon.set_from_stock(gtk.STOCK_YES, gtk.ICON_SIZE_BUTTON)
        self.status_hbox.pack_end(self.done_icon)

        self.vbox.pack_start(self.status_hbox, True, True)

        self.add(self.vbox)
        self.show_all()
        self.done_icon.hide()

        super(report_bug_show_result, self).run()
        self.destroy()

        return self.reported_ids
示例#30
0
 def __recibe_stop_rafaga(self, widget):
     """
     Cuando la camara dejará de fotografiar.
     """
     self.info_label.set_text("")
     self.info_label.hide()
     gobject.timeout_add(500, self.__resensitive_foto)