+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from api_krita.wrappers import Database
+from composer_utils import Config
+from typing import Type, TypeVar
+from enum import Enum
+
+T = TypeVar('T', bound=Enum)
+
+
+class TagConfigValues(list):
+ """
+ List-based container with preset names fetched from database.
+
+ Created using tag's name stored in passed configuration.
+ Uses custom tag order stored in `tag_values` config. All the tag
+ values not present in the order will be added to the end.
+
+ Values which are no longer in the tag, will not be included.
+
+ Does not update in runtime as the tag gets edited.
+
+ ### Example usage:
+
+ Fetch all brush presets from tag named stored in TAG_BLUE:
+ ```python
+ TagConfigValues(Config.TAG_BLUE, Config.TAG_BLUE_VALUES)
+ ```
+ """
+
+ def __init__(self, tag: Config, tag_values: Config) -> None:
+ self.tag = tag
+ self.config_to_write = tag_values
+
+ with Database() as database:
+ tag_presets = database.get_preset_names_from_tag(tag.read())
+
+ preset_string: str = tag_values.read()
+ preset_order = preset_string.split("\t")
+ preset_order = [p for p in preset_order if p in tag_presets]
+
+ missing = [p for p in tag_presets if p not in preset_order]
+ self.extend(preset_order + missing)
+
+
+class EnumConfigValues(list):
+ """
+ List-based container with enums fetched from configuration.
+
+ ### Example usage:
+
+ Fetch all enums stored in `TRANSFORM_MODES_VALUES` as enum `Tool`:
+ ```python
+ EnumConfigValues(Config.TRANSFORM_MODES_VALUES, Tool)
+ ```
+ """
+
+ def __init__(self, values: Config, enum_type: Type[T]) -> None:
+ self.config_to_write = values
+ value_string: str = values.read()
+ if value_string == '':
+ return
+ values_list = value_string.split("\t")
+ self.extend([enum_type[value] for value in values_list])
diff --git a/shortcut_composer/manual.html b/shortcut_composer/manual.html
index bc433337..27822975 100644
--- a/shortcut_composer/manual.html
+++ b/shortcut_composer/manual.html
@@ -16,13 +16,41 @@ Shortcut composer
Pie menu - while key is pressed, displays a pie menu, which allows to pick values by hovering a
mouse.
Cursor tracker - while key is pressed, tracks a cursor, switching values according to cursor
- offset.
+ offset.
+
Canvas preview - Temporarily changes canvas elements while the key is pressed.
Multiple assignment - repeatedly pressing a key, cycles between multiple values of krita property.
Temporary key - temporarily activates a krita property with long press or toggles it on/off with
short press.
+ What's new in v1.1.0
+ Added
+
+ - Edit mode for PieMenus - click or drag the value icon to enter it. While in edit mode, the values can be dragged
+ across the PieMenu to change their order.
+ - Action values tab in Configure Shortcut Composer for adding and removing values in PieMenus and
+ MultipleAssignment
+ actions.
+ - PieValues backtrounds are now animated.
+
+ Fixed
+
+ - Allow scrolling through masks while using layey mouse trackers
+ - Make sure that presets in PieMenu are displayed only once.
+ - Allow using "Enclose and fill" tool
+ - Fix icon of "Colorize Mask" tool
+ - Fix scaling issues of Text labels in PieMenu
+
+ Requirements
+ Shortcut Composer v1.1.0 Requires krita 5.1.0 or later.
+ OS support state:
+
+ - [x] Windows 10/11
+ - [x] Linux
+ - [ ] MacOS (Known bug of canvas losing focus after using PieMenu)
+ - [ ] Android (Does not support python plugins yet)
+
Installation:
- on github project page, click the green button
@@ -36,12 +64,17 @@
Installation:
Pre-made actions
While Shortcut-Composer is highly configurable and extendable, the add-on comes with pre-made, plug-and-play
- actions.
+ actions.
+
Pie menu is a widget displayed on the canvas while a key is pressed. It will disappear as soon, as the key is
released. Moving cursor in a direction of a icon, activates its value on key release. The action does not
recognise mouse clicks, and only requires hovering. Pie menu does nothing if the cursor is not moved out
- of the deadzone.
+ of
+ the deadzone.
+ Dragging a value enters Edit mode in which the keyboard button no longer needs to be pressed. In this
+ mode values can be dragged accross the widget to change their order. When done, press the tick button to apply the
+ changes.
-
Pick brush presets (red, green, blue)
@@ -59,7 +92,8 @@ Pick brush presets (red, green, blue
-
Pie menu for picking active tools. Includes tools that are used rather sporadically, and may
- not be worth a dedicated keyboard shortcut each:
+ not
+ be worth a dedicated keyboard shortcut each:
- crop tool,
- reference tool,
@@ -82,17 +116,35 @@ Pick painting blending modes
- lighten
+ -
+
Create painting layer with blending mode
+ Pie menu for creating a new layer with picked blending mode. Consists of most commonly used
+ ones:
+
+ - normal
+ - erase
+ - overlay,
+ - color,
+ - multiply,
+ - add,
+ - screen,
+ - darken,
+ - lighten
+
+
(Cursor trackers):
Cursor tracker is an action for switching values using cursor movement, while the keyboard key is pressed. It
- changes a single krita property according to the cursor movement along horizontal or vertical axis. The
- action does not recognise mouse clicks, and only requires hovering
+ changes
+ a single krita property according to the cursor movement along horizontal or vertical axis. The action does
+ not recognise mouse clicks, and only requires hovering
Worth noting
- Key bindings with modifiers like ctrl or shift are supported. When assigned to a key
combination, the key is considered released when the main key in sequence (non-modifier) is released.
- Multiple shortcuts from this plugin can be used at the same time, unless bindings make it technically
- impossible. For example holding both keys for
Temporary eraser and Cycle painting
- opacity result in an eraser with 70% opacity.
+ impossible.
+ For example holding both keys for Temporary eraser and Cycle painting opacity result in
+ an
+ eraser with 70% opacity.
Known limitations
@@ -264,43 +335,45 @@ Known limitations
For krita plugin programmers
Alternative API
The extension consists of elements that can be reused in other krita plugins under GPL-3.0-or-later license.
- Package api_krita wrappes krita api offering PEP8 compatibility, typings, and docstring documentation.
- Most of objects attributes are now available as settables properties.
+ Package
+ api_krita wrappes krita api offering PEP8 compatibility, typings, and docstring documentation. Most of
+ objects attributes are now available as settables properties.
Copy api_krita to the extension directory, to access syntax such as:
from .api_krita import Krita
- from .api_krita.enums import BlendingMode, Tool, Toggle
-
-
- tool = Krita.active_tool
- Krita.active_tool = Tool.FREEHAND_BRUSH
- Tool.FREEHAND_BRUSH.activate()
-
-
- document = Krita.get_active_document()
- all_nodes = document.get_all_nodes()
- picked_node = all_nodes[3]
-
- picked_node.name = "My layer name"
- picked_node.visible = True
- picked_node.opacity = 50
- document.active_node = picked_node
- document.refresh()
-
-
- view = Krita.get_active_view()
- view.brush_size = 100
- view.blending_mode = BlendingMode.NORMAL
-
-
- mirror_state = Toggle.MIRROR_CANVAS.state
- Toggle.SOFT_PROOFING.state = False
- Toggle.PRESERVE_ALPHA.switch_state()
-
+from .api_krita.enums import BlendingMode, Tool, Toggle
+
+
+tool = Krita.active_tool
+Krita.active_tool = Tool.FREEHAND_BRUSH
+Tool.FREEHAND_BRUSH.activate()
+
+
+document = Krita.get_active_document()
+all_nodes = document.get_all_nodes()
+picked_node = all_nodes[3]
+
+picked_node.name = "My layer name"
+picked_node.visible = True
+picked_node.opacity = 50
+document.active_node = picked_node
+document.refresh()
+
+
+view = Krita.get_active_view()
+view.brush_size = 100
+view.blending_mode = BlendingMode.NORMAL
+
+
+mirror_state = Toggle.MIRROR_CANVAS.state
+Toggle.SOFT_PROOFING.state = False
+Toggle.PRESERVE_ALPHA.switch_state()
+
Only functionalities that were needed during this plugin development are wrapped, so some of them are not yet
available. The syntax can also change over time.
Custom keyboard shortcut interface
Package input_adapter consists of ActionManager and ComplexAction which
- grants extended interface for creating keyboard shortcuts.
+ grants
+ extended interface for creating keyboard shortcuts.
While usual actions can only recognise key press, subclassing ComplexAction lets you override methods
performed on:
diff --git a/shortcut_composer/shortcut_composer.py b/shortcut_composer/shortcut_composer.py
index 96efc94e..b480e258 100755
--- a/shortcut_composer/shortcut_composer.py
+++ b/shortcut_composer/shortcut_composer.py
@@ -29,7 +29,8 @@ def createActions(self, window) -> None:
- Add a callback to reload plugin when krita theme changes
- Create complex action manager which holds and binds them to krita
"""
- self._transform_modes = TransformModeActions(window)
+ self._transform_modes = TransformModeActions()
+ self._transform_modes.create_actions(window)
self._pie_settings_dialog = SettingsDialog()
self._reload_action = self._create_reload_action(window)
diff --git a/shortcut_composer/templates/multiple_assignment.py b/shortcut_composer/templates/multiple_assignment.py
index aa28b28f..a5b5d88c 100644
--- a/shortcut_composer/templates/multiple_assignment.py
+++ b/shortcut_composer/templates/multiple_assignment.py
@@ -85,7 +85,10 @@ def on_key_press(self) -> None:
super().on_key_press()
if self._controller.get_value() != self._last_value:
self._reset_iterator()
- self._set_value(next(self._iterator))
+
+ # NOTE: When there are no values to cycle, iterator is invalid
+ if self._values_to_cycle:
+ self._set_value(next(self._iterator))
def on_long_key_release(self) -> None:
"""Long releases set default value."""
@@ -104,4 +107,4 @@ def _reset_iterator(self) -> None:
def _read_default_value(self, value: Optional[T]) -> T:
"""Read value from controller if it was not given."""
- return value if value else self._controller.default_value
+ return value if value is not None else self._controller.default_value
diff --git a/shortcut_composer/templates/pie_menu.py b/shortcut_composer/templates/pie_menu.py
index 501c0472..874aafb1 100644
--- a/shortcut_composer/templates/pie_menu.py
+++ b/shortcut_composer/templates/pie_menu.py
@@ -4,14 +4,12 @@
from typing import List, TypeVar, Generic, Union, Optional
from PyQt5.QtGui import QColor, QPixmap, QIcon
-from PyQt5.QtCore import QPoint
from api_krita.pyqt import Text
+from composer_utils import Config
from core_components import Controller, Instruction
from input_adapter import ComplexAction
from .pie_menu_utils import (
- CirclePoints,
- LabelHolder,
PieManager,
PieWidget,
PieStyle,
@@ -28,6 +26,8 @@ class PieMenu(ComplexAction, Generic[T]):
- Widget is displayed under the cursor between key press and release
- Moving mouse in a direction of a value activates in on key release
- When the mouse was not moved past deadzone, value is not changed
+ - Dragging values activates edit mode in which pie does not hide
+ - Applying the changes in edit mode, saves its values to settings
### Arguments:
@@ -37,12 +37,12 @@ class PieMenu(ComplexAction, Generic[T]):
- `values` -- list of values compatibile with controller to cycle
- `instructions` -- (optional) list of additional instructions to
perform on key press and release
- - `short_vs_long_press_time` -- (optional) time [s] that specifies
- if key press is short or long
- `pie_radius_scale` -- (optional) widget size multiplier
- `icon_radius_scale` -- (optional) icons size multiplier
- `background_color` -- (optional) rgba color of background
- `active_color` -- (optional) rgba color of active pie
+ - `short_vs_long_press_time` -- (optional) time [s] that specifies
+ if key press is short or long
### Action implementation example:
@@ -70,8 +70,6 @@ class PieMenu(ComplexAction, Generic[T]):
- Creating the PieWidget - and PieManager which displays it
- Starting and stopping the PieManager on key press and release
- Creating Labels - paintable representations of handled values
- - Storing created labels in LabelHolder which allows to fetch them
- by the angle on a pie
- Setting a value on key release when the deadzone was reached
"""
@@ -93,16 +91,18 @@ def __init__(
instructions=instructions)
self._controller = controller
+ self._labels = self._create_labels(values)
self._style = PieStyle(
pie_radius_scale=pie_radius_scale,
icon_radius_scale=icon_radius_scale,
+ icons_amount=len(self._labels),
background_color=background_color,
active_color=active_color,
)
- self._labels = self._create_labels(values)
- self._style.adapt_to_item_amount(len(self._labels))
- self._pie_manager = PieManager(PieWidget(self._labels, self._style))
+ related_config = self._get_config_to_write_back(values)
+ self._pie_widget = PieWidget(self._style, self._labels, related_config)
+ self._pie_manager = PieManager(self._pie_widget)
def on_key_press(self) -> None:
"""Show widget under mouse and start manager which repaints it."""
@@ -113,30 +113,19 @@ def on_key_press(self) -> None:
def on_every_key_release(self) -> None:
"""Stop the widget. Set selected value if deadzone was reached."""
super().on_every_key_release()
+ if self._pie_widget.edit_mode:
+ return
self._pie_manager.stop()
- if label := self._labels.active:
- self._controller.set_value(label.value)
+ if widget := self._pie_widget.widget_holder.active:
+ self._controller.set_value(widget.label.value)
- def _create_labels(self, values: List[T]) -> LabelHolder:
+ def _create_labels(self, values: List[T]) -> List[Label]:
"""Wrap values into paintable label objects with position info."""
label_list = []
for value in values:
if icon := self._get_icon_if_possible(value):
label_list.append(Label(value=value, display_value=icon))
-
- center = QPoint(self._style.widget_radius, self._style.widget_radius)
- circle_points = CirclePoints(
- center=center,
- radius=self._style.pie_radius)
- angle_iterator = circle_points.iterate_over_circle(len(label_list))
-
- label_holder = LabelHolder()
- for label, (angle, point) in zip(label_list, angle_iterator):
- label.angle = angle
- label.center = point
- label_holder.add(label)
-
- return label_holder
+ return label_list
def _get_icon_if_possible(self, value: T) \
-> Union[Text, QPixmap, QIcon, None]:
@@ -145,3 +134,10 @@ def _get_icon_if_possible(self, value: T) \
return self._controller.get_label(value)
except KeyError:
return None
+
+ def _get_config_to_write_back(self, values: List[T]) -> Optional[Config]:
+ """Some value lists can contain metadata with config to write back."""
+ try:
+ return values.config_to_write # type: ignore
+ except AttributeError:
+ return None
diff --git a/shortcut_composer/templates/pie_menu_utils/__init__.py b/shortcut_composer/templates/pie_menu_utils/__init__.py
index 35afe128..1e9c5a27 100644
--- a/shortcut_composer/templates/pie_menu_utils/__init__.py
+++ b/shortcut_composer/templates/pie_menu_utils/__init__.py
@@ -1,18 +1,16 @@
# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
# SPDX-License-Identifier: GPL-3.0-or-later
-"""Implementation of PieMenu."""
+"""Implementation of PieMenu main elements."""
-from .circle_points import CirclePoints
-from .label_holder import LabelHolder
+from .label_widget import LabelWidget
from .pie_manager import PieManager
from .pie_widget import PieWidget
from .pie_style import PieStyle
from .label import Label
__all__ = [
- "CirclePoints",
- "LabelHolder",
+ "LabelWidget",
"PieManager",
"PieWidget",
"PieStyle",
diff --git a/shortcut_composer/templates/pie_menu_utils/label.py b/shortcut_composer/templates/pie_menu_utils/label.py
index a837dcf4..a75ec460 100644
--- a/shortcut_composer/templates/pie_menu_utils/label.py
+++ b/shortcut_composer/templates/pie_menu_utils/label.py
@@ -1,22 +1,23 @@
# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
# SPDX-License-Identifier: GPL-3.0-or-later
-from typing import Union, Type, Any
+from api_krita.pyqt import Text
+from typing import Union, Any
from dataclasses import dataclass
-from abc import ABC, abstractmethod
-from PyQt5.QtCore import QPoint, Qt
-from PyQt5.QtGui import QFont, QPixmap, QColor, QIcon, QFontDatabase
-from PyQt5.QtWidgets import QLabel, QWidget
+from PyQt5.QtCore import QPoint
+from PyQt5.QtGui import (
+ QPixmap,
+ QIcon,
+)
-from api_krita.pyqt import Painter, Text, PixmapTransform
-from .pie_style import PieStyle
+from composer_utils import Config
@dataclass
class Label:
"""
- Paintable representation of value in PieWidget.
+ Data representing a single value in PieWidget.
- `value` -- Value to set using the controller
- `center -- Label position in widget coordinates
@@ -24,12 +25,7 @@ class Label:
counted clockwise with 0 being the top of widget
- `display_value` -- `value` representation to display. Can be
either a colored text or an image
-
- `display_value` can also be accessed using `text` and `image`
- properties, which return None when the value does not exist or is
- not of required type.
-
- Label can be displayed with LabelPainter, returned by get_painter().
+ - `activation_progress` -- state of animation in range <0-1>
"""
value: Any
@@ -37,138 +33,49 @@ class Label:
angle: int = 0
display_value: Union[QPixmap, QIcon, Text, None] = None
- def get_painter(self, widget: QWidget, style: PieStyle) -> 'LabelPainter':
- """Return LabelPainter which can display this label."""
- if self.display_value is None:
- raise ValueError(f"Label {self} is not valid")
-
- painter_type: Type[LabelPainter] = {
- QPixmap: ImageLabelPainter,
- Text: TextLabelPainter,
- QIcon: IconPainter,
- }[type(self.display_value)]
+ def __post_init__(self) -> None:
+ self.activation_progress = AnimationProgress(speed_scale=1, steep=1)
- return painter_type(self, widget, style)
+ def swap_locations(self, other: 'Label') -> None:
+ """Change position data with information Label."""
+ self.angle, other.angle = other.angle, self.angle
+ self.center, other.center = other.center, self.center
-@dataclass
-class LabelPainter(ABC):
- """Displays a `label` inside of `widget` using given `style`."""
+class AnimationProgress:
+ """
+ Grants interface to track progress of two-way steep animation.
- label: Label
- widget: QWidget
- style: PieStyle
+ Holds the state of animation as float in range <0-1> which can be
+ obtained with `value` property.
- @abstractmethod
- def paint(self, painter: Painter) -> None: """Paint a label."""
+ Animation state can be altered with `up()` and `down()` methods.
+ The change is the fastest when the animation starts, and then slows
+ down near the end (controlled by `steep` argument).
+ There is a `reset()` method to cancel the animation immediatelly.
+ """
-@dataclass
-class TextLabelPainter(LabelPainter):
- """Displays a `label` which holds text."""
-
- def __post_init__(self):
- self._pyqt_label = self._create_pyqt_label()
-
- def paint(self, painter: Painter):
- """Paint a background behind a label and its border."""
- painter.paint_wheel(
- center=self.label.center,
- outer_radius=self.style.icon_radius,
- color=self.style.icon_color,
- )
- painter.paint_wheel(
- center=self.label.center,
- outer_radius=self.style.icon_radius,
- color=self.style.border_color,
- thickness=self.style.border_thickness,
- )
-
- def _create_pyqt_label(self) -> QLabel:
- """Create and show a new Qt5 label. Does not need redrawing."""
- to_display = self.label.display_value
-
- if not isinstance(to_display, Text):
- raise TypeError("Label supposed to be text.")
-
- heigth = round(self.style.icon_radius*0.8)
-
- label = QLabel(self.widget)
- label.setText(to_display.value)
- label.setFont(self._font)
- label.setAlignment(Qt.AlignCenter)
- label.setGeometry(0, 0, round(heigth*2), round(heigth))
- label.move(self.label.center.x()-heigth,
- self.label.center.y()-heigth//2)
- label.setStyleSheet(f'''
- background-color:rgba({self._color_to_str(self.style.icon_color)});
- color:rgba({self._color_to_str(to_display.color)});
- ''')
-
- label.show()
- return label
+ def __init__(self, speed_scale: float = 1.0, steep: float = 1.0) -> None:
+ self._value = 0
+ self._speed = 0.004*Config.get_sleep_time()*speed_scale
+ self._steep = steep
- @property
- def _font(self) -> QFont:
- """Return font which to use in pyqt label."""
- font = QFontDatabase.systemFont(QFontDatabase.TitleFont)
- font.setPointSize(self.style.font_size)
- font.setBold(True)
- return font
+ def up(self) -> None:
+ """Increase the animation progress."""
+ difference = (1+self._steep-self._value) * self._speed
+ self._value = min(self._value + difference, 1)
- @staticmethod
- def _color_to_str(color: QColor) -> str: return f'''
- {color.red()}, {color.green()}, {color.blue()}, {color.alpha()}'''
+ def down(self) -> None:
+ """Decrease the animation progress."""
+ difference = (self._value+self._steep) * self._speed
+ self._value = max(self._value - difference, 0)
+ @property
+ def value(self) -> float:
+ """Get current state of animation. It ss in range <0-1>."""
+ return self._value
-@dataclass
-class ImageLabelPainter(LabelPainter):
- """Displays a `label` which holds an image."""
-
- def __post_init__(self):
- self.ready_image = self._prepare_image()
-
- def paint(self, painter: Painter):
- """Paint a background behind a label its border, and image itself."""
- painter.paint_wheel(
- center=self.label.center,
- outer_radius=self.style.icon_radius,
- color=self.style.icon_color
- )
- painter.paint_wheel(
- center=self.label.center,
- outer_radius=self.style.icon_radius-self.style.border_thickness//2,
- color=self.style.border_color,
- thickness=self.style.border_thickness,
- )
- painter.paint_pixmap(self.label.center, self.ready_image)
-
- def _prepare_image(self) -> QPixmap:
- """Return image after scaling and reshaping it to circle."""
- to_display = self.label.display_value
-
- if not isinstance(to_display, QPixmap):
- raise TypeError("Label supposed to be QPixmap.")
-
- rounded_image = PixmapTransform.make_pixmap_round(to_display)
- return PixmapTransform.scale_pixmap(
- pixmap=rounded_image,
- size_px=round(self.style.icon_radius*1.8)
- )
-
-
-class IconPainter(ImageLabelPainter):
- """Displays a `label` which holds an icon."""
-
- def _prepare_image(self) -> QPixmap:
- """Return icon after scaling it to fix QT_SCALE_FACTOR."""
- to_display = self.label.display_value
-
- if not isinstance(to_display, QIcon):
- raise TypeError("Label supposed to be QIcon.")
-
- size = round(self.style.icon_radius*1.1)
- return PixmapTransform.scale_pixmap(
- pixmap=to_display.pixmap(size, size),
- size_px=size
- )
+ def reset(self) -> None:
+ """Arbitralily set a value to 0"""
+ self._value = 0
diff --git a/shortcut_composer/templates/pie_menu_utils/label_holder.py b/shortcut_composer/templates/pie_menu_utils/label_holder.py
deleted file mode 100644
index c08c2ac8..00000000
--- a/shortcut_composer/templates/pie_menu_utils/label_holder.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
-# SPDX-License-Identifier: GPL-3.0-or-later
-
-from typing import Dict, Iterator, Optional
-
-from .label import Label
-
-
-class LabelHolder:
- """
- Holds Labels and allows fetching them using their angle.
-
- Allows one of the labels to be active, but does not handle this
- attribute by itself.
-
- Allows iterating over Labels (default) and over angles (angles())
- """
-
- def __init__(self):
- self._labels: Dict[int, Label] = {}
- self.active: Optional[Label] = None
-
- def add(self, label: Label) -> None:
- """Add a new label to the holder."""
- self._labels[label.angle] = label
-
- def angles(self) -> Iterator[int]:
- """Iterate over all angles of held Labels."""
- return iter(self._labels.keys())
-
- def from_angle(self, angle: int) -> Label:
- """Return Label which is the closest to given `angle`."""
-
- def angle_difference(label_angle: int):
- """Return the smallest difference between two angles."""
- nonlocal angle
- raw_difference = label_angle - angle
- return abs((raw_difference + 180) % 360 - 180)
-
- closest = min(self.angles(), key=angle_difference)
- return self._labels[closest]
-
- def __iter__(self) -> Iterator[Label]:
- """Iterate over all held labels."""
- return iter(self._labels.values())
-
- def __len__(self) -> int:
- """Return amount of held labels."""
- return len(self._labels)
diff --git a/shortcut_composer/templates/pie_menu_utils/label_widget.py b/shortcut_composer/templates/pie_menu_utils/label_widget.py
new file mode 100644
index 00000000..15d6805f
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/label_widget.py
@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from PyQt5.QtCore import Qt, QMimeData
+from PyQt5.QtWidgets import QWidget
+from PyQt5.QtGui import QDrag, QPixmap, QMouseEvent
+
+from api_krita.pyqt import PixmapTransform, BaseWidget
+from .pie_style import PieStyle
+from .label import Label
+
+
+class LabelWidget(BaseWidget):
+ """Displays a `label` inside of `widget` using given `style`."""
+
+ def __init__(
+ self,
+ label: Label,
+ style: PieStyle,
+ parent: QWidget,
+ ) -> None:
+ super().__init__(parent)
+ self.setGeometry(0, 0, style.icon_radius*2, style.icon_radius*2)
+
+ self.label = label
+ self._style = style
+ self.setCursor(Qt.ArrowCursor)
+
+ def move_to_label(self) -> None:
+ """Move the widget by providing a new center point."""
+ self.move_center(self.label.center)
+
+ def mousePressEvent(self, e: QMouseEvent) -> None:
+ """Initiate a drag loop for this Widget, so Widgets can be swapped."""
+ if e.buttons() != Qt.LeftButton:
+ return
+ drag = QDrag(self)
+ drag.setMimeData(QMimeData())
+
+ pixmap = QPixmap(self.size())
+ self.render(pixmap)
+ drag.setPixmap(PixmapTransform.make_pixmap_round(pixmap))
+
+ drag.exec_(Qt.MoveAction)
diff --git a/shortcut_composer/templates/pie_menu_utils/label_widget_utils/__init__.py b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/__init__.py
new file mode 100644
index 00000000..68760a4e
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Implementation of different LabelWidget types."""
+
+from .create_label_widget import create_label_widget
+
+__all__ = ["create_label_widget"]
diff --git a/shortcut_composer/templates/pie_menu_utils/label_widget_utils/create_label_widget.py b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/create_label_widget.py
new file mode 100644
index 00000000..57b42140
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/create_label_widget.py
@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Type
+
+from PyQt5.QtGui import (
+ QPixmap,
+ QIcon,
+)
+from PyQt5.QtWidgets import QWidget
+
+from api_krita.pyqt import Text
+from ..pie_style import PieStyle
+from ..label import Label
+from ..label_widget import LabelWidget
+from .icon_label_widget import IconLabelWidget
+from .text_label_widget import TextLabelWidget
+from .image_label_widget import ImageLabelWidget
+
+
+def create_label_widget(
+ label: Label,
+ style: PieStyle,
+ parent: QWidget
+) -> 'LabelWidget':
+ """Return LabelWidget which can display this label."""
+ if label.display_value is None:
+ raise ValueError(f"Label {label} is not valid")
+
+ painter_type: Type[LabelWidget] = {
+ QPixmap: ImageLabelWidget,
+ Text: TextLabelWidget,
+ QIcon: IconLabelWidget,
+ }[type(label.display_value)]
+
+ return painter_type(label, style, parent)
diff --git a/shortcut_composer/templates/pie_menu_utils/label_widget_utils/icon_label_widget.py b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/icon_label_widget.py
new file mode 100644
index 00000000..d99aa262
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/icon_label_widget.py
@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from PyQt5.QtGui import (
+ QPixmap,
+ QIcon,
+)
+
+from api_krita.pyqt import PixmapTransform
+from .image_label_widget import ImageLabelWidget
+
+
+class IconLabelWidget(ImageLabelWidget):
+ """Displays a `label` which holds an icon."""
+
+ def _prepare_image(self) -> QPixmap:
+ """Return icon after scaling it to fix QT_SCALE_FACTOR."""
+ to_display = self.label.display_value
+
+ if not isinstance(to_display, QIcon):
+ raise TypeError("Label supposed to be QIcon.")
+
+ size = round(self._style.icon_radius*1.1)
+ return PixmapTransform.scale_pixmap(
+ pixmap=to_display.pixmap(size, size),
+ size_px=size
+ )
diff --git a/shortcut_composer/templates/pie_menu_utils/label_widget_utils/image_label_widget.py b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/image_label_widget.py
new file mode 100644
index 00000000..fbdfd2b4
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/image_label_widget.py
@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from PyQt5.QtGui import (
+ QPixmap,
+ QPaintEvent,
+)
+from PyQt5.QtWidgets import QWidget
+
+from api_krita.pyqt import Painter, PixmapTransform
+from ..pie_style import PieStyle
+from ..label import Label
+from ..label_widget import LabelWidget
+
+
+class ImageLabelWidget(LabelWidget):
+ """Displays a `label` which holds an image."""
+
+ def __init__(self, label: Label, style: PieStyle, parent: QWidget) -> None:
+ super().__init__(label, style, parent)
+ self.ready_image = self._prepare_image()
+
+ def paintEvent(self, event: QPaintEvent) -> None:
+ """
+ Paint the entire widget using the Painter wrapper.
+
+ Paint a background behind a label its border, and image itself.
+ """
+ with Painter(self, event) as painter:
+ painter.paint_wheel(
+ center=self.center,
+ outer_radius=self._style.icon_radius,
+ color=self._style.icon_color
+ )
+ painter.paint_wheel(
+ center=self.center,
+ outer_radius=(
+ self._style.icon_radius-self._style.border_thickness//2),
+ color=self._style.border_color,
+ thickness=self._style.border_thickness,
+ )
+ painter.paint_pixmap(self.center, self.ready_image)
+
+ def _prepare_image(self) -> QPixmap:
+ """Return image after scaling and reshaping it to circle."""
+ to_display = self.label.display_value
+
+ if not isinstance(to_display, QPixmap):
+ raise TypeError("Label supposed to be QPixmap.")
+
+ rounded_image = PixmapTransform.make_pixmap_round(to_display)
+ return PixmapTransform.scale_pixmap(
+ pixmap=rounded_image,
+ size_px=round(self._style.icon_radius*1.8)
+ )
diff --git a/shortcut_composer/templates/pie_menu_utils/label_widget_utils/text_label_widget.py b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/text_label_widget.py
new file mode 100644
index 00000000..46729863
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/label_widget_utils/text_label_widget.py
@@ -0,0 +1,79 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import (
+ QFont,
+ QColor,
+ QFontDatabase,
+ QPaintEvent,
+)
+from PyQt5.QtWidgets import QLabel, QWidget
+
+from api_krita.pyqt import Painter, Text
+from ..pie_style import PieStyle
+from ..label import Label
+from ..label_widget import LabelWidget
+
+
+class TextLabelWidget(LabelWidget):
+ """Displays a `label` which holds text."""
+
+ def __init__(self, label: Label, style: PieStyle, parent: QWidget) -> None:
+ super().__init__(label, style, parent)
+ self._pyqt_label = self._create_pyqt_label()
+
+ def paintEvent(self, event: QPaintEvent) -> None:
+ """
+ Paint the entire widget using the Painter wrapper.
+
+ Paint a background behind a label and its border.
+ """
+ with Painter(self, event) as painter:
+ painter.paint_wheel(
+ center=self.center,
+ outer_radius=self._style.icon_radius,
+ color=self._style.icon_color,
+ )
+ painter.paint_wheel(
+ center=self.center,
+ outer_radius=self._style.icon_radius,
+ color=self._style.border_color,
+ thickness=self._style.border_thickness,
+ )
+
+ def _create_pyqt_label(self) -> QLabel:
+ """Create and show a new Qt5 label. Does not need redrawing."""
+ to_display = self.label.display_value
+
+ if not isinstance(to_display, Text):
+ raise TypeError("Label supposed to be text.")
+
+ heigth = round(self._style.icon_radius*0.8)
+
+ label = QLabel(self)
+ label.setText(to_display.value)
+ label.setAlignment(Qt.AlignCenter)
+ label.setGeometry(0, 0, round(heigth*2), round(heigth))
+ label.setFont(self._font)
+ label.move(self.center.x()-heigth,
+ self.center.y()-heigth//2)
+ label.setStyleSheet(f'''
+ background-color:rgba({self._color_to_str(self._style.icon_color)});
+ color:rgba({self._color_to_str(to_display.color)});
+ ''')
+
+ label.show()
+ return label
+
+ @property
+ def _font(self) -> QFont:
+ """Return font to use in pyqt label."""
+ font = QFontDatabase.systemFont(QFontDatabase.TitleFont)
+ font.setPointSize(round(self._style.font_multiplier*self.width()))
+ font.setBold(True)
+ return font
+
+ @staticmethod
+ def _color_to_str(color: QColor) -> str: return f'''
+ {color.red()}, {color.green()}, {color.blue()}, {color.alpha()}'''
diff --git a/shortcut_composer/templates/pie_menu_utils/pie_manager.py b/shortcut_composer/templates/pie_menu_utils/pie_manager.py
index 675988fe..5e22dc2b 100644
--- a/shortcut_composer/templates/pie_menu_utils/pie_manager.py
+++ b/shortcut_composer/templates/pie_menu_utils/pie_manager.py
@@ -8,8 +8,8 @@
from api_krita.pyqt import Timer
from composer_utils import Config
from .pie_widget import PieWidget
-from .label import Label
-from .circle_points import CirclePoints
+from .label_widget import LabelWidget
+from .widget_utils import CirclePoints
class PieManager:
@@ -23,34 +23,74 @@ class PieManager:
def __init__(self, widget: PieWidget) -> None:
self._widget = widget
- self._timer = Timer(self._track_angle, Config.get_sleep_time())
+ self._holder = self._widget.widget_holder
+ self._timer = Timer(self._handle_cursor, Config.get_sleep_time())
+ self._animator = LabelAnimator(widget)
self._circle: CirclePoints
- def start(self):
+ def start(self) -> None:
"""Show widget under the mouse and start the mouse tracking loop."""
self._widget.move_center(QCursor().pos())
self._widget.show()
self._circle = CirclePoints(self._widget.center_global, 0)
self._timer.start()
- def stop(self):
+ def stop(self) -> None:
"""Hide the widget and stop the mouse tracking loop."""
self._timer.stop()
+ for label in self._widget.labels:
+ label.activation_progress.reset()
self._widget.hide()
- def _track_angle(self):
- """Block a thread contiguously setting an active label."""
+ def _handle_cursor(self) -> None:
+ """Calculate zone of the cursor and mark which child is active."""
+ # NOTE: The widget can get hidden outside of stop() when key is
+ # released during the drag&drop operation or when user clicked
+ # outside the pie widget.
+ if not self._widget.isVisible():
+ return self.stop()
+
cursor = QCursor().pos()
if self._circle.distance(cursor) < self._widget.deadzone:
- label = None
- else:
- angle = self._circle.angle_from_point(cursor)
- label = self._widget.labels.from_angle(round(angle))
- self._set_active_label(label)
-
- def _set_active_label(self, label: Optional[Label]):
- """Mark label as active and ask the widget to repaint."""
- if self._widget.labels.active != label:
- self._widget.labels.active = label
- self._widget.repaint()
+ return self._set_active_widget(None)
+
+ angle = self._circle.angle_from_point(cursor)
+ self._set_active_widget(self._holder.on_angle(angle))
+
+ def _set_active_widget(self, widget: Optional[LabelWidget]) -> None:
+ """Mark label as active and start animating the change."""
+ if self._holder.active != widget:
+ self._holder.active = widget
+ self._animator.start()
+
+
+class LabelAnimator:
+ """
+ Controls the animation of background under pie labels.
+
+ Handles the whole widget at once, to prevent unnecessary repaints.
+ """
+
+ def __init__(self, widget: PieWidget) -> None:
+ self._widget = widget
+ self._children = widget.widget_holder
+ self._timer = Timer(self._update, Config.get_sleep_time())
+
+ def start(self) -> None:
+ """Start animating. The animation will stop automatically."""
+ self._timer.start()
+
+ def _update(self) -> None:
+ """Move all labels to next animation state. End animation if needed."""
+ for widget in self._children:
+ if self._children.active == widget:
+ widget.label.activation_progress.up()
+ else:
+ widget.label.activation_progress.down()
+
+ self._widget.repaint()
+ for widget in self._children:
+ if widget.label.activation_progress.value not in (0, 1):
+ return
+ self._timer.stop()
diff --git a/shortcut_composer/templates/pie_menu_utils/pie_style.py b/shortcut_composer/templates/pie_menu_utils/pie_style.py
index 4f09ace8..0561fefa 100644
--- a/shortcut_composer/templates/pie_menu_utils/pie_style.py
+++ b/shortcut_composer/templates/pie_menu_utils/pie_style.py
@@ -29,32 +29,30 @@ def __init__(
self,
pie_radius_scale: float,
icon_radius_scale: float,
+ icons_amount: int,
background_color: Optional[QColor],
active_color: QColor,
) -> None:
+ self._icons_amount = icons_amount
+ self._base_size = Krita.screen_size/2560
self.pie_radius_scale = pie_radius_scale
self.icon_radius_scale = icon_radius_scale
self.background_color = self._pick_background_color(background_color)
self.active_color = active_color
+ self.active_color_dark = QColor(
+ round(active_color.red()*0.8),
+ round(active_color.green()*0.8),
+ round(active_color.blue()*0.8))
- base_size = Krita.screen_size/2560
-
- self.pie_radius = round(
- 165 * base_size
+ self.pie_radius: int = round(
+ 165 * self._base_size
* self.pie_radius_scale
- * Config.PIE_GLOBAL_SCALE.read()
- )
- self.icon_radius = round(
- 50 * base_size
- * self.icon_radius_scale
- * Config.PIE_ICON_GLOBAL_SCALE.read()
- )
- self.deadzone_radius: float = (
- 40 * base_size
- * Config.PIE_DEADZONE_GLOBAL_SCALE.read()
- )
+ * Config.PIE_GLOBAL_SCALE.read())
+
+ self.icon_radius = self._pick_icon_radius()
self.widget_radius = self.pie_radius + self.icon_radius
+ self.deadzone_radius = self._pick_deadzone_radius()
self.border_thickness = round(self.pie_radius*0.02)
self.area_thickness = round(self.pie_radius/self.pie_radius_scale*0.4)
@@ -69,21 +67,31 @@ def __init__(
min(self.icon_color.red()+15, 255),
min(self.icon_color.green()+15, 255),
min(self.icon_color.blue()+15, 255),
- 255
- )
+ 255)
- font_multiplier = self.SYSTEM_FONT_SIZE[platform.system()]
- self.font_size: int = round(self.icon_radius*font_multiplier)
+ self.font_multiplier = self.SYSTEM_FONT_SIZE[platform.system()]
- def adapt_to_item_amount(self, amount: int) -> None:
- """Modify the style to make it fit the given amount of labels."""
- if not amount:
- self.deadzone_radius = float("inf")
- return
- max_icon_size = round(self.pie_radius * math.pi / amount)
- self.icon_radius = min(self.icon_radius, max_icon_size)
+ def _pick_icon_radius(self) -> int:
+ """Icons radius depend on settings, but they have to fit in the pie."""
+ icon_radius: int = round(
+ 50 * self._base_size
+ * self.icon_radius_scale
+ * Config.PIE_ICON_GLOBAL_SCALE.read()
+ )
+ max_icon_size = round(self.pie_radius * math.pi / self._icons_amount)
+ return min(icon_radius, max_icon_size)
+
+ def _pick_deadzone_radius(self) -> float:
+ """Deadzone can be configured, but when pie is empty, becomes inf."""
+ if not self._icons_amount:
+ return float("inf")
+ return (
+ 40 * self._base_size
+ * Config.PIE_DEADZONE_GLOBAL_SCALE.read()
+ )
def _pick_background_color(self, color: Optional[QColor]) -> QColor:
+ """Default background color depends on the app theme lightness."""
if color is not None:
return color
if Krita.is_light_theme_active:
@@ -91,8 +99,9 @@ def _pick_background_color(self, color: Optional[QColor]) -> QColor:
return QColor(75, 75, 75, 190)
SYSTEM_FONT_SIZE = {
- "Linux": 0.40,
- "Windows": 0.25,
- "Darwin": 0.6,
- "": 0.25,
+ "Linux": 0.175,
+ "Windows": 0.11,
+ "Darwin": 0.265,
+ "": 0.125,
}
+ """Scale to fix different font sizes each OS.."""
diff --git a/shortcut_composer/templates/pie_menu_utils/pie_widget.py b/shortcut_composer/templates/pie_menu_utils/pie_widget.py
index 969251c2..41ad3db2 100644
--- a/shortcut_composer/templates/pie_menu_utils/pie_widget.py
+++ b/shortcut_composer/templates/pie_menu_utils/pie_widget.py
@@ -1,19 +1,26 @@
# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
# SPDX-License-Identifier: GPL-3.0-or-later
-from typing import List
+from typing import List, Optional
-from PyQt5.QtCore import Qt, QPoint
-from PyQt5.QtGui import QColor, QPaintEvent
-
-from api_krita.pyqt import AnimatedWidget, Painter
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QPaintEvent, QDragMoveEvent, QDragEnterEvent
+from api_krita.pyqt import Painter, AnimatedWidget, BaseWidget
from composer_utils import Config
from .pie_style import PieStyle
-from .label import LabelPainter
-from .label_holder import LabelHolder
-
-
-class PieWidget(AnimatedWidget):
+from .label import Label
+from .label_widget import LabelWidget
+from .widget_utils import (
+ WidgetHolder,
+ CirclePoints,
+ AcceptButton,
+ PiePainter,
+ EditMode,
+)
+from .label_widget_utils import create_label_widget
+
+
+class PieWidget(AnimatedWidget, BaseWidget):
"""
PyQt5 widget with icons on ring that can be selected by hovering.
@@ -22,25 +29,47 @@ class PieWidget(AnimatedWidget):
- hide() - hides the widget
- repaint() - updates widget display after its data was changed
- Overrides paintEvent(QPaintEvent) which tells how the widget looks
+ Contains children widgets that are draggable. When one of the
+ children is dragged, the widget enters the edit mode. That can be
+ used by whoever controls this widget to handle it differently.
+
+ Stores the values in three forms:
+ - Labels: contain bare data
+ - LabelWidgets: widget children displaying a single Label
+ - LabelHolder: container of all LabelWidgets that operate on angles
- - Paints the widget: its base, and active pie and deadzone indicator
- - Wraps Labels with LabelPainter which activated, paint them
- - Extends widget interface to allow moving the widget on screen by
- providing the widget center.
+ Makes changes to LabelHolder when one of children is dragged.
+ When the widget is hidden while in the edit mode, changes made to
+ the LabelHolder are saved in the related configuration.
"""
+ edit_mode = EditMode()
+
def __init__(
self,
- labels: LabelHolder,
style: PieStyle,
+ labels: List[Label],
+ config_to_write_back: Optional[Config] = None,
parent=None
):
- super().__init__(parent, Config.PIE_ANIMATION_TIME.read())
- self.labels = labels
+ AnimatedWidget.__init__(self, parent, Config.PIE_ANIMATION_TIME.read())
+ self.setGeometry(0, 0, style.widget_radius*2, style.widget_radius*2)
+
self._style = style
- self._label_painters = self._create_label_painters()
+ self.config_to_write_back = config_to_write_back
+ self._circle_points = CirclePoints(
+ center=self.center,
+ radius=self._style.pie_radius)
+
+ self.labels = labels
+ self.children_widgets = self._create_children_holder()
+ self.widget_holder = self._put_children_in_holder()
+
+ self.accept_button = AcceptButton(self._style, self)
+ self.accept_button.move_center(self.center)
+ self.accept_button.clicked.connect(self.hide)
+ self.setAcceptDrops(True)
self.setWindowFlags((
self.windowFlags() | # type: ignore
Qt.Popup |
@@ -50,94 +79,63 @@ def __init__(
self.setStyleSheet("background: transparent;")
self.setCursor(Qt.CrossCursor)
- size = self._style.widget_radius*2
- self.setGeometry(0, 0, size, size)
-
- @property
- def center(self) -> QPoint:
- """Return point with center widget's point in its coordinates."""
- return QPoint(self._style.widget_radius, self._style.widget_radius)
-
- @property
- def center_global(self) -> QPoint:
- """Return point with center widget's point in screen coordinates."""
- return self.pos() + self.center # type: ignore
-
@property
def deadzone(self) -> float:
"""Return the deadzone distance."""
return self._style.deadzone_radius
- def move_center(self, new_center: QPoint) -> None:
- """Move the widget by providing a new center point."""
- self.move(new_center-self.center) # type: ignore
+ def hide(self):
+ """Leave the edit mode when the widget is hidden."""
+ self.edit_mode = False
+ super().hide()
def paintEvent(self, event: QPaintEvent) -> None:
"""Paint the entire widget using the Painter wrapper."""
with Painter(self, event) as painter:
- self._paint_deadzone_indicator(painter)
- self._paint_base_wheel(painter)
- self._paint_active_pie(painter)
- self._paint_base_border(painter)
-
- for label_painter in self._label_painters:
- label_painter.paint(painter)
-
- def _paint_base_wheel(self, painter: Painter) -> None:
- """Paint a base circle and low opacity background to trick Windows."""
- painter.paint_wheel(
- center=self.center,
- outer_radius=self._style.no_border_radius,
- color=QColor(128, 128, 128, 1),
- )
- painter.paint_wheel(
- center=self.center,
- outer_radius=self._style.no_border_radius,
- color=self._style.background_color,
- thickness=self._style.area_thickness,
- )
-
- def _paint_base_border(self, painter: Painter) -> None:
- """Paint a border on the inner edge of base circle."""
- painter.paint_wheel(
- center=self.center,
- outer_radius=self._style.inner_edge_radius,
- color=self._style.border_color,
- thickness=self._style.border_thickness,
- )
-
- def _paint_deadzone_indicator(self, painter: Painter) -> None:
- """Paint the circle representing deadzone, when its valid."""
- if self.deadzone == float("inf"):
- return
-
- painter.paint_wheel(
- center=self.center,
- outer_radius=self.deadzone,
- color=QColor(128, 255, 128, 120),
- thickness=1,
- )
- painter.paint_wheel(
- center=self.center,
- outer_radius=self.deadzone-1,
- color=QColor(255, 128, 128, 120),
- thickness=1,
- )
-
- def _paint_active_pie(self, painter: Painter) -> None:
- """Paint a pie representing active label if there is one."""
- if not self.labels.active:
- return
-
- painter.paint_pie(
- center=self.center,
- outer_radius=self._style.no_border_radius,
- angle=self.labels.active.angle,
- span=360//len(self._label_painters),
- color=self._style.active_color,
- thickness=self._style.area_thickness,
- )
-
- def _create_label_painters(self) -> List[LabelPainter]:
- """Wrap all labels with LabelPainter which can paint it."""
- return [label.get_painter(self, self._style) for label in self.labels]
+ PiePainter(painter, self.labels, self._style, self.edit_mode)
+
+ def dragEnterEvent(self, e: QDragEnterEvent) -> None:
+ """Start edit mode when one of the draggable children gets dragged."""
+ self.edit_mode = True
+ self.repaint()
+ e.accept()
+
+ def dragMoveEvent(self, e: QDragMoveEvent) -> None:
+ """Swap children during drag when mouse is moved to another zone."""
+ pos = e.pos()
+ source_widget = e.source()
+
+ if (self._circle_points.distance(pos) < self._style.deadzone_radius
+ or not isinstance(source_widget, LabelWidget)):
+ return e.accept()
+
+ # NOTE: This computation is too heavy to be done on each call
+ angle = self._circle_points.angle_from_point(pos)
+ widget = self.widget_holder.on_angle(angle)
+ if widget == source_widget:
+ return e.accept()
+
+ self.widget_holder.swap(widget, source_widget)
+ self.repaint()
+ e.accept()
+
+ def _create_children_holder(self) -> List[LabelWidget]:
+ """Create LabelWidgets that represent the labels."""
+ children: List[LabelWidget] = []
+ for label in self.labels:
+ children.append(create_label_widget(label, self._style, self))
+ return children
+
+ def _put_children_in_holder(self) -> WidgetHolder:
+ """Create WidgetHolder which manages child widgets angles."""
+ children = self.children_widgets
+ angle_iterator = self._circle_points.iterate_over_circle(len(children))
+ label_holder = WidgetHolder()
+
+ for child, (angle, point) in zip(children, angle_iterator):
+ child.label.angle = angle
+ child.label.center = point
+ child.move_to_label()
+ label_holder.add(child)
+
+ return label_holder
diff --git a/shortcut_composer/templates/pie_menu_utils/widget_utils/__init__.py b/shortcut_composer/templates/pie_menu_utils/widget_utils/__init__.py
new file mode 100644
index 00000000..fd578206
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/widget_utils/__init__.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Additional classes used by pie menu components."""
+
+from .circle_points import CirclePoints
+from .widget_holder import WidgetHolder
+from .accept_button import AcceptButton
+from .pie_painter import PiePainter
+from .edit_mode import EditMode
+
+__all__ = [
+ "CirclePoints",
+ "WidgetHolder",
+ "AcceptButton",
+ "PiePainter",
+ "EditMode",
+]
diff --git a/shortcut_composer/templates/pie_menu_utils/widget_utils/accept_button.py b/shortcut_composer/templates/pie_menu_utils/widget_utils/accept_button.py
new file mode 100644
index 00000000..f4cffbc3
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/widget_utils/accept_button.py
@@ -0,0 +1,45 @@
+from PyQt5.QtWidgets import QWidget, QPushButton
+from PyQt5.QtGui import QColor
+from PyQt5.QtCore import Qt
+
+from ..pie_style import PieStyle
+from api_krita.pyqt import BaseWidget
+from api_krita import Krita
+
+
+class AcceptButton(QPushButton, BaseWidget):
+ """Round button with a tick icon which uses provided PieStyle."""
+
+ def __init__(self, style: PieStyle, parent: QWidget) -> None:
+ QPushButton.__init__(self, Krita.get_icon("dialog-ok"), "", parent)
+
+ self._style = style
+ self.hide()
+ if self._style.deadzone_radius != float("inf"):
+ self.radius = int(self._style.deadzone_radius)
+ else:
+ self.radius = 1
+ self.setCursor(Qt.ArrowCursor)
+ self.setGeometry(
+ 0, 0,
+ self.radius*2,
+ self.radius*2)
+
+ self.setStyleSheet(f"""
+ QPushButton [
+ border: {self._style.border_thickness}px
+ {self._color_to_str(self._style.border_color)};
+ border-radius: {self.radius}px;
+ border-style: outset;
+ background: {self._color_to_str(self._style.background_color)};
+ qproperty-iconSize:{round(self.radius*1.5)}px;
+ ]
+ QPushButton:hover [
+ background: {self._color_to_str(self._style.active_color)};
+ ]
+ """.replace('[', '{').replace(']', '}')
+ )
+
+ @staticmethod
+ def _color_to_str(color: QColor) -> str: return f'''rgba(
+ {color.red()}, {color.green()}, {color.blue()}, {color.alpha()})'''
diff --git a/shortcut_composer/templates/pie_menu_utils/circle_points.py b/shortcut_composer/templates/pie_menu_utils/widget_utils/circle_points.py
similarity index 94%
rename from shortcut_composer/templates/pie_menu_utils/circle_points.py
rename to shortcut_composer/templates/pie_menu_utils/widget_utils/circle_points.py
index 6a136911..7c8739fe 100644
--- a/shortcut_composer/templates/pie_menu_utils/circle_points.py
+++ b/shortcut_composer/templates/pie_menu_utils/widget_utils/circle_points.py
@@ -21,11 +21,11 @@ class CirclePoints:
- iterate over points, when the circle is divided into even parts
"""
- def __init__(self, center: QPoint, radius: int):
+ def __init__(self, center: QPoint, radius: int) -> None:
self._center = center
self._radius = radius
- def distance(self, point: QPoint):
+ def distance(self, point: QPoint) -> float:
"""Count distance between pie center and cursor position."""
distance = (self._center.x() - point.x()) ** 2
distance += (self._center.y() - point.y()) ** 2
diff --git a/shortcut_composer/templates/pie_menu_utils/widget_utils/edit_mode.py b/shortcut_composer/templates/pie_menu_utils/widget_utils/edit_mode.py
new file mode 100644
index 00000000..d0f0c73a
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/widget_utils/edit_mode.py
@@ -0,0 +1,44 @@
+from enum import Enum
+from composer_utils import Config
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+ from ..pie_widget import PieWidget
+
+
+class EditMode:
+ """
+ Descriptor that handles the edit mode of PieWidget.
+
+ When red from, it returns a bool telling whether the Pie is in edit mode.
+ When mode is changed, changes the Pie's components to reflect that.
+ Whe edit mode is turned off, saves the current values to settings.
+ """
+
+ def __init__(self) -> None:
+ self._edit_mode = False
+
+ def __get__(self, *_) -> bool:
+ """Return whether the Pie is in edit mode"""
+ return self._edit_mode
+
+ def __set__(self, obj: 'PieWidget', mode_to_set: bool) -> None:
+ """Update the mode and change Pie's content accordingly."""
+ if not mode_to_set and self._edit_mode:
+ self._write_settings(obj)
+
+ self._edit_mode = mode_to_set
+ if mode_to_set:
+ obj.accept_button.show()
+ else:
+ obj.accept_button.hide()
+
+ def _write_settings(self, obj: 'PieWidget') -> None:
+ """If values were not hardcoded, but from config, write them back."""
+ if not obj.labels or obj.config_to_write_back is None:
+ return
+
+ values = [widget.label.value for widget in obj.widget_holder]
+ if isinstance(values[0], Enum):
+ obj.config_to_write_back.write(Config.format_enums(values))
+ else:
+ obj.config_to_write_back.write('\t'.join(values))
diff --git a/shortcut_composer/templates/pie_menu_utils/widget_utils/pie_painter.py b/shortcut_composer/templates/pie_menu_utils/widget_utils/pie_painter.py
new file mode 100644
index 00000000..44cc70da
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/widget_utils/pie_painter.py
@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import List
+from dataclasses import dataclass
+
+from PyQt5.QtCore import QPoint
+from PyQt5.QtGui import QColor
+
+from api_krita.pyqt import Painter
+from ..pie_style import PieStyle
+from ..label import Label
+
+
+@dataclass
+class PiePainter:
+ """Uses provided painter and parts of widget information to paint it."""
+
+ painter: Painter
+ labels: List[Label]
+ style: PieStyle
+ edit_mode: bool
+
+ def __post_init__(self):
+ """Paint the widget which created the passed painter."""
+ self._paint_deadzone_indicator()
+ self._paint_base_wheel()
+ self._paint_active_pie()
+ self._paint_base_border()
+
+ @property
+ def _center(self) -> QPoint:
+ """Return point with center widget's point in its coordinates."""
+ return QPoint(self.style.widget_radius, self.style.widget_radius)
+
+ def _paint_deadzone_indicator(self) -> None:
+ """Paint the circle representing deadzone, when its valid."""
+ if self.style.deadzone_radius == float("inf"):
+ return
+
+ self.painter.paint_wheel(
+ center=self._center,
+ outer_radius=self.style.deadzone_radius,
+ color=QColor(128, 255, 128, 120),
+ thickness=1,
+ )
+ self.painter.paint_wheel(
+ center=self._center,
+ outer_radius=self.style.deadzone_radius-1,
+ color=QColor(255, 128, 128, 120),
+ thickness=1,
+ )
+
+ def _paint_base_wheel(self) -> None:
+ """Paint a base circle."""
+ # NOTE: Windows10 does not treat the transparent center as part
+ # of the widget, so a low opacity circle allows to trick it.
+ self.painter.paint_wheel(
+ center=self._center,
+ outer_radius=self.style.no_border_radius,
+ color=QColor(128, 128, 128, 1),
+ )
+ self.painter.paint_wheel(
+ center=self._center,
+ outer_radius=self.style.no_border_radius,
+ color=self.style.background_color,
+ thickness=self.style.area_thickness,
+ )
+
+ def _paint_base_border(self) -> None:
+ """Paint a border on the inner edge of base circle."""
+ self.painter.paint_wheel(
+ center=self._center,
+ outer_radius=self.style.inner_edge_radius,
+ color=self.style.border_color,
+ thickness=self.style.border_thickness,
+ )
+
+ def _paint_active_pie(self) -> None:
+ """Paint a pie behind a label which is active or during animation."""
+ for label in self.labels:
+ if not label.activation_progress.value:
+ continue
+
+ thickness_addition = round(
+ 0.15 * label.activation_progress.value
+ * self.style.area_thickness)
+
+ self.painter.paint_pie(
+ center=self._center,
+ outer_radius=self.style.no_border_radius + thickness_addition,
+ angle=label.angle,
+ span=360//len(self.labels),
+ color=self._pick_pie_color(label),
+ thickness=self.style.area_thickness + thickness_addition,
+ )
+
+ def _pick_pie_color(self, label: Label) -> QColor:
+ """
+ Pick color of pie based on widget mode and animation progress.
+
+ In edit mode color is different to create visual distinction.
+ Two similar colors are merged with animated opacity to
+ distinguish two consequtive pies from each other.
+ """
+ if not self.edit_mode:
+ return self._overlay_colors(
+ self.style.active_color_dark,
+ self.style.active_color,
+ opacity=label.activation_progress.value)
+ return self._overlay_colors(
+ self.style.icon_color,
+ self.style.border_color,
+ opacity=label.activation_progress.value)
+
+ @staticmethod
+ def _overlay_colors(base: QColor, over: QColor, opacity: float) -> QColor:
+ """Merge two colors by overlaying one on another with given opacity."""
+ opacity_negation = 1-opacity
+ return QColor(
+ round(base.red()*opacity_negation + over.red()*opacity),
+ round(base.green()*opacity_negation + over.green()*opacity),
+ round(base.blue()*opacity_negation + over.blue()*opacity))
diff --git a/shortcut_composer/templates/pie_menu_utils/widget_utils/widget_holder.py b/shortcut_composer/templates/pie_menu_utils/widget_utils/widget_holder.py
new file mode 100644
index 00000000..b1061f75
--- /dev/null
+++ b/shortcut_composer/templates/pie_menu_utils/widget_utils/widget_holder.py
@@ -0,0 +1,62 @@
+# SPDX-FileCopyrightText: © 2022 Wojciech Trybus
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Dict, Iterator, Optional
+from ..label_widget import LabelWidget
+
+
+class WidgetHolder:
+ """
+ Holds LabelWidgets and in relation to their angles on PieWidget.
+
+ Holds which of them is active (One of them None), but does not
+ handle this attribute by itself - this is done by PieManager.
+ """
+
+ def __init__(self):
+ self._widgets: Dict[int, LabelWidget] = {}
+ self.active: Optional[LabelWidget] = None
+
+ def add(self, widget: LabelWidget) -> None:
+ """Add a new LabelWidget to the holder."""
+ self._widgets[widget.label.angle] = widget
+
+ def angles(self) -> Iterator[int]:
+ """Iterate over all angles at which LabelWidgets are."""
+ return iter(self._widgets.keys())
+
+ def on_angle(self, angle: float) -> LabelWidget:
+ """Return LabelWidget which is the closest to given `angle`."""
+
+ def angle_difference(label_angle: float) -> float:
+ """Return the smallest difference between two angles."""
+ nonlocal angle
+ raw_difference = label_angle - angle
+ return abs((raw_difference + 180) % 360 - 180)
+
+ closest = min(self.angles(), key=angle_difference)
+ return self._widgets[closest]
+
+ def angle(self, widget: LabelWidget) -> int:
+ """Return at which angle angle is the given LabelWidget."""
+ for angle, held_widget in self._widgets.items():
+ if widget == held_widget:
+ return angle
+ raise ValueError(f"{widget} not in holder.")
+
+ def swap(self, _a: LabelWidget, _b: LabelWidget) -> None:
+ """Swap two LabelWidgets that are already in the holder."""
+ _a.label.swap_locations(_b.label)
+ key_a, key_b = self.angle(_a), self.angle(_b)
+ self._widgets[key_a], self._widgets[key_b] = _b, _a
+ _a.move_to_label()
+ _b.move_to_label()
+
+ def __iter__(self) -> Iterator[LabelWidget]:
+ """Iterate over all held LabelWidgets."""
+ for angle in sorted(self.angles()):
+ yield self._widgets[angle]
+
+ def __len__(self) -> int:
+ """Return amount of held LabelWidgets."""
+ return len(self._widgets)