def confirm_transaction(self,
to_install: Optional[Collection[DebianPackage]],
removal: Optional[Collection[DebianPackage]],
watcher: ProcessWatcher) -> bool:
components = []
to_remove_data = self._map_to_remove(removal)
text_width, select_width = 672, 595
if to_remove_data:
to_remove_data[0].sort(key=attrgetter('label'))
lb_rem = self._i18n['debian.transaction.to_remove'].format(
no=bold(str(len(to_remove_data[0]))),
fspace=bold(to_remove_data[1]))
components.append(TextComponent(html=lb_rem, min_width=text_width))
components.append(
MultipleSelectComponent(id_='rem',
options=to_remove_data[0],
label=None,
default_options={*to_remove_data[0]},
max_width=select_width))
to_install_data = self._map_to_install(to_install)
if to_install_data:
to_install_data[0].sort(key=attrgetter('label'))
lb_deps = self._i18n['debian.transaction.to_install'].format(
no=bold(str(len(to_install_data[0]))),
dsize=bold(to_install_data[2]),
isize=bold(to_install_data[1]))
components.append(
TextComponent(html=f'<br/>{lb_deps}', min_width=text_width))
components.append(
MultipleSelectComponent(id_='inst',
label='',
options=to_install_data[0],
default_options={*to_install_data[0]},
max_width=select_width))
return watcher.request_confirmation(
title=self._i18n['debian.transaction.title'],
components=components,
confirmation_label=self._i18n['popup.button.continue'],
deny_label=self._i18n['popup.button.cancel'],
body=None,
min_width=text_width,
min_height=54)
def request_install_missing_deps(pkgname: str, deps: List[Tuple[str, str]],
watcher: ProcessWatcher, i18n: I18n) -> bool:
msg = '<p>{}</p>'.format(i18n['arch.missing_deps.body'].format(
name=bold(pkgname) if pkgname else '', deps=bold(str(len(deps)))))
opts = []
repo_deps = [d[0] for d in deps if d[1] != 'aur']
sizes = pacman.get_update_size(repo_deps) if repo_deps else {}
for dep in deps:
size = sizes.get(dep[0])
op = InputOption(
'{} ({}: {}) - {}: {}'.format(
dep[0], i18n['repository'], dep[1].lower(),
i18n['size'].capitalize(),
get_human_size_str(size) if size else '?'), dep[0])
op.read_only = True
op.icon_path = _get_repo_icon(dep[1])
opts.append(op)
comp = MultipleSelectComponent(label='',
options=opts,
default_options=set(opts))
return watcher.request_confirmation(
i18n['arch.missing_deps.title'],
msg, [comp],
confirmation_label=i18n['continue'].capitalize(),
deny_label=i18n['cancel'].capitalize())
def request_optional_deps(pkgname: str, pkg_repos: dict,
watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
opts = []
repo_deps = [
p for p, data in pkg_repos.items() if data['repository'] != 'aur'
]
sizes = pacman.get_update_size(repo_deps) if repo_deps else {}
for p, d in pkg_repos.items():
size = sizes.get(p)
op = InputOption(
'{}{} ({}: {}) - {}: {}'.format(
p, ': ' + d['desc'] if d['desc'] else '', i18n['repository'],
d['repository'].lower(), i18n['size'].capitalize(),
get_human_size_str(size) if size else '?'), p)
op.icon_path = _get_repo_icon(d['repository'])
opts.append(op)
view_opts = MultipleSelectComponent(label='',
options=opts,
default_options=set(opts))
install = watcher.request_confirmation(
title=i18n['arch.install.optdeps.request.title'],
body='<p>{}.</p><p>{}:</p>'.format(
i18n['arch.install.optdeps.request.body'].format(bold(pkgname)),
i18n['arch.install.optdeps.request.help']),
components=[view_opts],
confirmation_label=i18n['install'].capitalize(),
deny_label=i18n['do_not.install'].capitalize())
if install:
return {o.value for o in view_opts.values}
def request_optional_deps(pkgname: str, pkg_mirrors: dict,
watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
opts = []
for p, d in pkg_mirrors.items():
op = InputOption(
'{}{} ( {}: {} )'.format(p, ': ' + d['desc'] if d['desc'] else '',
i18n['repository'], d['mirror'].upper()),
p)
op.icon_path = _get_mirror_icon(d['mirror'])
opts.append(op)
view_opts = MultipleSelectComponent(label='',
options=opts,
default_options=set(opts))
install = watcher.request_confirmation(
title=i18n['arch.install.optdeps.request.title'],
body='<p>{}.</p><p>{}:</p>'.format(
i18n['arch.install.optdeps.request.body'].format(bold(pkgname)),
i18n['arch.install.optdeps.request.help']),
components=[view_opts],
confirmation_label=i18n['install'].capitalize(),
deny_label=i18n['do_not.install'].capitalize())
if install:
return {o.value for o in view_opts.values}
def request_install_missing_deps(pkgname: str, deps: List[Tuple[str, str]],
watcher: ProcessWatcher, i18n: I18n) -> bool:
msg = '<p>{}</p>'.format(i18n['arch.missing_deps.body'].format(
name=bold(pkgname) if pkgname else '', deps=bold(str(len(deps)))))
opts = []
sorted_deps = [*deps]
sorted_deps.sort(key=lambda e: e[0])
for dep in sorted_deps:
op = InputOption(
'{} ( {}: {} )'.format(dep[0], i18n['repository'], dep[1].upper()),
dep[0])
op.read_only = True
op.icon_path = _get_mirror_icon(dep[1])
opts.append(op)
comp = MultipleSelectComponent(label='',
options=opts,
default_options=set(opts))
return watcher.request_confirmation(
i18n['arch.missing_deps.title'],
msg, [comp],
confirmation_label=i18n['continue'].capitalize(),
deny_label=i18n['cancel'].capitalize())
def request_optional_deps(pkgname: str, pkg_repos: dict, watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
opts = []
repo_deps = [p for p, data in pkg_repos.items() if data['repository'] != 'aur']
sizes = pacman.map_update_sizes(repo_deps) if repo_deps else {}
for p, d in pkg_repos.items():
size = sizes.get(p)
label = f"{p} ({i18n['repository']}: {d['repository'].lower()}) | " \
f"{i18n['size'].capitalize()}: {get_human_size_str(size) if size is not None else '?'}"
op = InputOption(label=label, value=p, tooltip=d.get('desc') or None)
op.icon_path = _get_repo_icon(d['repository'])
opts.append(op)
view_opts = MultipleSelectComponent(label='',
options=opts,
default_options=set(opts))
msg = f"<p>{i18n['arch.install.optdeps.request.success'].format(pkg=bold(pkgname))}</p>" \
f"<p>{i18n['arch.install.optdeps.request.body']}:</p>"
install = watcher.request_confirmation(title=i18n['arch.install.optdeps.request.title'],
body=msg,
components=[view_opts],
confirmation_label=i18n['install'].capitalize(),
deny_label=i18n['do_not.install'].capitalize(),
min_width=600,
min_height=200)
if install:
return {o.value for o in view_opts.values}
def confirm_missing_deps(deps: Collection[Tuple[str, str]], watcher: ProcessWatcher, i18n: I18n) -> bool:
opts = []
total_isize, total_dsize = None, None
pkgs_data = pacman.map_updates_data(pkgs=tuple(d[0] for d in deps if d[1] != 'aur'), description=True) or dict()
for dep in deps:
ver, desc, isize, dsize = None, None, None, None
data = pkgs_data.get(dep[0])
if data:
desc, isize, dsize = (data.get(f) for f in ('des', 's', 'ds'))
if isize is not None:
if total_isize is None:
total_isize = 0
total_isize += isize
if dsize is not None:
if total_dsize is None:
total_dsize = 0
total_dsize += dsize
label = f"{dep[0]} | " \
f"{i18n['size'].capitalize()}: {get_human_size_str(isize) if isize is not None else '?'}" \
f"{' ({}: {})'.format(i18n['download'].capitalize(), get_human_size_str(dsize)) if dsize else ''}"
op = InputOption(label=label, value=dep[0], tooltip=desc)
op.read_only = True
op.icon_path = _get_repo_icon(dep[1])
opts.append(op)
comp = MultipleSelectComponent(label='', options=opts, default_options=set(opts))
body = StringIO()
body.write('<p>')
body.write(i18n['arch.missing_deps.body'].format(deps=bold(str(len(deps)))))
if total_isize is not None or total_dsize is not None:
body.write(' (')
if total_isize is not None:
body.write(f"{i18n['size'].capitalize()}: {bold(get_human_size_str(total_isize))} | ")
if total_dsize is not None:
body.write(f"{i18n['download'].capitalize()}: {bold(get_human_size_str(total_dsize))}")
body.write(')')
body.write(':</p>')
return watcher.request_confirmation(title=i18n['arch.missing_deps.title'],
body=body.getvalue(),
components=[comp],
confirmation_label=i18n['continue'].capitalize(),
deny_label=i18n['cancel'].capitalize(),
min_width=625)
def _gen_cannot_upgrade_form(self, reqs: List[UpgradeRequirement]) -> FormComponent:
reqs.sort(key=UpgradeRequirement.sort_by_priority)
opts = [self._req_as_option(req=r, tooltip=False, custom_tooltip=r.reason, display_sizes=False) for r in reqs]
comps = [MultipleSelectComponent(label='', options=opts, default_options=set(opts))]
return FormComponent(label='{} ({}: {})'.format(self.i18n['action.update.cannot_update_label'],
self.i18n['amount'].capitalize(), len(opts)),
components=comps)
def _gen_to_remove_form(self, reqs: List[UpgradeRequirement]) -> FormComponent:
opts = [self._req_as_option(r, False, r.reason, required_size=False) for r in reqs]
comps = [MultipleSelectComponent(label='', options=opts, default_options=set(opts))]
required_size, extra_size = self._sum_pkgs_size(reqs)
lb = '{} ({}: {} | {}: {})'.format(self.i18n['action.update.label_to_remove'].capitalize(),
self.i18n['amount'].capitalize(),
len(opts),
self.i18n['action.update.storage_size'],
'?' if extra_size is None else get_human_size_str(-extra_size))
return FormComponent(label=lb, components=comps)
def get_settings(self, screen_width: int, screen_height: int) -> ViewComponent:
tabs = list()
gem_opts, def_gem_opts, gem_tabs = [], set(), []
for man in self.managers:
if man.can_work():
man_comp = man.get_settings(screen_width, screen_height)
modname = man.__module__.split('.')[-2]
icon_path = "{r}/gems/{n}/resources/img/{n}.svg".format(r=ROOT_DIR, n=modname)
if man_comp:
tab_name = self.i18n.get('gem.{}.label'.format(modname), modname.capitalize())
gem_tabs.append(TabComponent(label=tab_name, content=man_comp, icon_path=icon_path, id_=modname))
opt = InputOption(label=self.i18n.get('gem.{}.label'.format(modname), modname.capitalize()),
tooltip=self.i18n.get('gem.{}.info'.format(modname)),
value=modname,
icon_path='{r}/gems/{n}/resources/img/{n}.svg'.format(r=ROOT_DIR, n=modname))
gem_opts.append(opt)
if man.is_enabled() and man in self.working_managers:
def_gem_opts.add(opt)
core_config = read_config()
if gem_opts:
type_help = TextComponent(html=self.i18n['core.config.types.tip'])
gem_opts.sort(key=lambda o: o.value)
gem_selector = MultipleSelectComponent(label=None,
tooltip=None,
options=gem_opts,
max_width=floor(screen_width * 0.22),
default_options=def_gem_opts,
id_="gems")
tabs.append(TabComponent(label=self.i18n['core.config.tab.types'],
content=PanelComponent([type_help, FormComponent([gem_selector], spaces=False)]),
id_='core.types'))
tabs.append(self._gen_general_settings(core_config, screen_width, screen_height))
tabs.append(self._gen_ui_settings(core_config, screen_width, screen_height))
tabs.append(self._gen_tray_settings(core_config, screen_width, screen_height))
tabs.append(self._gen_adv_settings(core_config, screen_width, screen_height))
bkp_settings = self._gen_backup_settings(core_config, screen_width, screen_height)
if bkp_settings:
tabs.append(bkp_settings)
for tab in gem_tabs:
tabs.append(tab)
return TabGroupComponent(tabs)
def _gen_cannot_update_form(
self, reqs: List[UpgradeRequirement]) -> FormComponent:
opts = [self._req_as_option(r, False, r.reason) for r in reqs]
comps = [
MultipleSelectComponent(label='',
options=opts,
default_options=set(opts))
]
return FormComponent(
label=self.i18n['action.update.cannot_update_label'],
components=comps)
def _gen_to_install_form(self, reqs: List[UpgradeRequirement]) -> Tuple[FormComponent, Tuple[int, int]]:
opts = [self._req_as_option(r, custom_tooltip=r.reason, positive_size_symbol=True) for r in reqs]
comps = [MultipleSelectComponent(label='', options=opts, default_options=set(opts))]
required_size, extra_size = self._sum_pkgs_size(reqs)
lb = '{} ({}: {} | {}: {} | {}: {})'.format(self.i18n['action.update.required_label'].capitalize(),
self.i18n['amount'].capitalize(),
len(opts),
self.i18n['action.update.storage_size'],
'?' if extra_size is None else get_human_size_str(extra_size, True),
self.i18n['action.update.download_size'],
'?' if required_size is None else get_human_size_str(required_size))
return FormComponent(label=lb, components=comps), (required_size, extra_size)
def _gen_to_update_form(self, reqs: List[UpgradeRequirement]) -> Tuple[FormComponent, Tuple[int, int]]:
opts = [self._req_as_option(r, tooltip=False) for r in reqs]
comps = [MultipleSelectComponent(label='', options=opts, default_options=set(opts))]
required_size, extra_size = self._sum_pkgs_size(reqs)
lb = '{} ( {}: {}. {}: {}. {}: {} )'.format(self.i18n['action.update.label_to_upgrade'].capitalize(),
self.i18n['amount'].capitalize(),
len(opts),
self.i18n['size'].capitalize(),
'?' if extra_size is None else get_human_size_str(extra_size),
self.i18n['action.update.pkg.required_size'].capitalize(),
'?' if required_size is None else get_human_size_str(required_size))
return FormComponent(label=lb, components=comps), (required_size, extra_size)
def confirm_removal(self, source_pkg: str,
dependencies: Collection[DebianPackage],
watcher: ProcessWatcher) -> bool:
dep_views = []
freed_space = 0
for p in sorted(dependencies, key=attrgetter('name')):
if p.transaction_size is not None:
size = p.transaction_size * (-1
if p.transaction_size < 0 else 1)
freed_space += size
size_str = get_human_size_str(size)
else:
size_str = '?'
dep_views.append(
InputOption(label=f"{p.name}: -{size_str}",
value=p.name,
read_only=True,
icon_path=DEBIAN_ICON_PATH,
tooltip=p.description))
deps_container = MultipleSelectComponent(id_='deps',
label='',
options=dep_views,
default_options={*dep_views},
max_width=537)
freed_space_str = bold('-' + get_human_size_str(freed_space))
body_text = TextComponent(html=self._i18n['debian.remove_deps'].format(
no=bold(str(len(dependencies))),
pkg=bold(source_pkg),
fspace=freed_space_str),
min_width=653)
return watcher.request_confirmation(
title=self._i18n['debian.transaction.title'],
components=[body_text, deps_container],
confirmation_label=self._i18n['popup.button.continue'],
deny_label=self._i18n['popup.button.cancel'],
min_height=200,
body=None)
def request_optional_deps(pkgname: str, pkg_mirrors: dict,
watcher: ProcessWatcher, i18n: dict) -> Set[str]:
opts = [
InputOption(
'{}{} ( {} )'.format(p, ': ' + d['desc'] if d['desc'] else '',
d['mirror'].upper()), p)
for p, d in pkg_mirrors.items()
]
view_opts = MultipleSelectComponent(label='',
options=opts,
default_options=None)
install = watcher.request_confirmation(
title=i18n['arch.install.optdeps.request.title'],
body='<p>{}</p>'.format(
i18n['arch.install.optdeps.request.body'].format(bold(pkgname)) +
':'),
components=[view_opts],
confirmation_label=i18n['install'],
deny_label=i18n['cancel'])
if install:
return {o.value for o in view_opts.values}
def _ask_update_permission(self, to_update: List[EnvironmentComponent],
watcher: ProcessWatcher) -> bool:
icon = resource.get_path('img/web.png', ROOT_DIR)
opts = [
InputOption(label='{} ( {} )'.format(f.name, f.size or '?'),
tooltip=f.url,
icon_path=icon,
read_only=True,
value=f.name) for f in to_update
]
comps = MultipleSelectComponent(label=None,
options=opts,
default_options=set(opts))
return watcher.request_confirmation(
title=self.i18n['web.install.env_update.title'],
body=self.i18n['web.install.env_update.body'],
components=[comps],
confirmation_label=self.i18n['continue'].capitalize(),
deny_label=self.i18n['cancel'].capitalize())
def get_settings(self) -> TabGroupComponent:
tabs = list()
gem_opts, def_gem_opts, gem_tabs = [], set(), []
self._settings_views = dict()
for man in self.managers:
can_work, reason_not_work = man.can_work()
modname = man.__module__.split('.')[-2]
man_settings = man.get_settings() if can_work else None
if man_settings:
for view in man_settings:
icon_path = view.icon_path
if not icon_path:
icon_path = f"{ROOT_DIR}/gems/{modname}/resources/img/{modname}.svg"
tab_name = view.label if view.label else self.i18n.get(
f'gem.{modname}.label', modname.capitalize())
gem_tabs.append(
TabComponent(label=tab_name,
content=view.component,
icon_path=icon_path))
views = self._settings_views.get(man.__class__, list())
self._settings_views[man.__class__] = views
views.append(view)
help_tip = reason_not_work if not can_work and reason_not_work else self.i18n.get(
f'gem.{modname}.info')
opt = InputOption(
label=self.i18n.get(f'gem.{modname}.label',
modname.capitalize()),
tooltip=help_tip,
value=modname,
icon_path=
f'{ROOT_DIR}/gems/{modname}/resources/img/{modname}.svg',
read_only=not can_work,
extra_properties={'warning': 'true'} if not can_work else None)
gem_opts.append(opt)
if man.is_enabled() and man in self.working_managers:
def_gem_opts.add(opt)
core_config = self.configman.get_config()
if gem_opts:
type_help = TextComponent(html=self.i18n['core.config.types.tip'])
gem_opts.sort(key=lambda o: o.value)
gem_selector = MultipleSelectComponent(
label=None,
tooltip=None,
options=gem_opts,
max_width=floor(self.context.screen_width * 0.22),
default_options=def_gem_opts,
id_="gems")
tabs.append(
TabComponent(label=self.i18n['core.config.tab.types'],
content=PanelComponent([
type_help,
FormComponent([gem_selector], spaces=False)
]),
id_='core.types'))
tabs.append(self._gen_general_settings(core_config))
tabs.append(self._gen_interface_settings(core_config))
tabs.append(self._gen_tray_settings(core_config))
tabs.append(self._gen_adv_settings(core_config))
bkp_settings = self._gen_backup_settings(core_config)
if bkp_settings:
tabs.append(bkp_settings)
for tab in gem_tabs:
tabs.append(tab)
return TabGroupComponent(tabs)
def _ask_install_options(
self, app: WebApplication,
watcher: ProcessWatcher) -> Tuple[bool, List[str]]:
watcher.change_substatus(self.i18n['web.install.substatus.options'])
inp_url = TextInputComponent(label=self.i18n['address'],
value=app.url,
read_only=True)
inp_name = TextInputComponent(label=self.i18n['name'], value=app.name)
inp_desc = TextInputComponent(label=self.i18n['description'],
value=app.description)
cat_ops = [
InputOption(label=self.i18n['web.install.option.category.none'].
capitalize(),
value=0)
]
cat_ops.extend([
InputOption(label=self.i18n[c.lower()].capitalize(), value=c)
for c in self.context.default_categories
])
def_cat = cat_ops[0]
if app.categories:
for opt in cat_ops:
if opt.value == app.categories[0]:
def_cat = opt
break
inp_cat = SingleSelectComponent(label=self.i18n['category'],
type_=SelectViewType.COMBO,
options=cat_ops,
default_option=def_cat)
tray_op_off = InputOption(
id_='tray_off',
label=self.i18n['web.install.option.tray.off.label'],
value=0,
tooltip=self.i18n['web.install.option.tray.off.tip'])
tray_op_default = InputOption(
id_='tray_def',
label=self.i18n['web.install.option.tray.default.label'],
value='--tray',
tooltip=self.i18n['web.install.option.tray.default.tip'])
tray_op_min = InputOption(
id_='tray_min',
label=self.i18n['web.install.option.tray.min.label'],
value='--tray=start-in-tray',
tooltip=self.i18n['web.install.option.tray.min.tip'])
tray_opts = [tray_op_off, tray_op_default, tray_op_min]
def_tray_opt = None
if app.preset_options:
for opt in tray_opts:
if opt.id in app.preset_options:
def_tray_opt = opt
break
inp_tray = SingleSelectComponent(
type_=SelectViewType.COMBO,
options=tray_opts,
default_option=def_tray_opt,
label=self.i18n['web.install.option.tray.label'])
icon_op_ded = InputOption(
id_='icon_ded',
label=self.i18n['web.install.option.wicon.deducted.label'],
value=0,
tooltip=self.i18n['web.install.option.wicon.deducted.tip'].format(
'Nativefier'))
icon_op_disp = InputOption(
id_='icon_disp',
label=self.i18n['web.install.option.wicon.displayed.label'],
value=1,
tooltip=self.i18n['web.install.option.wicon.displayed.tip'])
inp_icon = SingleSelectComponent(
type_=SelectViewType.COMBO,
options=[icon_op_disp, icon_op_ded],
default_option=icon_op_disp
if app.icon_url and app.save_icon else icon_op_ded,
label=self.i18n['web.install.option.wicon.label'])
icon_chooser = FileChooserComponent(
allowed_extensions={'png', 'svg', 'ico', 'jpg', 'jpeg'},
label=self.i18n['web.install.option.icon.label'])
form_1 = FormComponent(
components=[
inp_url, inp_name, inp_desc, inp_cat, inp_icon, icon_chooser,
inp_tray
],
label=self.i18n['web.install.options.basic'].capitalize())
op_single = InputOption(
id_='single',
label=self.i18n['web.install.option.single.label'],
value="--single-instance",
tooltip=self.i18n['web.install.option.single.tip'])
op_max = InputOption(id_='max',
label=self.i18n['web.install.option.max.label'],
value="--maximize",
tooltip=self.i18n['web.install.option.max.tip'])
op_fs = InputOption(
id_='fullscreen',
label=self.i18n['web.install.option.fullscreen.label'],
value="--full-screen",
tooltip=self.i18n['web.install.option.fullscreen.tip'])
op_nframe = InputOption(
id_='no_frame',
label=self.i18n['web.install.option.noframe.label'],
value="--hide-window-frame",
tooltip=self.i18n['web.install.option.noframe.tip'])
op_allow_urls = InputOption(
id_='allow_urls',
label=self.i18n['web.install.option.allow_urls.label'],
value='--internal-urls=.*',
tooltip=self.i18n['web.install.option.allow_urls.tip'])
op_ncache = InputOption(
id_='no_cache',
label=self.i18n['web.install.option.nocache.label'],
value="--clear-cache",
tooltip=self.i18n['web.install.option.nocache.tip'])
op_insecure = InputOption(
id_='insecure',
label=self.i18n['web.install.option.insecure.label'],
value="--insecure",
tooltip=self.i18n['web.install.option.insecure.tip'])
op_igcert = InputOption(
id_='ignore_certs',
label=self.i18n['web.install.option.ignore_certificate.label'],
value="--ignore-certificate",
tooltip=self.i18n['web.install.option.ignore_certificate.tip'])
adv_opts = [
op_single, op_allow_urls, op_max, op_fs, op_nframe, op_ncache,
op_insecure, op_igcert
]
def_adv_opts = {op_single, op_allow_urls}
if app.preset_options:
for opt in adv_opts:
if opt.id in app.preset_options:
def_adv_opts.add(opt)
check_options = MultipleSelectComponent(
options=adv_opts,
default_options=def_adv_opts,
label=self.i18n['web.install.options.advanced'].capitalize())
res = watcher.request_confirmation(
title=self.i18n['web.install.options_dialog.title'],
body=None,
components=[form_1, check_options],
confirmation_label=self.i18n['continue'].capitalize(),
deny_label=self.i18n['cancel'].capitalize())
if res:
selected = []
if check_options.values:
selected.extend(check_options.get_selected_values())
tray_mode = inp_tray.get_selected()
if tray_mode is not None and tray_mode != 0:
selected.append(tray_mode)
custom_name = inp_name.get_value()
if custom_name:
app.name = custom_name
custom_desc = inp_desc.get_value()
if custom_desc:
app.description = inp_desc.get_value()
cat = inp_cat.get_selected()
if cat != 0:
app.categories = [cat]
if icon_chooser.file_path:
app.set_custom_icon(icon_chooser.file_path)
selected.append('--icon={}'.format(icon_chooser.file_path))
app.save_icon = inp_icon.value == icon_op_disp
return res, selected
return False, []
def __init__(self,
window: QWidget,
manager: GenericSoftwareManager,
i18n: dict,
config: Configuration,
show_panel_after_restart: bool = False):
super(GemSelectorPanel, self).__init__()
self.window = window
self.manager = manager
self.config = config
self.setLayout(QGridLayout())
self.setWindowIcon(QIcon(resource.get_path('img/logo.svg')))
self.setWindowTitle(i18n['gem_selector.title'])
self.resize(400, 400)
self.show_panel_after_restart = show_panel_after_restart
self.label_question = QLabel(i18n['gem_selector.question'])
self.label_question.setStyleSheet('QLabel { font-weight: bold}')
self.layout().addWidget(self.label_question, 0, 1, Qt.AlignHCenter)
self.bt_proceed = QPushButton(i18n['change'].capitalize())
self.bt_proceed.setStyleSheet(css.OK_BUTTON)
self.bt_proceed.clicked.connect(self.save)
self.bt_exit = QPushButton(i18n['exit'].capitalize())
self.bt_exit.clicked.connect(self.exit)
self.gem_map = {}
gem_options = []
default = set()
for m in manager.managers:
if m.can_work():
modname = m.__module__.split('.')[-2]
op = InputOption(
label=i18n.get('gem.{}.label'.format(modname),
modname.capitalize()),
tooltip=i18n.get('gem.{}.info'.format(modname)),
value=modname,
icon_path='{r}/gems/{n}/resources/img/{n}.png'.format(
r=ROOT_DIR, n=modname))
gem_options.append(op)
self.gem_map[modname] = m
if m.is_enabled() and m in manager.working_managers:
default.add(op)
if self.config.enabled_gems:
default_ops = {
o
for o in gem_options if o.value in self.config.enabled_gems
}
else:
default_ops = default
self.bt_proceed.setEnabled(bool(default_ops))
self.gem_select_model = MultipleSelectComponent(
label='',
options=gem_options,
default_options=default_ops,
max_per_line=3)
self.gem_select = MultipleSelectQt(self.gem_select_model,
self.check_state)
self.layout().addWidget(self.gem_select, 1, 1)
self.layout().addWidget(new_spacer(), 2, 1)
self.layout().addWidget(self.bt_proceed, 3, 1, Qt.AlignRight)
self.layout().addWidget(self.bt_exit, 3, 1, Qt.AlignLeft)
self.adjustSize()
self.setFixedSize(self.size())
qt_utils.centralize(self)
