pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/services/file_dialog.py

@@ -0,0 +1,71 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from os import path
+
+from PyQt5.QtCore import QStandardPaths, QTimer
+from PyQt5.QtWidgets import QFileDialog
+
+from .event_registry import EventTypes
+
+class FileDialogService:
+    def __init__(self, project_manager, application_configuration, event_registry):
+        self._project_manager = project_manager
+        self._application_configuration = application_configuration
+        self._event_registry = event_registry
+
+    def _get_dialog(self, parent, filter_, default_directory=None):
+        dialog = QFileDialog(
+            parent,
+            directory=default_directory or self._get_default_directory(),
+            filter=filter_
+        )
+        def _notify_save_dialog_finished(result):
+            self._event_registry.event(EventTypes.save_dialog_finished).emit(result)
+        dialog.finished.connect(_notify_save_dialog_finished)
+        return dialog
+
+    def get_save_filename(self, parent, filter_, default_name=None):
+        default_directory = path.dirname(default_name) if default_name else None
+        dialog = self._get_dialog(parent, filter_, default_directory)
+
+        if default_name:
+            dialog.selectFile(default_name)
+        dialog.setModal(True)
+        dialog.setAcceptMode(QFileDialog.AcceptSave)
+        if dialog.exec_() != QFileDialog.Accepted or not dialog.selectedFiles():
+            return None
+        return dialog.selectedFiles()[0]
+    
+    def get_open_filename(self, parent, filter_, file_mode=None):
+        dialog = self._get_dialog(parent, filter_)
+        if file_mode:
+            dialog.setFileMode(file_mode)
+        if dialog.exec_():
+            return dialog.selectedFiles()[0]
+        else:
+            return None
+    
+    def _get_default_directory(self):
+        if not self._project_manager.filename:
+            default_location = self._application_configuration.get_value('application.default_directory')
+            if default_location and path.isdir(default_location):
+                return default_location
+            return QStandardPaths.writableLocation(QStandardPaths.DocumentsLocation)
+        elif self._project_manager.filename and not path.isdir(path.dirname(self._project_manager.filename)):
+            return QStandardPaths.writableLocation(QStandardPaths.DocumentsLocation)
+        else:
+            return path.dirname(self._project_manager.filename)

pyqttoolkit/services/hotkey_manager.py

@@ -0,0 +1,137 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum
+
+from PyQt5.QtCore import Qt
+
+class HotkeyEvents(Enum):
+    next_instance_y = 0
+    previous_instance_y = 1
+    next_instance_x = 2
+    previous_instance_x = 3
+    next_t = 4
+    previous_t = 5
+    zoom_in = 6
+    zoom_out = 7
+
+class HotkeyManager:
+    keymap = {
+        Qt.Key_0: '0',
+        Qt.Key_1: '1',
+        Qt.Key_2: '2',
+        Qt.Key_3: '3',
+        Qt.Key_4: '4',
+        Qt.Key_5: '5',
+        Qt.Key_6: '6',
+        Qt.Key_7: '7',
+        Qt.Key_8: '8',
+        Qt.Key_9: '9',
+        Qt.Key_A: 'a',
+        Qt.Key_B: 'b',
+        Qt.Key_C: 'c',
+        Qt.Key_D: 'd',
+        Qt.Key_E: 'e',
+        Qt.Key_F: 'f',
+        Qt.Key_G: 'g',
+        Qt.Key_H: 'h',
+        Qt.Key_I: 'i',
+        Qt.Key_J: 'j',
+        Qt.Key_K: 'k',
+        Qt.Key_L: 'l',
+        Qt.Key_M: 'm',
+        Qt.Key_N: 'n',
+        Qt.Key_O: 'o',
+        Qt.Key_P: 'p',
+        Qt.Key_Q: 'q',
+        Qt.Key_R: 'r',
+        Qt.Key_S: 's',
+        Qt.Key_T: 't',
+        Qt.Key_U: 'u',
+        Qt.Key_V: 'v',
+        Qt.Key_W: 'w',
+        Qt.Key_X: 'x',
+        Qt.Key_Y: 'y',
+        Qt.Key_Z: 'z',
+        Qt.Key_BraceLeft: '{',
+        Qt.Key_BraceRight: '}',
+        Qt.Key_BracketLeft: '[',
+        Qt.Key_BracketRight: ']',
+        Qt.Key_Colon: ':',
+        Qt.Key_Semicolon: ';',
+        Qt.Key_Greater: '>',
+        Qt.Key_Less: '<',
+        Qt.Key_Comma: ',',
+        Qt.Key_Period: '.',
+        Qt.Key_Space: '<space>',
+        Qt.Key_Up: '<up>',
+        Qt.Key_Down: '<down>',
+        Qt.Key_Left: '<left>',
+        Qt.Key_Right: '<right>',
+        Qt.Key_Backslash: '\\',
+    }
+
+    defaults = {
+        HotkeyEvents.next_instance_y: 'w',
+        HotkeyEvents.previous_instance_y: 's',
+        HotkeyEvents.next_instance_x: 'shift+w',
+        HotkeyEvents.previous_instance_x: 'shift+s',
+        HotkeyEvents.next_t: 'd',
+        HotkeyEvents.previous_t: 'a',
+        HotkeyEvents.zoom_in: 'e',
+        HotkeyEvents.zoom_out: 'q'
+    }
+
+    def __init__(self, application_configuration):
+        self._application_configuration = application_configuration
+        self._cached_configuration = self._get_configuration()
+
+    def get_default_keystring(self, event):
+        return self.defaults[event]
+
+    def keyevent_to_string(self, event):
+        key = self.keymap.get(event.key())
+        if not key:
+            return None
+        modifiers = []
+        if Qt.ShiftModifier & event.modifiers():
+            modifiers.append('shift')
+        if Qt.ControlModifier & event.modifiers():
+            modifiers.append('control')
+        if Qt.AltModifier & event.modifiers():
+            modifiers.append('alt')
+        return '+'.join(modifiers + [key])
+
+    def assign_keystring(self, event, keystring):
+        path = f'application.hotkeys.{event.name}'
+        self._application_configuration.set_value(path, keystring)
+        self._cached_configuration = self._get_configuration()
+    
+    def get_keystring(self, event):
+        return self._cached_configuration.get(event.name) or self.get_default_keystring(event)
+
+    def handle_event(self, event, handlers):
+        keystring = self.keyevent_to_string(event)
+        if not keystring:
+            return False
+        for hotkey_event in HotkeyEvents:
+            if self.get_keystring(hotkey_event) == keystring and handlers.get(hotkey_event):
+                handlers.get(hotkey_event)()
+                return True
+        return False
+
+    def _get_configuration(self):
+        return self._application_configuration.get_value('application.hotkeys') or {}

pyqttoolkit/services/link_manager.py

@@ -0,0 +1,135 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import Qt, QObject
+from PyQt5.QtGui import QColor, QPalette
+
+from pyqttoolkit.views import ModuleWindow
+from . import MessageType
+from ..colors import rgb_to_hex
+
+class IncompatibleWidgets(Exception):
+    def __init__(self):
+        Exception.__init__(self)
+
+class LinkManager(QObject):
+    def __init__(self, parent, message_board, color_selection):
+        QObject.__init__(self, parent)
+        self._message_board = message_board
+        self._current_widget = None
+        self._color_count = 10
+        self._selecting_color = (220/255, 240/255, 247/255)
+        self._colors = color_selection.colors(self._color_count)
+        self._link_count = 0
+        self._link_groups = []
+    
+    def request_link(self, widget):
+        if self._current_widget is None:
+            self._current_widget = widget
+            self._set_background_color(widget, self._selecting_color)
+        elif self._current_widget == widget:
+            current_group = self._current_link_group(widget)
+            if current_group is not None:
+                self._remove_widget_from_group(widget, current_group)
+            self._set_background_color(widget, None)
+            self._current_widget = None
+        else:
+            self._update_link(widget)
+            self._current_widget = None
+    
+    def _update_link(self, widget):
+        try:
+            current_group = self._current_link_group(self._current_widget)
+            if current_group is not None:
+                if widget in current_group['widgets']:
+                    self._remove_widget_from_group(widget, current_group)
+                else:
+                    self._add_widget_to_group(widget, current_group)
+            else:
+                other_group = self._current_link_group(widget)
+                if other_group is not None:
+                    self._add_widget_to_group(self._current_widget, other_group)
+                else:
+                    self._create_new_group(self._current_widget, widget)
+        except IncompatibleWidgets:
+            self._message_board.post(MessageType.validation_error, self.tr('It is not possible to link these controls'))
+            self._set_background_color(self._current_widget, current_group and current_group['color'])
+    
+    def _current_link_group(self, widget):
+        for group in self._link_groups:
+            if widget in group['widgets']:
+                return group
+        return None
+
+    def _create_new_group(self, from_widget, to_widget):
+        from_widget.link(to_widget)
+        group = {
+            'widgets': [],
+            'color': self._colors[self._link_count % self._color_count]
+        }
+        self._add_widget_to_group(from_widget, group, link=False)
+        self._add_widget_to_group(to_widget, group, link=False)
+        self._link_count += 1
+        self._link_groups.append(group)
+    
+    def _add_widget_to_group(self, widget, group, link=True):
+        existing_group = self._current_link_group(widget)
+        if existing_group == group:
+            return
+        if existing_group is not None:
+            self._remove_widget_from_group(widget, existing_group)
+        if link:
+            for w in group['widgets']:
+                w.link(widget)
+        group['widgets'].append(widget)
+        self._get_module_window(widget).closing.connect(lambda _: self._remove_widget_from_group(widget, group))
+        for w in group['widgets']:
+            self._set_background_color(w, group['color'])
+    
+    def _remove_widget_from_group(self, widget, group):
+        if group not in self._link_groups or widget not in group['widgets']:
+            return
+        group['widgets'].remove(widget)
+        for w in group['widgets']:
+            w.unlink(widget)
+        self._set_background_color(widget, None)
+        if len(group['widgets']) == 1:
+            remaining_widget = group['widgets'][0]
+            group['widgets'].remove(remaining_widget)
+            self._link_groups.remove(group)
+            self._set_background_color(remaining_widget, None)
+        else:
+            for w in group['widgets']:
+                self._set_background_color(w, group['color'])
+
+    def _get_module_window(self, widget):
+        parent = widget.parent()
+        while parent is not None:
+            if isinstance(parent, ModuleWindow):
+                return parent
+            parent = parent.parent()
+
+        raise ValueError('Could not find module window')
+
+    def _set_background_color(self, widget, color):
+        try:
+            palette = widget.linkDisplay().palette()
+            palette.setColor(QPalette.Background, QColor(rgb_to_hex(color)) if color is not None else Qt.transparent)
+            widget.linkDisplay().setAutoFillBackground(True)
+            widget.linkDisplay().setPalette(palette)
+        except RuntimeError:
+            # May have been deleted
+            pass

pyqttoolkit/services/message_board.py

@@ -0,0 +1,90 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+#pylint: disable=no-name-in-module
+from PyQt5.QtCore import QObject, pyqtSignal, Qt
+#pylint: enable=no-name-in-module
+
+from ..properties import AutoProperty
+from ..data import MessageType, MessageResponse
+
+class MessageArgs:
+    def __init__(self, message_type, message, checkbox_message, response_type, text_format):
+        self._message_type = message_type
+        self._message = message
+        self._checkbox_message = checkbox_message
+        self._response_type = response_type
+        self._text_format = text_format
+        self._response = None
+        self._checkbox_value = None
+    
+    @property
+    def message_type(self):
+        return self._message_type
+
+    @property
+    def message(self):
+        return self._message
+    
+    @property
+    def checkbox_message(self):
+        return self._checkbox_message
+    
+    @property
+    def response_type(self):
+        return self._response_type
+
+    @property
+    def text_format(self):
+        return self._text_format
+
+    @property
+    def response(self):
+        return self._response
+    
+    @response.setter
+    def response(self, value):
+        self._response = value
+    
+    @property
+    def checkbox_value(self):
+        return self._checkbox_value
+    
+    @checkbox_value.setter
+    def checkbox_value(self, value):
+        self._checkbox_value = value
+
+class MessageBoard(QObject):
+    def __init__(self, parent):
+        QObject.__init__(self, parent)
+        self._message_enabled = True
+
+    def messageEnabled(self):
+        return self._message_enabled
+
+    def setMessageEnabled(self, value):
+        self._message_enabled = value
+
+    def post(self, message_type, message, response_type=MessageResponse.ok, checkbox_message=None, text_format=Qt.AutoText):
+        if not self._message_enabled:
+            return
+        self.message = MessageArgs(message_type, message, checkbox_message, response_type, text_format)
+        return self.message
+
+    messageChanged = pyqtSignal(MessageArgs)
+
+    message = AutoProperty(MessageArgs)

pyqttoolkit/services/module_service.py

@@ -0,0 +1,154 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`module_service`
+The module service, creates and manages qt widget modules
+"""
+from os.path import basename
+
+from weakref import ref
+import weakref
+
+from PyQt5.QtCore import QObject, pyqtSlot, QTimer, Qt
+
+from pyqttoolkit.modules import Module, CommandModule
+from pyqttoolkit.views import ModuleWindow
+from pyqttoolkit.modules.events import ModuleOpeningEvent
+
+class ModuleService(QObject):
+    """class::ModuleService
+    This class creates and displays modules (views, models and view managers)
+    """
+
+    def __init__(self, dependency_container, theme_manager, project_updater, project_manager, garbage_collector):
+        super().__init__(None)
+        self._theme_manager = theme_manager
+        self._dependency_container = dependency_container
+        self._view_manager_refs = {}
+        self._window_refs = {}
+        self._model_refs = {}
+        self._view_managers = {}
+        self._windows = {}
+        self._models = {}
+        self._registered_modules = {}
+        self._project_updater = project_updater
+        self._project_manager = project_manager
+        self._garbage_collector = garbage_collector
+    
+    def register(self, module):
+        if module.id in self._registered_modules:
+            raise ValueError('module')
+        module.setParent(self)
+        self._registered_modules[module.id] = module
+        if module.launcher_config and self._project_updater is not None and self._project_manager is not None:
+            self._project_updater.projectUpdated.connect(self._project_update_handler(module))
+        
+    def _project_update_handler(self, module):
+        def _handler():
+            module.handle_project_updated(self._project_manager.project)
+        return _handler
+
+    @pyqtSlot(str, QObject)
+    def openModule(self, name):
+        """function::openModule(self, name, parent, model)
+        Opens the module with the specified name, setting the parent and model
+        """
+        if self._init_module(name):
+            module = self._registered_modules[name]
+            if isinstance(module, CommandModule):
+                result = module.execute()
+            elif isinstance(module, Module):
+                result = self._create_module(name).show()
+            else:
+                raise ValueError('Invalid module type')
+            self._module_opened(name)
+            return result
+        return None
+
+    def closeModules(self):
+        for id_, window in list(self._windows.items()):
+            if id_ != 'root' and not window.forceClose():
+                return False
+        return True
+            
+    def modules(self):
+        return self._registered_modules
+    
+    def _init_module(self, id_):
+        module = self._registered_modules[id_]
+        opening_event = ModuleOpeningEvent()
+        module.opening.emit(opening_event)
+        return opening_event.accepted
+    
+    def _module_opened(self, id_):
+        self._registered_modules[id_].opened.emit()
+    
+    def _create_module(self, id_):
+        if not id_ in self._registered_modules:
+            raise RuntimeError(f'Could not find module with id {id_}')
+        if self._registered_modules[id_].is_root:
+            return self._create_root_module(id_)
+        else:
+            return self._create_sub_module(id_)
+    
+    def _create_root_module(self, id_):
+        window = self._dependency_container.resolve(self._registered_modules[id_].view_type)
+        model = self._dependency_container.resolve(self._registered_modules[id_].model_type)
+        model.setParent(window)
+        view_manager = self._registered_modules[id_].view_manager_type(window, model)
+        self._windows['root'] = window
+        self._models['root'] = model
+        self._view_managers['root'] = view_manager
+        return window
+
+    def _create_sub_module(self, id_):
+        singleton = self._registered_modules[id_].singleton
+        window_title = self._registered_modules[id_].title
+        if self._project_manager.filename:
+            window_title += f' - {basename(self._project_manager.filename)}'
+        elif self._project_updater and self._project_updater.dirty:
+            window_title += self.tr(' - unsaved')
+        window = ModuleWindow(self._theme_manager, window_title, singleton)
+        window.setAttribute(Qt.WA_DeleteOnClose)
+        model = self._dependency_container.resolve(
+            self._registered_modules[id_].model_type,
+            {'parent': window, 'module_id': id_}
+        )
+        view = self._dependency_container.resolve(self._registered_modules[id_].view_type, {'parent': window})
+        window.setModuleView(view)
+        view_manager = self._registered_modules[id_].view_manager_type(view, model)
+
+        self._view_managers[window.moduleId] = model
+        self._windows[window.moduleId] = window
+        self._models[window.moduleId] = model
+        self._view_manager_refs[window.moduleId] = ref(view_manager)
+        self._window_refs[window.moduleId] = ref(window)
+        self._model_refs[window.moduleId] = ref(model)
+        window.closing.connect(self._remove_module)
+        return window
+    
+    def _remove_module(self, module_id):
+        self._view_managers.pop(module_id)
+        window = self._windows.pop(module_id)
+        self._models.pop(module_id)
+        window.deleteLater()
+        window.destroyed.connect(self._schedule_gc)
+    
+    def _schedule_gc(self):
+        QTimer.singleShot(0, self._gc)
+    
+    def _gc(self):
+        self._garbage_collector.check(full=True)

pyqttoolkit/services/object_converter.py

@@ -0,0 +1,45 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class NoConverter(Exception):
+    def __init__(self, type_):
+        Exception.__init__(self, f'No converter for type {type_}')
+
+class DictConverter:
+    def to_dict(self, value):
+        raise NotImplementedError()
+    
+    def from_dict(self, value):
+        raise NotImplementedError()
+
+class ObjectConverter:
+    def __init__(self):
+        self._converters = {}
+    
+    def register_converter(self, converter, value_type):
+        self._converters.setdefault(value_type, []).append(converter)
+    
+    def to_dict(self, value):
+        return self._get_converter(type(value), DictConverter).to_dict(value)
+    
+    def from_dict(self, value, value_type, **kwargs):
+        return self._get_converter(value_type, DictConverter).from_dict(value, **kwargs)
+    
+    def _get_converter(self, value_type, converter_type):
+        type_converters = [c for c in self._converters.get(value_type, []) if isinstance(c, converter_type)]
+        if not type_converters:
+            raise NoConverter(value_type)
+        return type_converters[0]