Exemple #1
0
 def add_item(self, item: QtGui.QTreeWidgetItem) -> None:
     if self.max_number is not None and self.topLevelItemCount() >= self.max_number:
         warning(_('Unable to add item'), _('Unable to add more than %(s)d items.') % {'s': self.max_number},
                 only_ok=True)
         return
     index = self.indexOfTopLevelItem(item)
     self.insert_item(values={}, index=index)
Exemple #2
0
 def remove_item(self, item: QtGui.QTreeWidgetItem) -> None:
     if self.min_number is not None and self.topLevelItemCount() <= self.min_number:
         warning(_('Unable to remove item'), _('At least %(s)d items are required.') % {'s': self.min_number},
                 only_ok=True)
         return
     index = self.indexOfTopLevelItem(item)
     self.takeTopLevelItem(index)
Exemple #3
0
 def check_base_type(self, value):
     if not isinstance(value, dict):
         raise InvalidValueException(_('Value must be a dict of standard JSON types'))
     try:
         json.dumps(value)
     except TypeError:
         raise InvalidValueException(_('Value must be a dict of standard JSON types'))
Exemple #4
0
 def check_base_type(self, value):
     if not isinstance(value, list) and not isinstance(value, tuple):
         raise InvalidValueException(_('Value must be a list or tuple of base JSON types'))
     if self.base_type in (str, int, float, bool):
         pass
     try:
         json.dumps(value)
     except TypeError:
         raise InvalidValueException(_('Value must be a list of base JSON types'))
Exemple #5
0
 def base_open_recent(self):
     actions = []
     seen_basefilenames = set()
     for filename in application.GlobalInfos.last_documents:
         if not os.path.isfile(filename):
             continue
         basename = os.path.basename(filename)
         if basename in seen_basefilenames:
             basename = filename
         seen_basefilenames.add(basename)
         actions.append(MenuAction(functools.partial(self.base_open_document, filename),
                                   _('Open %(name)s') % {'name': basename}, _('File')))
     return actions
Exemple #6
0
 def __init__(self, verbose_name='', help_text=None, default=None, disabled=False, validators=None,
              choices=None, on_change=None):
     super().__init__(verbose_name=verbose_name, help_text=help_text, disabled=disabled, validators=validators,
                      default=default, on_change=on_change)
     if choices is None:
         raise InvalidValueException(_('You must provide a list of tuples for ‘choices’ argument.'))
     self.choices = choices
Exemple #7
0
 def __init__(self, *args, **kwargs):
     QtGui.QLineEdit.__init__(self, *args, **kwargs)
     self.setPlaceholderText(_("Search…"))
     self.setStyleSheet(
         "QLineEdit { padding: 2px; border-radius: 9px; border-color: #8e8e8e; };"
         "QLineEdit:focus { padding: 2px; border-radius: 9px; };"
     )
Exemple #8
0
    def __init__(self, args: list):
        super().__init__()
        self.load()  # load preferences

        # initialize QtApplication
        self.application = QtGui.QApplication(args)
        self.parent = QtGui.QWidget()
        global_dict[application_key] = self
        # initialize thread pool executor
        self.executor = QtCore.QThreadPool()
        self.executor.setMaxThreadCount(self.GlobalInfos.pool_thread_size)

        # set some global stuff
        if self.description_icon:
            self.application.setWindowIcon(get_icon(self.description_icon))
        if self.verbose_name:
            self.application.setApplicationName(str(self.verbose_name))
        if self.application_version:
            self.application.setApplicationVersion(self.application_version)
        if self.systemtray_icon:
            self._parent_obj = QtGui.QWidget()
            self.systray = QtGui.QSystemTrayIcon(get_icon(self.systemtray_icon), self._parent_obj)
            self.systray.setVisible(True)
            self.systray.show()

            # retrieve menu and associated actions for the whole class hierarchy
            created_action_keys = set()
            menu = None
            for qualname in self.__class__.__mro__:
                cls_name = qualname.__name__.rpartition('.')[2]
                if cls_name not in registered_menus:
                    continue
                for menu_action in registered_menu_actions[cls_name]:
                    if menu is None:
                        menu = QtGui.QMenu(self.verbose_name, self._parent_obj)
                    if menu_action.uid in created_action_keys:  # skip overriden actions (there are already created)
                        continue
                    created_action_keys.add(menu_action.uid)
                    menu_action.create(self, menu)
            if menu is not None:
                self.systray.setContextMenu(menu)
            # noinspection PyUnresolvedReferences
            self.systray.activated.connect(self.systray_activated)
            # noinspection PyUnresolvedReferences
            self.systray.messageClicked.connect(self.systray_message_clicked)
        if self.splashscreen_icon:
            self.splashscreen = QtGui.QSplashScreen(self.parent, get_pixmap(self.splashscreen_icon),
                                                    QtCore.Qt.WindowStaysOnTopHint)
            self.splashscreen.showMessage(_('Loading data…'))
            self.splashscreen.show()

        # noinspection PyUnresolvedReferences
        self.application.lastWindowClosed.connect(self.save)
        self.load_data()
        if self.splashscreen is not None:
            self.splashscreen.hide()
Exemple #9
0
 def __init__(self, filename: str = None, selection_filter: str = None, parent: QtGui.QWidget = None):
     self.selection_filter = selection_filter
     self.filename = None
     super().__init__(parent)
     self.select_button = create_button(
         _("Choose a file…"), min_size=True, connect=self.select_file, icon="edit-find"
     )
     self.line_editor = QtGui.QLineEdit(p(self))
     self.set_value(filename)
     layout = h_layout(self, self.select_button, self.line_editor)
     self.setLayout(layout)
     self.adjustSize()
Exemple #10
0
 def __init__(self, message, parent=None):
     super().__init__(p(parent))
     widgets = []
     if application.splashscreen_icon:
         pixmap = get_pixmap(application.splashscreen_icon)
         label = QtGui.QLabel(p(self))
         label.setPixmap(pixmap)
         widgets.append(label)
         edit = QtGui.QTextEdit(message, self)
         edit.setReadOnly(True)
         widgets.append(edit)
     widgets.append(create_button(_('Close'), min_size=True, parent=self, connect=self.close))
     self.setLayout(v_layout(self, *widgets))
Exemple #11
0
    def select_file(self):
        try:
            from qthelpers.application import application

            dirname = application.GlobalInfos.last_open_folder
        except AttributeError:
            dirname = os.path.expanduser("~")
        # noinspection PyTypeChecker
        filename, selected_filter = QtGui.QFileDialog.getOpenFileName(
            p(self), _("Select a file"), dirname, self.selection_filter, "", 0
        )
        if filename:
            self.set_value(filename)
Exemple #12
0
 def base_open_document(self, filename=None):
     if self._base_check_is_modified():
         return False
     if not filename:
         # noinspection PyCallByClass
         (filename, selected_filter) = QtGui.QFileDialog.getOpenFileName(p(self), _('Please select a file'),
                                                                         application.GlobalInfos.last_open_folder,
                                                                         self.document_known_extensions)
         if not filename:
             return False
         application.GlobalInfos.last_open_folder = os.path.dirname(filename)
     if not self.is_valid_document(filename):
         warning(_('Invalid document'), _('Unable to open document %(filename)s.') %
                 {'filename': os.path.basename(filename)},
                 only_ok=True)
         return False
     self.unload_document()
     self.current_document_filename = filename
     self.current_document_is_modified = False
     self.base_window_title()
     self.base_add_recent_filename()
     self.load_document()
     return True
Exemple #13
0
 def __init__(self, color: str = None, parent: QtGui.QWidget = None):
     self.color = None
     super().__init__(parent)
     self.select_button = create_button(
         _("Choose a color…"), min_size=True, connect=self.select_color, icon="preferences-color"
     )
     self.line_editor = QtGui.QLineEdit(p(self))
     self.line_editor.setValidator(self.validator)
     if not color or not COLOR_RE.match(color):
         color = None
     self.set_value(color)
     layout = h_layout(self, self.select_button, self.line_editor)
     self.setLayout(layout)
     self.adjustSize()
Exemple #14
0
 def base_save_document_as(self):
     # noinspection PyCallByClass
     (filename, selected_filter) = QtGui.QFileDialog.getSaveFileName(p(self), _('Please choose a name'),
                                                                     application.GlobalInfos.last_save_folder,
                                                                     filter=self.document_known_extensions)
     if not filename:
         return False
     application.GlobalInfos.last_save_folder = os.path.dirname(filename)
     self.current_document_filename = filename
     if self.save_document():
         self.current_document_is_modified = False
         self.base_window_title()
         self.base_add_recent_filename()
         return True
     return False
Exemple #15
0
 def check_base_type(self, value):
     if value is None or isinstance(value, float):
         return
     raise InvalidValueException(_('value must be a float'))
Exemple #16
0
 def _base_check_is_modified(self):
     return self.current_document_is_modified and not warning(_('The document has been modified'),
                                                              _('The current document has been modified. '
                                                              'Any change will be lost if you close it. '
                                                              'Do you really want to continue?'))
Exemple #17
0
 def check_base_type(self, value):
     try:
         json.dumps(value)
     except TypeError:
         raise InvalidValueException(_('Value must be a list of base JSON types'))
Exemple #18
0
 def valid_max(value):
     if value is not None and len(value) > max_length:
         raise InvalidValueException(_('list must count at most %(m)d values') % {'m': min_length})
Exemple #19
0
 def check_required(value):
     if value is None:
         raise InvalidValueException(_('no value provided'))
Exemple #20
0
 def valid_max(value):
     if value is not None and len(value) > max_length:
         raise InvalidValueException(_('value must be at most %(m)d character long') % {'m': min_length})
Exemple #21
0
 def valid_max(value):
     if value is not None and value > max_value:
         raise InvalidValueException(_('value must be smaller than %(m)d') % {'m': max_value})
Exemple #22
0
 def valid_min(value):
     if value is not None and value < min_value:
         raise InvalidValueException(_('value must be greater than %(m)d') % {'m': min_value})
Exemple #23
0
 def check_base_type(self, value):
     if isinstance(value, str):
         return
     raise InvalidValueException(_('value must be a string'))
Exemple #24
0
    def __init__(self, parent=None):
        QtGui.QMainWindow.__init__(self, p(parent))
        ThreadedCalls.__init__(self)

        self._window_id = next(BaseMainWindow._window_counter)
        self._docks = {}
        application.windows[self._window_id] = self

        # retrieve menus and associated actions from the whole class hierarchy
        menubar = self.menuBar()
        defined_qmenus = {}
        created_action_keys = set()
        supernames = [x.__name__.rpartition('.')[2] for x in self.__class__.__mro__]
        supernames.reverse()
        for menu_name in self.menus:
            defined_qmenus[menu_name] = menubar.addMenu(menu_name)
        for cls_name in supernames:
            for menu_name in registered_menus.get(cls_name, []):  # create all top-level menus
                if menu_name not in defined_qmenus:
                    defined_qmenus[menu_name] = menubar.addMenu(menu_name)
        supernames.reverse()
        for cls_name in supernames:
            for menu_action in registered_menu_actions.get(cls_name, []):
                if menu_action.uid in created_action_keys:  # skip overriden actions (there are already created)
                    continue
                created_action_keys.add(menu_action.uid)
                menu_action.create(self, defined_qmenus[menu_action.menu])

        # retrieve toolbar actions from the whole class hierarchy
        self.setUnifiedTitleAndToolBarOnMac(True)
        defined_qtoolbars = {}
        created_action_keys = set()
        for superclass in self.__class__.__mro__:
            cls_name = superclass.__name__.rpartition('.')[2]
            if cls_name not in registered_toolbars:
                continue
            for toolbar_name in registered_toolbars[cls_name]:  # create all top-level menus
                if toolbar_name not in defined_qtoolbars:
                    if toolbar_name is not None:
                        defined_qtoolbars[toolbar_name] = BaseToolBar(toolbar_name, p(self))
                    else:
                        defined_qtoolbars[toolbar_name] = BaseToolBar(_('Toolbar'), p(self))
                    self.addToolBar(defined_qtoolbars[toolbar_name])
            for toolbar_action in registered_toolbar_actions[cls_name]:
                if toolbar_action.uid in created_action_keys:  # skip overriden actions (there are already created)
                    continue
                created_action_keys.add(toolbar_action.uid)
                toolbar_action.create(self, defined_qtoolbars[toolbar_action.toolbar])

        # create all dock widgets
        for dock_cls in self.docks:
            """:type dock_cls: type"""
            if not isinstance(dock_cls, type) or not issubclass(dock_cls, BaseDock):
                continue
            dock = dock_cls(parent=self)
            """:type dock: BaseDock"""
            self._docks[dock_cls] = dock
            self.addDockWidget(dock.default_position, dock)
            menu_name = dock.menu
            if menu_name is not None:
                if menu_name not in defined_qmenus:
                    defined_qmenus[menu_name] = menubar.addMenu(menu_name)
                    connect = functools.partial(self._base_swap_dock_display, dock_cls)
                    action = MenuAction(connect, verbose_name=dock.verbose_name, menu=menu_name, shortcut=dock.shortcut)
                    action.create(self, defined_qmenus[menu_name])

        # some extra stuff
        self.setWindowTitle(self.verbose_name)
        if self.description_icon:
            self.setWindowIcon(get_icon(self.description_icon))

        self.setCentralWidget(self.central_widget())
        # restore state and geometry
        # noinspection PyBroadException
        self.adjustSize()
        try:
            cls_name = self.__class__.__name__
            if cls_name in application['GlobalInfos/main_window_geometries']:
                geometry_str = application['GlobalInfos/main_window_geometries'][cls_name].encode('utf-8')
                geometry = base64.b64decode(geometry_str)
                self.restoreGeometry(geometry)
            if cls_name in application['GlobalInfos/main_window_states']:
                state_str = application['GlobalInfos/main_window_states'][cls_name].encode('utf-8')
                state = base64.b64decode(state_str)
                self.restoreState(state)
        except ValueError:
            pass
        self.raise_()
Exemple #25
0
 def check_base_type(self, value):
     if not isinstance(value, bool):
         raise InvalidValueException(_('Value must be a boolean'))