Пример #1
0
    def _gen_tray_settings(self, core_config: dict, screen_width: int, screen_height: int) -> TabComponent:
        default_width = floor(0.22 * screen_width)

        input_update_interval = TextInputComponent(label=self.i18n['core.config.updates.interval'].capitalize(),
                                                   tooltip=self.i18n['core.config.updates.interval.tip'],
                                                   only_int=True,
                                                   value=str(core_config['updates']['check_interval']),
                                                   max_width=default_width,
                                                   id_="updates_interval")

        allowed_exts = {'png', 'svg', 'jpg', 'jpeg', 'ico', 'xpm'}
        select_def_icon = FileChooserComponent(id_='def_icon',
                                               label=self.i18n["core.config.ui.tray.default_icon"].capitalize(),
                                               tooltip=self.i18n["core.config.ui.tray.default_icon.tip"].capitalize(),
                                               file_path=str(core_config['ui']['tray']['default_icon']) if core_config['ui']['tray']['default_icon'] else None,
                                               max_width=default_width,
                                               allowed_extensions=allowed_exts)

        select_up_icon = FileChooserComponent(id_='up_icon',
                                              label=self.i18n["core.config.ui.tray.updates_icon"].capitalize(),
                                              tooltip=self.i18n["core.config.ui.tray.updates_icon.tip"].capitalize(),
                                              file_path=str(core_config['ui']['tray']['updates_icon']) if core_config['ui']['tray']['updates_icon'] else None,
                                              max_width=default_width,
                                              allowed_extensions=allowed_exts)

        sub_comps = [FormComponent([input_update_interval, select_def_icon, select_up_icon], spaces=False)]
        return TabComponent(self.i18n['core.config.tab.tray'].capitalize(), PanelComponent(sub_comps), None, 'core.tray')
Пример #2
0
    def update_file(self, pkg: AppImage, root_password: Optional[str], watcher: ProcessWatcher):
        max_width = 350
        file_chooser = FileChooserComponent(label=self.i18n['file'].capitalize(),
                                            allowed_extensions={'AppImage', '*'},
                                            search_path=get_default_manual_installation_file_dir(),
                                            max_width=max_width)
        input_version = TextInputComponent(label=self.i18n['version'].capitalize(), max_width=max_width)
        file_chooser.observers.append(ManualInstallationFileObserver(None, input_version))

        while True:
            if watcher.request_confirmation(title=self.i18n['appimage.custom_action.manual_update.details'], body=None,
                                            components=[FormComponent(label='', components=[file_chooser, input_version], spaces=False)],
                                            confirmation_label=self.i18n['proceed'].capitalize(),
                                            deny_label=self.i18n['cancel'].capitalize(),
                                            min_height=100, max_width=max_width + 150):

                if not file_chooser.file_path or not os.path.isfile(file_chooser.file_path) or not file_chooser.file_path.lower().strip().endswith('.appimage'):
                    watcher.request_confirmation(title=self.i18n['error'].capitalize(),
                                                 body=self.i18n['appimage.custom_action.install_file.invalid_file'],
                                                 deny_button=False)
                else:
                    break
            else:
                return False

        pkg.local_file_path = file_chooser.file_path
        pkg.version = input_version.get_value()

        reqs = UpgradeRequirements(to_install=None, to_remove=None, to_upgrade=[UpgradeRequirement(pkg=pkg)], cannot_upgrade=None)
        return self.upgrade(reqs, root_password=root_password, watcher=watcher)
Пример #3
0
    def install_file(self, root_password: Optional[str], watcher: ProcessWatcher) -> bool:
        max_width = 350
        file_chooser = FileChooserComponent(label=self.i18n['file'].capitalize(),
                                            allowed_extensions={'AppImage', '*'},
                                            search_path=get_default_manual_installation_file_dir(),
                                            max_width=max_width)
        input_name = TextInputComponent(label=self.i18n['name'].capitalize(), max_width=max_width)
        input_version = TextInputComponent(label=self.i18n['version'].capitalize(), max_width=max_width)
        file_chooser.observers.append(ManualInstallationFileObserver(input_name, input_version))

        input_description = TextInputComponent(label=self.i18n['description'].capitalize(), max_width=max_width)

        cat_ops = [InputOption(label=self.i18n['category.none'].capitalize(), value=0)]
        cat_ops.extend([InputOption(label=self.i18n.get(f'category.{c.lower()}', c.lower()).capitalize(), value=c) for c in self.context.default_categories])
        inp_cat = SingleSelectComponent(label=self.i18n['category'], type_=SelectViewType.COMBO, options=cat_ops,
                                        default_option=cat_ops[0], max_width=max_width)

        form = FormComponent(label='', components=[file_chooser, input_name, input_version, input_description, inp_cat],
                             spaces=False)

        while True:
            if watcher.request_confirmation(title=self.i18n['appimage.custom_action.install_file.details'], body=None,
                                            components=[form],
                                            confirmation_label=self.i18n['proceed'].capitalize(),
                                            deny_label=self.i18n['cancel'].capitalize(),
                                            min_height=100, max_width=max_width + 150):
                if not file_chooser.file_path or not os.path.isfile(file_chooser.file_path) or not file_chooser.file_path.lower().strip().endswith('.appimage'):
                    watcher.request_confirmation(title=self.i18n['error'].capitalize(),
                                                 body=self.i18n['appimage.custom_action.install_file.invalid_file'],
                                                 deny_button=False)
                elif not input_name.get_value() or not input_name.get_value().strip():
                    watcher.request_confirmation(title=self.i18n['error'].capitalize(),
                                                 body=self.i18n['appimage.custom_action.install_file.invalid_name'],
                                                 deny_button=False)
                else:
                    break
            else:
                return False

        appim = AppImage(i18n=self.i18n, imported=True)
        appim.name = input_name.get_value().strip()
        appim.local_file_path = file_chooser.file_path
        appim.version = input_version.get_value()
        appim.latest_version = input_version.get_value()
        appim.description = input_description.get_value()
        appim.categories = ['Imported']

        if inp_cat.get_selected() != cat_ops[0].value:
            appim.categories.append(inp_cat.get_selected())

        res = self.install(root_password=root_password, pkg=appim, disk_loader=None, watcher=watcher).success

        if res:
            appim.installed = True
            self.cache_to_disk(appim, None, False)

        return res
Пример #4
0
    def update_file(self, pkg: AppImage, root_password: str,
                    watcher: ProcessWatcher):
        file_chooser = FileChooserComponent(
            label=self.i18n['file'].capitalize(),
            allowed_extensions={'AppImage'})
        input_version = TextInputComponent(
            label=self.i18n['version'].capitalize())

        while True:
            if watcher.request_confirmation(
                    title=self.
                    i18n['appimage.custom_action.manual_update.details'],
                    body=None,
                    components=[
                        FormComponent(label='',
                                      components=[file_chooser, input_version],
                                      spaces=False)
                    ],
                    confirmation_label=self.i18n['proceed'].capitalize(),
                    deny_label=self.i18n['cancel'].capitalize()):
                if not file_chooser.file_path or not os.path.isfile(
                        file_chooser.file_path):
                    watcher.request_confirmation(
                        title=self.i18n['error'].capitalize(),
                        body=self.i18n[
                            'appimage.custom_action.install_file.invalid_file'],
                        deny_button=False)
                else:
                    break
            else:
                return False

        pkg.local_file_path = file_chooser.file_path
        pkg.version = input_version.get_value()

        reqs = UpgradeRequirements(to_install=None,
                                   to_remove=None,
                                   to_upgrade=[UpgradeRequirement(pkg=pkg)],
                                   cannot_upgrade=None)
        return self.upgrade(reqs, root_password=root_password, watcher=watcher)
Пример #5
0
    def install_file(self, root_password: str,
                     watcher: ProcessWatcher) -> bool:
        file_chooser = FileChooserComponent(
            label=self.i18n['file'].capitalize(),
            allowed_extensions={'AppImage'})
        input_name = TextInputComponent(label=self.i18n['name'].capitalize())
        input_version = TextInputComponent(
            label=self.i18n['version'].capitalize())
        input_description = TextInputComponent(
            label=self.i18n['description'].capitalize())

        cat_ops = [
            InputOption(label=self.i18n['category.none'].capitalize(), value=0)
        ]
        cat_ops.extend([
            InputOption(label=self.i18n[c.lower()].capitalize(), value=c)
            for c in self.context.default_categories
        ])
        inp_cat = SingleSelectComponent(label=self.i18n['category'],
                                        type_=SelectViewType.COMBO,
                                        options=cat_ops,
                                        default_option=cat_ops[0])

        form = FormComponent(label='',
                             components=[
                                 file_chooser, input_name, input_version,
                                 input_description, inp_cat
                             ],
                             spaces=False)

        while True:
            if watcher.request_confirmation(
                    title=self.
                    i18n['appimage.custom_action.install_file.details'],
                    body=None,
                    components=[form],
                    confirmation_label=self.i18n['proceed'].capitalize(),
                    deny_label=self.i18n['cancel'].capitalize()):
                if not file_chooser.file_path or not os.path.isfile(
                        file_chooser.file_path):
                    watcher.request_confirmation(
                        title=self.i18n['error'].capitalize(),
                        body=self.i18n[
                            'appimage.custom_action.install_file.invalid_file'],
                        deny_button=False)
                elif not input_name.get_value() or not input_name.get_value(
                ).strip():
                    watcher.request_confirmation(
                        title=self.i18n['error'].capitalize(),
                        body=self.i18n[
                            'appimage.custom_action.install_file.invalid_name'],
                        deny_button=False)
                else:
                    break
            else:
                return False

        appim = AppImage(i18n=self.i18n,
                         imported=True,
                         custom_actions=self.custom_app_actions)
        appim.name = input_name.get_value().strip()
        appim.local_file_path = file_chooser.file_path
        appim.version = input_version.get_value()
        appim.latest_version = input_version.get_value()
        appim.description = input_description.get_value()
        appim.categories = ['Imported']

        if inp_cat.get_selected() != cat_ops[0].value:
            appim.categories.append(inp_cat.get_selected())

        installed = self.install(root_password=root_password,
                                 pkg=appim,
                                 watcher=watcher)

        if installed:
            appim.installed = True
            self.cache_to_disk(appim, None, False)

        return installed
Пример #6
0
    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, []