New additions/improvements to Pie Menus

[Don-Dori]

Hi, and first I must say a big thank you for this plugin. A game changer for Krita experience!

After using available features for a while now, I've had some ideas that could further improve Pie Menus.

Pick Brush Preset Pie menus

• Adding an option to set desired Brush Smoothing mode for the Pie menu in use. This could be an option within Pie Menu Preferences (although it wouldn't make much sense to show this in other pie menus, unless it could show up only in Pick Brush Preset Pie menus) or at top of "Values" tab as that's where we pick presets. This would allow user to have stabilization set up for let's say inking/drawing brushes in one Pie Menu while painting or eraser presets on another Pie Menu could have it turned off. This could even include Dynamic Brush Tool as one of the selectable Smoothing modes but in that case it would have to swap to proper Brush Tool depending on the mode.
• Adding an option to set desired Eraser mode. Another option similar to above that would ensure proper erase mode when swapping presets within and between pie menus. Example: let's say one Pie menu is set to Erase mode ON for "Erasers" and other set to Erase mode OFF for Paint presets, selecting a preset within "Erasers" Pie menu would ensure the Eraser mode is toggled on while selecting a preset from "Paint" pie menu would toggle it off. This would allow use of any preset as either Eraser or Paint brush as in having two different tools (many have been asking for dedicated Eraser tool) while still allowing temporary/manual Erase mode toggle.
• Extra pies - Cyan, Magenta and Yellow. This one is easily added by user but we have RGB so why not CMY as well 😄
  Having 6 menus I personally use them for Erasers, Basic, Drawing/Inking, Smudges, Extras, Textures. The current "Local" could be black (Key) and white style instead of Yellow.

Pick Blend Mode and Create Layer with Blend mode menus

• Add missing new blending modes: Lambert Lighting (Linear) and Lambert Lighting (Gamma 2.2). Values are "lambert_lighting" and "lambert_lighting_gamma2.2" respectively.

All Pie menus

• Short and long key press behavior. When pie menu behavior is set to either "Pick Top" or "Pick Previous" a short key press could simply swap preset/tool/useAction without flashing Pie Menu, while long key press hold would open Pie menu normally. This would avoid unintentional preset/tool/action swaps/use when quickly changing from one pie menu to another with intent to pick top or previous and accidentally going out of deadzone. The deadzone function would still be used for when Pie menu is open with key hold.

The smoothing part I've hardcoded myself and it's working flawlessly, although having a quick access to change desired smoothing within Pie Menu in Krita would be cool. Also I know there have been talks about built-in feature that would use different (Brush Smoothing off) for Erase mode but having an option to change to different smoothing on the fly without using extra shortcuts is always good imo.
The Ensure correct eraser mode I'm unsure how to implement because if I use available EnsureOn/Off methods it happens on Key press rather than preset swap so in case Erase is on and swapping to preset that should be on again it will negate and toggle it off. Using dedicated eraser presets with Erase blend mode is one way to go but it's just an idea that could solve the issue many have with no dedicated Eraser tool (Pie menu could act as one).

[wojtryb]

Hi,

I'm glad you like my plugin, and thank you for your input. I'll do my best to comment on all of those.

• You said you hardcoded the smoothing features yourself. Did you use Instructions, and activated smoothing actions on key press? Or did you use a action pie menu that sets smoothing type. I checked that those are achieved via krita actions, so I guess there are pies capable of that. Anyway this topic is not that clear to me, as I don't really change smoothing myself.
• I like the idea of pie that sets an eraser mode, and can use any preset to change it into an eraser. I would do it with the EnsureOn Instruction, but I don't really understand your concerns about it. I do see a problem that all the other pies would have to get EnsureOff, which is not what you expect, when you just add eraser presets to usual pie. So that can't be done for now unless there is a good idea how it should work.
• It's great you managed to get more preset pies, but I think that 4 pies are already a lot for an average user. If somebody really needs more, they can add those the way you did, but it feels wrong to spam too many of those "just in case".
• Thanks for pointing out those blending modes.
• That's something I considered, but there is a problem with that. You don't know if a key press is short or long before you wait to find out. Your idea would mean having to delay opening of the pie, which could get pretty annoying for some people used to doing things quick.

[wojtryb]

For the smoothing and eraser: Probably both of those would become possible if the instructions would get redesigned.

Instructions were implemented before the 1.0.0 release - way before configuration of the pie menus was possible. They work good enough for injecting some logic to the specific pie without creating a new class, but they can miss a few possibilities like triggering after the main actions, or on steps specific to the action type. Also what's more important, they are not designed with GUI in mind.

I guess that when the user could add and remove instructions from the pie, add some actions on different steps (which could include steps specific to the pie), you could achieve both your smoothing and eraser requests.

GUI for instructions seems like a huge feature and can be an overkill only a small group of users would need, but some redesign analysis on the instructions could a good idea, as it could make the feature more versatile. And if GUI for that is ever to be created, it won't be possible before this redesign.

---

For the short/long behavior - the whole action could be delayed by a short time (so that the pie appears on mouse position AFTER the time passes), but I'm not sure I want to change this, as the current solution still feels good enough to me.

[Don-Dori]

I see, that explains everything. Maybe just a thought for some distant future update then if more ideas come up with the need of such functionality. For my own use case the "hack" way will do.

Thank you for your time!

[Don-Dori]

Hi again,

got some update regarding the idea of "dedicated eraser preset pie". I've managed to implement a working solution but have a few questions first before considering a possible merge (if you show interest).

After some thinking, instead of an option to set any Preset Pie as an "Eraser Pie" , I've decided that a better solution is a separate Pie acting as dedicated "Eraser" Tool where any preset changes to eraser while the remaining Preset Pies are "Paint" Brush Tools where preset sets to paint mode allowing immediate painting, without having to manually turn off any leftover erase toggles. There is no need for multiple "Eraser" Tool Pies. (But like with existing Preset Pies, user can manually add extra "Eraser" Pies by adding extra actions manually in code.)

This I've achieved by adding one new action named "Pick eraser presets" that uses a new "EraserController()" controller. Following code blocks are only sections with changes/additions to avoid large blocks here.
The EraserController() is the same as PresetController() with one main difference:

• shortcut_composer\core_components\controllers\view_controllers.py:

class EraserController(ViewBasedController, Controller[str]):
...
def set_value(self, value: str) -> None:
        """Set a preset of passed name acting as "Eraser". After set, turn Erase mode to 'On' if it was set with 'Off' state."""
        self.view.brush_preset = value
        if not Toggle.state.fget(Toggle.ERASER):
            Toggle.state.fset(Toggle.ERASER, True)
...

class PresetController(ViewBasedController, Controller[str]):
...
def set_value(self, value: str) -> None:
        """
        Set a preset of passed name.
        - After set, turn Erase mode to 'Off' if it was set with 'On' state  
        - If user wants to keep Eraser mode 'On' for any preset in "Preset Pies" 
            changing its Blending Mode to "Erase" will ensure it stays in Erase mode 'On'
        """
        self.view.brush_preset = value
        if (Toggle.state.fget(Toggle.ERASER)) and (self.view.blending_mode != BlendingMode.ERASE):
            Toggle.state.fset(Toggle.ERASER, False)
        elif (self.view.blending_mode == BlendingMode.ERASE) and (not Toggle.state.fget(Toggle.ERASER)):
            Toggle.state.fset(Toggle.ERASER, True)
...

This method still allows manually changing Erase mode On or Off for any preset in both Pie types and even allow user to manually set persisting Eraser presets on Paint Pies but swapping presets between/within Pies with Pie shortcuts will always toggle correct modes,

1. First question: Would a return be necessary before Toggle set in these If/Elif checks? Or it doesn't make any difference? (Works either way but unsure what are the norms)
2. Second question: As I've created a new controller EraserController() do I need dedicated pie settings/config implementations (see below) that I also dispatch via dispatch files same as for PresetController() or is this not necessary as it seemingly doesn't make a difference? (Is same controller.TYPE)

• shortcut_composer\templates\pie_menu_utils\pie_settings_impl\eraser_pie_settings.py
• shortcut_composer\templates\pie_menu_utils\pie_config_impl\eraser_pie_config.py

This part in preset_pie_settings.py is what first got me thinking I need it's own config/setting files and everything:

class PresetGroupManager(GroupManager):

    known_labels: dict[str, PieLabel | None] = {}

    def __init__(self) -> None:
        self._controller = PresetController()   <---- Here ---

But I suppose the controller EraserController() takes dispatched PresetPieSettings as its controller.TYPE is also string?

Either way, this solution is working as expected without any issues (none popped within a few days of use). If you like the idea I'll do my best to make necessary changes if you consider it a worthy addition.

Regards 🙇

[wojtryb]

Hi, sorry for the late response, but I was a bit busy lately.

It's great you managed to get a feature you needed! More correct way to write it in terms of python syntax would be something like this. Docstrings still exceed 79 characters per line, but at least those properties are less weird :)

def set_value(self, value: str) -> None:
    """Set a preset of passed name acting as "Eraser". After set, turn Erase mode to 'On'"""
    self.view.brush_preset = value
    Toggle.ERASER.state = True


def set_value(self, value: str) -> None:
    """
    Set a preset of passed name.
    - After set, turn Erase mode to 'Off' if it was set with 'On' state
    - If user wants to keep Eraser mode 'On' for any preset in "Preset Pies"
        changing its Blending Mode to "Erase" will ensure it stays in Erase mode 'On'
    """
    self.view.brush_preset = value
    Toggle.ERASER.state = self.view.blending_mode == BlendingMode.ERASE

It is a great hack, but it is not correct architecture-wise. Concept of those controllers was for each of them to control a single krita property. When you start doing two or more things at a time, you will soon be having a ton of weird controllers that do many different combinations of krita actions at once. Those are also not applicable in any other place in code apart from the one you wanted it initially.

Instructions were the concept of doing additional things during the action - and that is the place where something like this should be done. As you know it is not possible right now, as there is no way to run instructions after the main action instead of before it.

I have started working on instructions refactor, but it did not go that well, and I do not think I will be accepting those changes. On the other hand - I am not sure I want the "eraser pie" shipped with the plugin. It is a rather specific feature after all, and I am not sure it would be used by users other than you :) Anyway I will remember about it.

[Don-Dori]

Hi, no worries, we all have our schedules.

It's true my initial syntax was messy and too long, was trying to avoid any unnecessary action triggers as Erase blend mode visually automatically sets eraser even if it's actually "off" in preset settings. Also figured I had a wrong logic on top of it being weird and long so then I simplified it to (the best I could think of to fit it in 78 chars):

def set_value(self, value: str) -> None:
        """Set a preset of passed name in "Paint" mode"""
        self.view.brush_preset = value
        self.eraser_mode = Toggle.ERASER.state

        if self.view.blending_mode == BlendingMode.ERASE:
            pass
        elif self.eraser_mode:
            Toggle.ERASER.state = False
            
def set_value(self, value: str) -> None:
        """Set a preset of passed name in "Eraser" mode."""
        self.view.brush_preset = value
        self.eraser_mode = Toggle.ERASER.state

        if self.view.blending_mode == BlendingMode.ERASE:
            pass
        elif not self.eraser_mode:
            Toggle.ERASER.state = True

This worked fine, avoiding unnecessary triggers and everything. However, like with every other "dedicated eraser" plugin solution, last night I realized there's still one issue with it and no easy way to address. That's if user wants to use same preset but different size, opacity or flow for eraser vs paint mode. That would require writing/reading those settings on every swap and that would possibly introduce some lag on top of everything.

So in short I'm pretty much throwing that idea away as this is best left for Krita team to do a proper dedicated eraser tool implementation for those that want/need it (although I don't see it happening even if it's a hot topic on forums). It's still less hassle and better to use separate Erase blend mode presets that don't affect paint preset settings in any way and your shortcut composer pies allow to have them all on 1 button.
In all this at least I learned something new and found a solution to ensure paint mode for all non-Erase presets on every swap (if there are any leftover toggles) so I'll probably keep that myself xD

Anyways, thanks again for everything. Looking forward to any new possibilities with this plugin!