def __init__(self):
"""
Init popover
"""
Gtk.Popover.__init__(self)
self.__input = False
self.set_modal(False)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Eolie/PopoverUri.ui')
builder.connect_signals(self)
self.__scrolled_bookmarks = builder.get_object('scrolled_bookmarks')
# Sorting is broken when using a model
# We should be using Gio.ListStore insert_sorted() but seems broken too
# self.__history_model = Gio.ListStore()
self.__history_box = builder.get_object('history_box')
self.__history_box.set_sort_func(self.__sort_history)
self.__stack = builder.get_object('stack')
# self.__history_box.bind_model(self.__history_model,
# self.__on_item_create)
self.__bookmarks_model = Gio.ListStore()
self.__tags_model = Gio.ListStore()
self.__tags = builder.get_object('tags')
self.__tags_box = builder.get_object('tags_box')
self.__tags_box.bind_model(self.__tags_model, self.__on_item_create)
self.__bookmarks_box = builder.get_object('bookmarks_box')
self.__bookmarks_box.bind_model(self.__bookmarks_model,
self.__on_item_create)
self.add(builder.get_object('widget'))
self.connect('map', self.__on_map)
def __init__(self, application):
super().__init__(application=application)
self.set_default_size(240, 240)
self.set_title('Weather App')
# Create Box layout widget with margins and spacing props
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, margin=6, spacing=6)
# Create SearchEntry widget
self.search_entry = Gtk.SearchEntry(placeholder_text='Enter location name')
# We use ::search-changed signal to make it more reactive.
self.search_entry.connect('search-changed', self.search_changed)
# Model to store locations
self.locations_model = Gio.ListStore()
# Create list view to show locations
self.locations_list = Gtk.ListBox()
self.locations_list.bind_model(self.locations_model, LocationRow)
self.locations_list.show_all()
# Add locations_list to ScrolledWindow to make it scrollable
scroll_window = Gtk.ScrolledWindow()
scroll_window.add(self.locations_list)
# Add widgets to the box
box.pack_start(self.search_entry, False, True, 0)
box.pack_start(scroll_window, True, True, 0)
# And finally add the box as central widget to the window
self.add(box)
# Set visibility of all widgets to visible
self.show_all()
def createPlaylist(self, widget):
inputV = self.builder.get_object("inputV") # filepicker for Videos
inputM = self.builder.get_object("inputM") # filepicker for music
listbox = self.builder.get_object("lstbox")
liststore = Gio.ListStore()
inpv = inputV.get_filename()
inpm = inputM.get_filename()
print("V ", inpv)
print("M ", inpm)
names = ck.rez(inpv, inpm)
# liststore.empty()
for name in names:
print(name)
itemz = Item()
itemz.text = name
liststore.append(itemz)
listbox.bind_model(liststore, self.create_widget_func)
try:
subprocess.Popen(["vlc", "list.xspf"])
except Exception as e:
print('Error')
raise
def iter_to_model(patient_iter: Iterable["Patient"]) -> Gio.ListStore:
"""Convert an iterable of Patient objects into a Gio.ListStore.
Args:
patient_iter (Iterable[Patient]): An iterable of patients to
convert
Returns:
Gio.ListStore: The converted model
"""
model: Gio.ListStore = Gio.ListStore()
patient_list: List[Patient] = list(patient_iter)
def add_patients(patient_list: List[Patient]):
if len(patient_list):
for patient in patient_list[:10]:
model.append(patient)
GLib.timeout_add(20, add_patients, patient_list[10:])
for patient in patient_list[:20]:
model.append(patient)
# left out for perfomance reasons
# add_patients(patient_list[20:])
return model
def __init__(self, widget):
super().__init__()
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.collector = DataCollector()
self.collecting = False
self.stopping = False
self.pause_info = False
self.start_time = 0
self.frame_monitor = None
self.first_frame = True
self.monitors = {}
self.image_viewer = ImageViewer()
self.microscope = Registry.get_utility(IMicroscope)
self.run_editor = datawidget.RunEditor()
self.editor_frame = arrowframe.ArrowFrame()
self.editor_frame.add(self.run_editor.data_form)
self.widget.datasets_overlay.add_overlay(self.editor_frame)
self.run_store = Gio.ListStore(item_type=datawidget.RunItem)
self.run_store.connect('items-changed', self.on_runs_changed)
self.collector.connect('done', self.on_done)
self.collector.connect('paused', self.on_pause)
self.collector.connect('stopped', self.on_stopped)
self.collector.connect('progress', self.on_progress)
self.collector.connect('started', self.on_started)
Registry.add_utility(IDatasets, self)
self.setup()
def model(self):
if self._model is None:
self._model = Gio.ListStore()
self._populate_model()
return self._model
def __init__(self, window):
"""
Init popover
@param window as Window
"""
Gtk.Popover.__init__(self)
self.set_modal(False)
window.register(self, False)
self.__window = window
self.__input = False
self.__modifier = 0
self.get_style_context().add_class("box-shadow")
builder = Gtk.Builder()
builder.add_from_resource("/org/gnome/Eolie/PopoverUri.ui")
builder.connect_signals(self)
self.__scrolled_bookmarks = builder.get_object("scrolled_bookmarks")
self.__infobar = builder.get_object("infobar")
self.__infobar_confirm = Gtk.Button()
self.__infobar_confirm.show()
self.__infobar_select = Gtk.ComboBoxText()
self.__infobar_select.show()
self.__infobar.get_content_area().add(self.__infobar_select)
self.__infobar.add_action_widget(self.__infobar_confirm, 1)
self.__infobar.add_button(_("Cancel"), 2)
self.__history_model = Gio.ListStore()
self.__history_box = builder.get_object("history_box")
self.__history_box.bind_model(self.__history_model,
self.__on_item_create)
self.__search_box = builder.get_object("search_box")
self.__search_box.set_sort_func(self.__sort_search)
self.__stack = builder.get_object("stack")
self.__bookmarks_model = Gio.ListStore()
self.__tags = builder.get_object("tags")
self.__tags_box = builder.get_object("tags_box")
self.__tags_box.set_sort_func(self.__sort_tags)
self.__remove_button = builder.get_object("remove_button")
self.__bookmarks_count = builder.get_object("count")
self.__bookmarks_box = builder.get_object("bookmarks_box")
self.__bookmarks_box.bind_model(self.__bookmarks_model,
self.__on_item_create)
self.__calendar = builder.get_object("calendar")
if El().sync_worker is not None:
self.__sync_stack = builder.get_object("sync_stack")
self.__sync_stack.show()
self.add(builder.get_object("widget"))
self.connect("map", self.__on_map)
self.connect("unmap", self.__on_unmap)
def setup_shows_listbox(lb, shows):
ls = Gio.ListStore()
for s in shows:
ls.append(ShowObject(s.title, 'by {}'.format(s.nickname), s.logo_path))
lb.bind_model(
ls, lambda model, data: show.Show(model.title, model.subtitle, model.
logo_path), None)
def __init__(self, coreselection):
super().__init__()
self._flatten_model = None
self._playlist_signal_id = None
self._previous_playlist_model = None
self._search_signal_id = None
self._song_signal_id = None
self._model = Gio.ListStore.new(CoreSong)
self._songliststore = SongListStore(self._model)
self._coreselection = coreselection
self._album_model = Gio.ListStore()
self._album_model_sort = Gfm.SortListModel.new(self._album_model)
self._album_model_sort.set_sort_func(
self._wrap_list_store_sort_func(self._albums_sort))
self._artist_model = Gio.ListStore.new(CoreArtist)
self._artist_model_sort = Gfm.SortListModel.new(self._artist_model)
self._artist_model_sort.set_sort_func(
self._wrap_list_store_sort_func(self._artist_sort))
self._playlist_model = Gio.ListStore.new(CoreSong)
self._playlist_model_sort = Gfm.SortListModel.new(self._playlist_model)
self._song_search_proxy = Gio.ListStore.new(Gfm.FilterListModel)
self._song_search_flatten = Gfm.FlattenListModel.new(CoreSong)
self._song_search_flatten.set_model(self._song_search_proxy)
self._album_search_model = Gfm.FilterListModel.new(
self._album_model)
self._album_search_model.set_filter_func(lambda a: False)
self._album_search_filter = Gfm.FilterListModel.new(
self._album_search_model)
self._artist_search_model = Gfm.FilterListModel.new(
self._artist_model)
self._artist_search_model.set_filter_func(lambda a: False)
self._artist_search_filter = Gfm.FilterListModel.new(
self._artist_search_model)
self._playlists_model = Gio.ListStore.new(Playlist)
self._playlists_model_filter = Gfm.FilterListModel.new(
self._playlists_model)
self._playlists_model_sort = Gfm.SortListModel.new(
self._playlists_model_filter)
self._playlists_model_sort.set_sort_func(
self._wrap_list_store_sort_func(self._playlists_sort))
self.props.grilo = CoreGrilo(self, self._coreselection)
# FIXME: Not all instances of internal _grilo use have been
# fixed.
self._grilo = self.props.grilo
self._model.connect("items-changed", self._on_songs_items_changed)
def update_cpubox(self):
"""Update the CPU Combobox"""
self.cpu_store = Gio.ListStore()
self.cpu_box.bind_name_model(self.cpu_store, lambda x: x.name)
for cpu in self.online_cpus:
self.cpu_store.append(CpuCore(cpu))
self.cpu_box.set_selected_index(0)
def __init__(self, app):
super().__init__(application=app, title=_("Producers Dashboard"))
self.settings = Gio.Settings.new('gr.uoc.radio.dashboard')
self.set_size_request(200, 100)
# <State>
self.store = Store()
self.current_user = None
self.user_shows = None
self.current_show = None
self.timer_id = None
self.time_for_live = None
self.pagination_state = None
self.metadata_propagation_state = None
# Keep a single TextBuffer for all pages
self.message_buffer = Gtk.TextBuffer()
self.inbox_messages_model = Gio.ListStore()
self.players_model = Gtk.ListStore(str)
self.pool = ThreadPool(processes=1)
self.message_fetcher = MockMessagesFetcher(20)
self.message_fetcher.connect('new-messages-received', self._on_new_messages_received)
# Need a reference to live page, as it is needed for message received handler
self.live_page = None
# </State>
self.prev_view = None
self.curr_view = None
size_setting = self.settings.get_value('window-size')
if isinstance(size_setting[0], int) and isinstance(size_setting[1], int):
self.resize(size_setting[0], size_setting[1])
position_setting = self.settings.get_value('window-position')
if len(position_setting) == 2 \
and isinstance(position_setting[0], int) \
and isinstance(position_setting[1], int):
self.move(position_setting[0], position_setting[1])
if self.settings.get_value('window-maximized'):
self.maximize()
self._setup_view()
self.window_size_update_timeout = None
self.connect("notify::is-maximized", self._on_maximized)
self.connect("configure-event", self._on_configure_event)
def __init__(self, view, widget):
super().__init__()
self.model = Gtk.ListStore(*self.Data.TYPES)
self.search_model = self.model.filter_new()
self.search_model.set_visible_func(self.search_data)
self.sort_model = Gtk.TreeModelSort(model=self.search_model)
self.group_model = Gio.ListStore(item_type=GroupItem)
self.group_registry = {}
self.prefetch_pending = False
self.initializing = True
# initialize properties
self.props.next_sample = {}
self.props.current_sample = {}
self.props.ports = set()
self.props.containers = set()
cache = load_cache('samples')
self.props.cache = set() if not cache else set(cache)
self.filter_text = ''
self.view = view
self.widget = widget
self.view.set_model(self.sort_model)
self.beamline = Registry.get_utility(IBeamline)
self.setup()
self.model.connect('row-changed', self.on_sample_row_changed)
self.widget.samples_selectall_btn.connect('clicked',
self.on_select_all)
self.widget.samples_selectnone_btn.connect('clicked',
self.on_unselect_all)
self.view.connect('key-press-event', self.on_key_press)
self.widget.samples_reload_btn.connect('clicked',
lambda x: self.import_mxlive())
self.beamline.automounter.connect('sample', self.on_sample_mounted)
self.beamline.automounter.connect('next-port', self.on_prefetched)
self.beamline.automounter.connect('ports', self.update_states)
self.widget.samples_mount_btn.connect('clicked',
lambda x: self.mount_action())
self.widget.samples_dismount_btn.connect(
'clicked', lambda x: self.dismount_action())
self.widget.samples_search_entry.connect('search-changed',
self.on_search)
self.widget.mxdc_main.connect('realize', self.import_mxlive)
self.connect('notify::cache', self.on_cache)
self.connect('notify::current-sample', self.on_cur_changed)
self.connect('notify::next-sample', self.on_next_changed)
Registry.add_utility(ISampleStore, self)
def _get_album_model(self):
disc_model = Gio.ListStore()
disc_model_sort = Gfm.SortListModel.new(disc_model)
def _disc_order_sort(disc_a, disc_b):
return disc_a.props.disc_nr - disc_b.props.disc_nr
disc_model_sort.set_sort_func(
utils.wrap_list_store_sort_func(_disc_order_sort))
self._coregrilo.get_album_discs(self.props.media, disc_model)
return disc_model_sort
def update_profile_boxes(self):
# Configure profiles box
self.prof_store = Gio.ListStore()
# Empty profile name to use for resetting settings
self.prof_store.append(Profile(_("No profile")))
# Add the profiles from configuration
for prof in self.conf.profiles:
profile = self.conf.get_profile(prof)
self.prof_store.append(Profile(profile))
self.profile_box.bind_name_model(self.prof_store, lambda x: x.name)
# Add the profiles from configuration to prefs
model = Gio.ListStore()
for prof in self.conf.profiles:
model.append(Profile(prof))
index = self.conf.get_profile_index(self.conf.default_profile)
self.default_profile_pref.bind_name_model(model, lambda x: x.name)
self.default_profile_pref.set_selected_index(index)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.init_template()
# Set up comment type list
self.__comment_type_model = Gio.ListStore()
self.__set_up_comment_types_list_widget()
self.__set_comment_type_content()
# Set up header combo box
self.__combo_model = Gtk.ListStore(str)
self.__set_up_combo_box_header_subtitle()
self.list_ct.unselect_all()
def __init__(self,
songs: Iterable[AudioFile],
manager: CoverManager,
config: Config,
headless: bool = False,
**kwargs):
super().__init__(title=_("Cover Art Download"),
use_header_bar=True,
**kwargs)
self.set_default_size(1400, 720)
id_ = DownloadCoverArt.PLUGIN_ID.lower().replace(" ", "_")
self.enable_window_tracking(id_)
self.config = config
self.headless = headless
self.flow_box = box = Gtk.FlowBox()
self.model = Gio.ListStore()
self.songs = songs
self._groups = {}
self.button = None
def selected(fb):
children = fb.get_selected_children()
if children:
cover = self.model.get_item(children[0].get_index())
if cover:
self.button.set_sensitive(True)
# Only supported on GTK >= 3.18 (not Ubuntu 16.04)
# Re-enable some day perhaps...
# box.bind_model(self.model, self.create_widget, None)
box.set_valign(Gtk.Align.START)
box.set_max_children_per_line(4)
box.connect("selected-children-changed", selected)
paned = Paned(orientation=Gtk.Orientation.VERTICAL)
paned.ensure_wide_handle()
sw = Gtk.ScrolledWindow()
sw.add(self.flow_box)
paned.pack1(sw, True, True)
paned.pack2(self.create_options(), False, False)
self.vbox.pack_start(paned, True, True, 0)
connect_destroy(manager, "covers-found", self._covers_found)
connect_destroy(manager, "searches-complete", self._finished)
cancellable = self.__cancellable = Gio.Cancellable()
self.show_all()
# Do the search
self._groups = manager.search_cover(cancellable, songs)
def __init__(self, list_id, **kwargs):
super().__init__(**kwargs)
self.init_template()
self.list_id = list_id
self.list_store = Gio.ListStore()
self.load_categories()
self.categories_list.bind_model(self.list_store, self.make_list_widget)
self.close_btn.connect('clicked', self.handle_close)
self.new_category_btn.connect('clicked', self.handle_new_cat)
self.new_input.connect('activate', self.handle_new_entry_activate)
def __init__(self, app, file_handler):
self.group_lists = {}
self.app = app
self.visible_group = None
self.dragged_note = None
self.file_handler = file_handler
self.file_handler.connect('group-changed', self.on_list_changed)
self.builder = Gtk.Builder.new_from_file('/usr/share/sticky/manager.ui')
self.window = self.builder.get_object('main_window')
self.group_list = self.builder.get_object('group_list')
self.note_view = self.builder.get_object('note_view')
def create_group_entry(item):
widget = Gtk.ListBoxRow()
widget.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT, NOTE_TARGETS, Gdk.DragAction.MOVE)
widget.connect('drag-drop', self.handle_drop)
widget.item = item
box = Gtk.Box()
widget.add(box)
label = Gtk.Label(label=item.name, halign=Gtk.Align.START, margin=5)
box.pack_start(label, True, True, 10)
if item.is_default:
box.pack_end(Gtk.Image.new_from_icon_name('emblem-default-symbolic', Gtk.IconSize.BUTTON), False, False, 10)
elif item.visible:
box.pack_end(Gtk.Image.new_from_icon_name('group-visible-symbolic', Gtk.IconSize.BUTTON), False, False, 10)
return widget
self.group_model = Gio.ListStore()
self.group_list.bind_model(self.group_model, create_group_entry)
self.group_list.connect('row-selected', self.generate_previews)
self.builder.get_object('new_note').connect('clicked', self.new_note)
self.builder.get_object('new_group').connect('clicked', self.new_group)
self.builder.get_object('remove_note').connect('clicked', self.remove_note)
self.builder.get_object('remove_group').connect('clicked', self.remove_group)
self.builder.get_object('preview_group').connect('clicked', self.preview_group)
self.builder.get_object('set_default').connect('clicked', self.set_default)
self.generate_group_list()
self.window.show_all()
def generate_group_list(self, *args):
name = None
selected_group_name = self.get_current_group()
self.group_model.remove_all()
for group_name in self.file_handler.get_note_group_names():
model = Gio.ListStore()
if self.app.settings.get_string('active-group') == group_name:
name = group_name
self.group_model.append(Group(group_name, self.file_handler, model))
self.group_list.show_all()
if name != None:
self.select_group(name)
def __init__(self, parent):
self.setup_gui()
self.settings = Gio.ListStore(item_type=Setting)
self.settings_list.bind_model(self.settings, self.create_setting)
self.settings_list.connect('row-selected', self.on_row_selected)
self.active_item = None
for key, icon, validator in self.OPTIONS:
item = Setting(key, icon, validator)
self.settings.append(item)
self.settings_dialog.set_transient_for(parent)
self.use_default_switch.connect('notify::active',
self.on_default_switched)
self.custom_entry.connect('changed', self.on_custom_changed)
self.settings_dialog.connect('destroy',
lambda x: self.settings_dialog.destroy())
def __init__(self, widget):
self.widget = widget
self.beamline = Registry.get_utility(IBeamline)
self.messages = Gio.ListStore(item_type=Message)
self.configs = {}
self.add_avatars()
self.widget.chat_messages.bind_model(self.messages, self.create_message)
self.widget.chat_user_fbk.set_text(misc.get_project_name().upper())
self.widget.avatar_box.connect('child-activated', self.select_avatar)
self.widget.chat_config_btn.set_popover(self.widget.chat_avatars_pop)
self.widget.chat_msg_entry.connect('activate', self.send_message)
self.widget.chat_messages.connect('size-allocate', self.adjust_view)
self.beamline.messenger.connect('message', self.show_message)
self.beamline.messenger.connect('config', self.update_configs)
self.configs = {}
def iter_to_model(program_iter: Iterable["Program"]) -> Gio.ListStore:
"""Convert an iterable of Program objects into a Gio.ListStore.
Args:
program_iter (Iterable[Program]): An iterable of programs to convert
Returns:
Gio.ListStore: The converted model"""
model: Gio.ListStore = Gio.ListStore()
program_list: List[Program] = list(program_iter)
for program in program_list:
model.append(program)
return model
def __init__(self, coreselection):
super().__init__()
self._flatten_model = None
self._search_signal_id = None
self._song_signal_id = None
self._model = Gio.ListStore.new(CoreSong)
self._songliststore = SongListStore(self._model)
self._coreselection = coreselection
self._album_model = Gio.ListStore()
self._album_model_sort = Gfm.SortListModel.new(self._album_model)
self._album_model_sort.set_sort_func(
self._wrap_list_store_sort_func(self._albums_sort))
self._artist_model = Gio.ListStore.new(CoreArtist)
self._artist_model_sort = Gfm.SortListModel.new(self._artist_model)
self._artist_model_sort.set_sort_func(
self._wrap_list_store_sort_func(self._artist_sort))
self._playlist_model = Gio.ListStore.new(CoreSong)
self._playlist_model_sort = Gfm.SortListModel.new(self._playlist_model)
self._song_search_proxy = Gio.ListStore.new(Gfm.FilterListModel)
self._song_search_flatten = Gfm.FlattenListModel.new(CoreSong)
self._song_search_flatten.set_model(self._song_search_proxy)
self._album_search_model = Dazzle.ListModelFilter.new(
self._album_model)
self._album_search_model.set_filter_func(lambda a: False)
self._artist_search_model = Dazzle.ListModelFilter.new(
self._artist_model)
self._artist_search_model.set_filter_func(lambda a: False)
self._playlists_model = Gio.ListStore.new(Playlist)
self._playlists_model_filter = Dazzle.ListModelFilter.new(
self._playlists_model)
self._playlists_model_sort = Gfm.SortListModel.new(
self._playlists_model_filter)
self._playlists_model_sort.set_sort_func(
self._wrap_list_store_sort_func(self._playlists_sort))
self._grilo = CoreGrilo(self, self._coreselection)
self._model.connect("items-changed", self._on_songs_items_changed)
def test_list_store_insert_sorted():
store = Gio.ListStore()
items = [NamedItem(name=n) for n in "cabx"]
sorted_items = sorted(items, key=lambda i: i.props.name)
user_data = [object(), object()]
def sort_func(a, b, *args):
assert list(args) == user_data
assert isinstance(a, NamedItem)
assert isinstance(b, NamedItem)
return cmp(a.props.name, b.props.name)
for item in items:
index = store.insert_sorted(item, sort_func, *user_data)
assert isinstance(index, int)
assert store[:] == sorted_items
def iter_to_model(user_iter: Iterable["User"]) -> Gio.ListStore:
"""Convert an iterable of User objects into a Gio.ListStore.
Args:
user_iter (Iterable[User]): An iterable of users to convert
Returns:
Gio.ListStore: The converted model
"""
model: Gio.ListStore = Gio.ListStore()
user_list: List[User] = list(user_iter)
for user in user_list:
model.append(user)
return model
def iter_to_model(treatment_iter: Iterable["Treatment"]) -> Gio.ListStore:
"""Convert an iterable of Treatment objects into a Gio.ListStore.
Args:
treatment_iter (Iterable[Treatment]): An iterable of treatments to
convert
Returns:
Gio.ListStore: The converted model
"""
model: Gio.ListStore = Gio.ListStore()
treatment_list: List[Treatment] = list(treatment_iter)
for treatment in treatment_list:
model.append(treatment)
return model
def test_list_store_sort():
store = Gio.ListStore()
items = [NamedItem(name=n) for n in "cabx"]
sorted_items = sorted(items, key=lambda i: i.props.name)
user_data = [object(), object()]
def sort_func(a, b, *args):
assert list(args) == user_data
assert isinstance(a, NamedItem)
assert isinstance(b, NamedItem)
cmp = lambda a, b: (a > b) - (a < b)
return cmp(a.props.name, b.props.name)
store[:] = items
assert store[:] != sorted_items
store.sort(sort_func, *user_data)
assert store[:] == sorted_items
def _update_gov_box(self):
"""Updates the governor combobox"""
cpu = self._get_active_cpu()
conf = self.settings.get(cpu)
governor = conf.govid
governors = conf.governors
if governor is not None:
gov_store = Gio.ListStore()
for govid, gov in enumerate(governors):
gov_store.append(Governor(govid, gov.capitalize()))
self.gov_box.bind_name_model(gov_store, lambda x: x.name)
self.gov_box.set_selected_index(governor)
self.gov_box.set_sensitive(True)
else:
self.gov_box.set_sensitive(False)
def generate_group_list(self, *args):
selected_group_name = self.get_current_group()
self.group_model.remove_all()
for group_name in self.file_handler.get_note_group_names():
note_list = self.file_handler.get_note_list(group_name)
model = Gio.ListStore()
is_default = self.app.settings.get_string('default-group') == group_name
visible = self.visible_group == group_name
self.group_model.append(Group(group_name, note_list, model, is_default, visible))
self.group_list.show_all()
for row in self.group_list.get_children():
if row.item.name == selected_group_name:
self.group_list.select_row(row)
return
def _update_energy_pref_box(self):
"""Updates the energy performance combobox"""
cpu = self._get_active_cpu()
conf = self.settings.get(cpu)
energy_pref = conf.energy_pref_id
energy_prefs = conf.energy_prefs
if energy_pref != -1:
pref_store = Gio.ListStore()
for prefid, pref in enumerate(energy_prefs):
if "_" in pref:
pref = pref.replace("_", " ")
pref_store.append(EnergyPref(prefid, pref.capitalize()))
self.energy_pref_box.bind_name_model(pref_store, lambda x: x.name)
self.energy_pref_box.set_selected_index(energy_pref)
self.energy_pref_box.set_sensitive(True)
else:
self.energy_pref_box.set_sensitive(False)
