def __init__(self, config, notify_cb = None):
		if notify_cb is None:
			notify_cb = lambda: None

		widgets = Template('preferences_box')

		self.window = widgets.get_widget('preferences_box')
		self.window.connect('destroy', lambda w: self.destroyed())

		network = widgets.get_widget('network_use')
		network.set_active(list(network_levels).index(config.network_use))

		def set_network_use(combo):
			config.network_use = network_levels[network.get_active()]
			config.save_globals()
			notify_cb()
		network.connect('changed', set_network_use)

		# Freshness
		times = [x.time for x in freshness_levels]
		if config.freshness not in times:
			freshness_levels.append(Freshness(config.freshness,
							  '%d seconds' % config.freshness))
			times.append(config.freshness)
		freshness = widgets.get_widget('freshness')
		for level in freshness_levels:
			freshness.append_text(str(level))
		freshness.set_active(times.index(config.freshness))
		def set_freshness(combo, freshness = freshness): # (pygtk bug?)
			config.freshness = freshness_levels[freshness.get_active()].time
			config.save_globals()
			notify_cb()
		freshness.connect('changed', set_freshness)

		stable_toggle = widgets.get_widget('help_test')
		stable_toggle.set_active(config.help_with_testing)
		def toggle_stability(toggle):
			config.help_with_testing = toggle.get_active()
			config.save_globals()
			notify_cb()
		stable_toggle.connect('toggled', toggle_stability)

		# Keys
		keys_view = widgets.get_widget('trusted_keys')
		KeyList(keys_view)

		# Responses
		self.window.set_default_response(gtk.RESPONSE_CLOSE)
		self.window.default_widget.grab_focus()

		def response(dialog, resp):
			if resp in (gtk.RESPONSE_CLOSE, gtk.RESPONSE_DELETE_EVENT):
				self.window.destroy()
			elif resp == gtk.RESPONSE_HELP:
				gui_help.display()
		self.window.connect('response', response)

		self.window.set_default_size(-1, gtk.gdk.screen_height() / 3)
	def __init__(self, config, notify_cb = None):
		if notify_cb is None:
			notify_cb = lambda: None

		def connect_toggle(widget_name, setting_name):
			widget = widgets.get_widget(widget_name)
			widget.set_active(getattr(config, setting_name))
			def toggle(w, config = config, setting_name = setting_name):
				setattr(config, setting_name, w.get_active())
				config.save_globals()
				notify_cb()
			widget.connect('toggled', toggle)

		widgets = Template('preferences_box')

		self.window = widgets.get_widget('preferences_box')
		self.window.connect('destroy', lambda w: self.destroyed())

		# (attribute to avoid: free variable 'network' referenced before assignment in enclosing scope)
		self.network = widgets.get_widget('network_use')
		self.network.set_active(list(network_levels).index(config.network_use))

		def set_network_use(combo):
			config.network_use = network_levels[self.network.get_active()]
			config.save_globals()
			notify_cb()
		self.network.connect('changed', set_network_use)

		# Freshness
		times = [x.time for x in freshness_levels]
		if config.freshness not in times:
			freshness_levels.append(Freshness(config.freshness,
							  '%d seconds' % config.freshness))
			times.append(config.freshness)
		freshness = widgets.get_widget('freshness')
		freshness_model = freshness.get_model()
		for level in freshness_levels:
			i = freshness_model.append()
			freshness_model.set_value(i, 0, str(level))
		freshness.set_active(times.index(config.freshness))
		def set_freshness(combo, freshness = freshness): # (pygtk bug?)
			config.freshness = freshness_levels[freshness.get_active()].time
			config.save_globals()
			notify_cb()
		freshness.connect('changed', set_freshness)

		connect_toggle('help_test', 'help_with_testing')

		# Keys
		keys_view = widgets.get_widget('trusted_keys')
		KeyList(keys_view)
		connect_toggle('auto_approve', 'auto_approve_keys')

		# Responses
		self.window.set_default_response(gtk.RESPONSE_CLOSE)
		self.window.get_default_widget().grab_focus()

		def response(dialog, resp):
			if resp in (gtk.RESPONSE_CLOSE, gtk.RESPONSE_DELETE_EVENT):
				self.window.destroy()
			elif resp == gtk.RESPONSE_HELP:
				gui_help.display()
		self.window.connect('response', response)

		self.window.set_default_size(-1, gtk.gdk.screen_height() / 3)
    def __init__(self, policy, interface, show_versions=False):
        self.policy = policy

        widgets = Template('interface_properties')

        self.interface = interface

        window = widgets.get_widget('interface_properties')
        self.window = window
        window.set_title(_('Properties for %s') % interface.get_name())
        window.set_default_size(-1, gtk.gdk.screen_height() / 3)

        self.compile_button = widgets.get_widget('compile')
        self.compile_button.connect(
            'clicked', lambda b: compile.compile(policy, interface))
        window.set_default_response(gtk.RESPONSE_CANCEL)

        def response(dialog, resp):
            if resp == gtk.RESPONSE_CANCEL:
                window.destroy()
            elif resp == gtk.RESPONSE_HELP:
                properties_help.display()

        window.connect('response', response)

        notebook = widgets.get_widget('interface_notebook')
        assert notebook

        feeds = Feeds(policy, interface, widgets)

        stability = widgets.get_widget('preferred_stability')
        stability.set_active(0)
        if interface.stability_policy:
            i = [stable, testing, developer].index(interface.stability_policy)
            i += 1
            if i == 0:
                warn(_("Unknown stability policy %s"),
                     interface.stability_policy)
        else:
            i = 0
        stability.set_active(i)

        def set_stability_policy(combo):
            i = stability.get_active()
            if i == 0:
                new_stability = None
            else:
                name = stability.get_model()[i][0].lower()
                new_stability = stability_levels[name]
            interface.set_stability_policy(new_stability)
            writer.save_interface(interface)
            policy.recalculate()

        stability.connect('changed', set_stability_policy)

        self.use_list = ImplementationList(policy, interface, widgets)

        self.update_list()

        feeds.tv.grab_focus()

        def updated():
            self.update_list()
            feeds.updated()
            self.shade_compile()

        window.connect('destroy', lambda s: policy.watchers.remove(updated))
        policy.watchers.append(updated)
        self.shade_compile()

        if show_versions:
            notebook.next_page()
Beispiel #4
0
    def __init__(self, driver, interface, compile, show_versions=False):
        self.driver = driver

        widgets = Template('interface_properties')

        self.interface = interface

        window = widgets.get_widget('interface_properties')
        self.window = window
        window.set_title(_('Properties for %s') % interface.get_name())
        window.set_default_size(-1, gtk.gdk.screen_height() / 3)

        self.compile_button = widgets.get_widget('compile')
        self.compile_button.connect('clicked', lambda b: compile(interface))
        window.set_default_response(gtk.RESPONSE_CANCEL)

        def response(dialog, resp):
            if resp == gtk.RESPONSE_CANCEL:
                window.destroy()
            elif resp == gtk.RESPONSE_HELP:
                properties_help.display()

        window.connect('response', response)

        notebook = widgets.get_widget('interface_notebook')
        assert notebook

        target_arch = self.driver.solver.get_arch_for(driver.requirements,
                                                      interface=interface)
        feeds = Feeds(driver.config, target_arch, interface, widgets)

        stability = widgets.get_widget('preferred_stability')
        stability.set_active(0)
        if interface.stability_policy:
            i = [stable, testing, developer].index(interface.stability_policy)
            i += 1
            if i == 0:
                warn(_("Unknown stability policy %s"),
                     interface.stability_policy)
        else:
            i = 0
        stability.set_active(i)

        def set_stability_policy(combo, stability=stability):  # (pygtk bug?)
            i = stability.get_active()
            if i == 0:
                new_stability = None
            else:
                name = ['stable', 'testing', 'developer'][i - 1]
                new_stability = stability_levels[name]
            interface.set_stability_policy(new_stability)
            writer.save_interface(interface)
            import main
            main.recalculate()

        stability.connect('changed', set_stability_policy)

        self.use_list = ImplementationList(driver, interface, widgets)

        self.update_list()

        feeds.tv.grab_focus()

        def updated():
            self.update_list()
            feeds.updated()
            self.shade_compile()

        window.connect('destroy', lambda s: driver.watchers.remove(updated))
        driver.watchers.append(updated)
        self.shade_compile()

        if show_versions:
            notebook.next_page()
	def __init__(self, policy, interface, compile, show_versions = False):
		self.policy = policy

		widgets = Template('interface_properties')

		self.interface = interface

		window = widgets.get_widget('interface_properties')
		self.window = window
		window.set_title(_('Properties for %s') % interface.get_name())
		window.set_default_size(-1, gtk.gdk.screen_height() / 3)

		self.compile_button = widgets.get_widget('compile')
		self.compile_button.connect('clicked', lambda b: compile(interface))
		window.set_default_response(gtk.RESPONSE_CANCEL)

		def response(dialog, resp):
			if resp == gtk.RESPONSE_CANCEL:
				window.destroy()
			elif resp == gtk.RESPONSE_HELP:
				properties_help.display()
		window.connect('response', response)

		notebook = widgets.get_widget('interface_notebook')
		assert notebook

		feeds = Feeds(policy, interface, widgets)

		stability = widgets.get_widget('preferred_stability')
		stability.set_active(0)
		if interface.stability_policy:
			i = [stable, testing, developer].index(interface.stability_policy)
			i += 1
			if i == 0:
				warn(_("Unknown stability policy %s"), interface.stability_policy)
		else:
			i = 0
		stability.set_active(i)

		def set_stability_policy(combo, stability = stability):	# (pygtk bug?)
			i = stability.get_active()
			if i == 0:
				new_stability = None
			else:
				name = ['stable', 'testing', 'developer'][i-1]
				new_stability = stability_levels[name]
			interface.set_stability_policy(new_stability)
			writer.save_interface(interface)
			import main
			main.recalculate()
		stability.connect('changed', set_stability_policy)

		self.use_list = ImplementationList(policy, interface, widgets)

		self.update_list()

		feeds.tv.grab_focus()

		def updated():
			self.update_list()
			feeds.updated()
			self.shade_compile()
		window.connect('destroy', lambda s: policy.watchers.remove(updated))
		policy.watchers.append(updated)
		self.shade_compile()

		if show_versions:
			notebook.next_page()
Beispiel #6
0
    def __init__(self, policy):
        widgets = Template('preferences_box')

        self.window = widgets.get_widget('preferences_box')
        self.window.connect('destroy', lambda w: self.destroyed())

        network = widgets.get_widget('network_use')
        network.set_active(list(network_levels).index(policy.network_use))

        def set_network_use(combo):
            policy.network_use = network_levels[network.get_active()]
            policy.save_config()
            policy.solve_with_downloads()

        network.connect('changed', set_network_use)

        # Freshness
        times = [x.time for x in freshness_levels]
        if policy.freshness not in times:
            freshness_levels.append(
                Freshness(policy.freshness, '%d seconds' % policy.freshness))
            times.append(policy.freshness)
        eb = gtk.EventBox()  # For the tooltip
        freshness = widgets.get_widget('freshness')
        for level in freshness_levels:
            freshness.append_text(str(level))
        freshness.set_active(times.index(policy.freshness))

        def set_freshness(combo):
            policy.freshness = freshness_levels[freshness.get_active()].time
            policy.save_config()
            policy.recalculate()

        freshness.connect('changed', set_freshness)

        stable_toggle = widgets.get_widget('help_test')
        stable_toggle.set_active(policy.help_with_testing)

        def toggle_stability(toggle):
            policy.help_with_testing = toggle.get_active()
            policy.save_config()
            policy.recalculate()

        stable_toggle.connect('toggled', toggle_stability)

        # Keys
        keys_view = widgets.get_widget('trusted_keys')
        KeyList(keys_view)

        # Responses
        self.window.set_default_response(gtk.RESPONSE_CLOSE)
        self.window.default_widget.grab_focus()

        def response(dialog, resp):
            if resp in (gtk.RESPONSE_CLOSE, gtk.RESPONSE_DELETE_EVENT):
                self.window.destroy()
            elif resp == gtk.RESPONSE_HELP:
                gui_help.display()

        self.window.connect('response', response)

        self.window.set_default_size(-1, gtk.gdk.screen_height() / 3)
Beispiel #7
0
    def __init__(self, config, notify_cb=None):
        if notify_cb is None:
            notify_cb = lambda: None

        def connect_toggle(widget_name, setting_name):
            widget = widgets.get_widget(widget_name)
            widget.set_active(getattr(config, setting_name))

            def toggle(w, config=config, setting_name=setting_name):
                setattr(config, setting_name, w.get_active())
                config.save_globals()
                notify_cb()

            widget.connect('toggled', toggle)

        widgets = Template('preferences_box')

        self.window = widgets.get_widget('preferences_box')
        self.window.connect('destroy', lambda w: self.destroyed())

        # (attribute to avoid: free variable 'network' referenced before assignment in enclosing scope)
        self.network = widgets.get_widget('network_use')
        self.network.set_active(list(network_levels).index(config.network_use))

        def set_network_use(combo):
            config.network_use = network_levels[self.network.get_active()]
            config.save_globals()
            notify_cb()

        self.network.connect('changed', set_network_use)

        # Freshness
        times = [x.time for x in freshness_levels]
        if config.freshness not in times:
            freshness_levels.append(
                Freshness(config.freshness, '%d seconds' % config.freshness))
            times.append(config.freshness)
        freshness = widgets.get_widget('freshness')
        freshness_model = freshness.get_model()
        for level in freshness_levels:
            i = freshness_model.append()
            freshness_model.set_value(i, 0, str(level))
        freshness.set_active(times.index(config.freshness))

        def set_freshness(combo, freshness=freshness):  # (pygtk bug?)
            config.freshness = freshness_levels[freshness.get_active()].time
            config.save_globals()
            notify_cb()

        freshness.connect('changed', set_freshness)

        connect_toggle('help_test', 'help_with_testing')

        # Keys
        keys_view = widgets.get_widget('trusted_keys')
        KeyList(keys_view)
        connect_toggle('auto_approve', 'auto_approve_keys')

        # Responses
        self.window.set_default_response(gtk.RESPONSE_CLOSE)
        self.window.get_default_widget().grab_focus()

        def response(dialog, resp):
            if resp in (gtk.RESPONSE_CLOSE, gtk.RESPONSE_DELETE_EVENT):
                self.window.destroy()
            elif resp == gtk.RESPONSE_HELP:
                gui_help.display()

        self.window.connect('response', response)

        self.window.set_default_size(-1, gtk.gdk.screen_height() / 3)