small improvements

Author: lbalazscs

src/main/java/pixelitor/filters/gui/PresetOwner.java

@@ -115,7 +115,9 @@ default Action createSavePresetAction(Component parent,
             savePreset(parent, menuAdder, menuRemover));
     }
 
-    private void savePreset(Component parent, Consumer<UserPreset> menuAdder, Consumer<UserPreset> menuRemover) {
+    private void savePreset(Component parent,
+                            Consumer<UserPreset> menuAdder,
+                            Consumer<UserPreset> menuRemover) {
         String presetName = Dialogs.showInputDialog(
             parent, "Preset Name", "Preset Name:");
         if (presetName == null || presetName.isBlank()) {
@@ -130,11 +132,12 @@ private void savePreset(Component parent, Consumer<UserPreset> menuAdder, Consum
             if (!overwrite) {
                 return;
             }
-            // remove the overwritten preset from the menus
+            // if the user overwrites an existing preset,
+            // remove the old menu item before adding the new one
             menuRemover.accept(preset);
         }
         preset.save();
-        menuAdder.accept(preset);
+        menuAdder.accept(preset); // add the new preset to the menu
     }
 
     private static boolean confirmOverwrite(Component parent, String presetName) {

src/main/java/pixelitor/filters/gui/UserPreset.java

@@ -314,8 +314,8 @@ public Action createAction(PresetOwner owner) {
     }
 
     /**
-     * Detects all presets in the given directory by listing files.
-     * The presets' contents are not loaded into memory.
+     * Detects all presets in the given directory by listing files
+     * ending in ".txt". The presets' contents are not loaded into memory.
      */
     public static List<UserPreset> detectPresetNames(String presetDirName) {
         File presetsDir = getSaveDir(presetDirName);

src/main/java/pixelitor/gui/PixelitorWindow.java

@@ -73,23 +73,19 @@ private PixelitorWindow() {
         workSpace = new WorkSpace();
 
         Dimension screenSize = Screens.getMaxWindowSize();
+        AppPreferences.loadFramePreferences(this, screenSize);
 
         addMenuBar();
         addImageArea();
         addSidePanel();
+        addStatusBar();
         addToolsPanel(screenSize);
         Tools.setDefaultTool();
-        addStatusBar();
 
         initIcons();
 
         GlobalEvents.init();
 
-        initWindow(screenSize);
-    }
-
-    private void initWindow(Dimension screenSize) {
-        AppPreferences.loadFramePreferences(this, screenSize);
         if (JVM.isWindows) {
             // this is tricky code that had problems on Linux
             setupRememberingLastBounds();

src/main/java/pixelitor/tools/Tool.java

@@ -348,15 +348,6 @@ public char getHotkey() {
         return hotkey;
     }
 
-    /**
-     * Returns whether this tool shares its hotkey with other tools.
-     * A tool shares its key when it's part of a tool group where
-     * multiple tools can be activated by the same keyboard shortcut.
-     */
-    public boolean hasSharedHotkey() {
-        return false;
-    }
-
     public boolean hasPixelSnapping() {
         return pixelSnapping;
     }

src/main/java/pixelitor/tools/Tools.java

@@ -44,6 +44,7 @@
 
 import java.awt.event.MouseEvent;
 import java.awt.geom.AffineTransform;
+import java.util.List;
 
 /**
  * Tool-related static utility methods
@@ -235,6 +236,17 @@ public static void maskEditingChanged(boolean maskEditing) {
         activeTool.maskEditingChanged(maskEditing);
     }
 
+    /**
+     * Returns the tool groups where a single hotkey is used to cycle through the tools.
+     */
+    public static List<Tool[]> getSharedHotkeyGroups() {
+        return List.of(
+            new Tool[]{RECTANGLE_SELECTION, ELLIPSE_SELECTION}, // M
+            new Tool[]{LASSO_SELECTION, POLY_SELECTION}, // L
+            new Tool[]{PEN, NODE, TRANSFORM_PATH} // P
+        );
+    }
+
     public static class EventDispatcher {
         private static boolean mouseDown = false;
         private static PMouseEvent lastEvent;

src/main/java/pixelitor/tools/gui/ToolButton.java

@@ -59,7 +59,7 @@ public ToolButton(Tool tool) {
         setToolTipText("<html>" + tool.getName()
             + " (<b>" + tool.getHotkey() + "</b>)");
 
-        // Adds a listener to activate the tool when the button is selected.
+        // Activates the tool when the button is selected.
         // An item listener is better than an action listener because it
         // is also triggered by keyboard focus traversal selections.
         addItemListener(e -> {
@@ -75,6 +75,7 @@ public ToolButton(Tool tool) {
 
     @Override
     public void updateUI() {
+        // this method can be called by the super constructor before 'tool' is initialized
         if (tool != null) { // changing the theme
             setupIcons(tool);
         }
@@ -91,6 +92,10 @@ private void setupIcons(Tool tool) {
         setSelectedIcon(selectedIcon);
     }
 
+    /**
+     * Creates a right-click popup menu that can be used to save, load,
+     * and manage configuration presets for the tool represented by this button.
+     */
     private void initPresetsPopup(Tool tool) {
         List<UserPreset> startupPresets = UserPreset.detectPresetNames(tool.getPresetDirName());
         numPresets = startupPresets.size();
@@ -106,6 +111,7 @@ private void initPresetsPopup(Tool tool) {
         presetsMenu.add(tool.createSavePresetAction(this,
             this::addPresetMenuItem, this::removePresetMenuItem));
 
+        // if any existing presets were detected, add them to the menu
         if (!startupPresets.isEmpty()) {
             if (GUIUtils.CAN_USE_FILE_MANAGER) {
                 presetsMenu.add(tool.createManagePresetsAction());
@@ -119,17 +125,28 @@ private void initPresetsPopup(Tool tool) {
         setComponentPopupMenu(presetsMenu);
     }
 
+    /**
+     * Callback to dynamically add a new menu item to the presets
+     * menu after a user has successfully saved a new preset.
+     */
     private void addPresetMenuItem(UserPreset preset) {
         if (numPresets == 0) {
+            // if this is the very first preset being added, then this
+            // was not added during initialization, so add it now
             if (GUIUtils.CAN_USE_FILE_MANAGER) {
                 presetsMenu.add(tool.createManagePresetsAction());
             }
             presetsMenu.addSeparator();
         }
+
         presetsMenu.add(preset.createAction(tool));
         numPresets++;
     }
 
+    /**
+     * Callback to dynamically remove the old menu item
+     * when the user overwrites an existing preset.
+     */
     private void removePresetMenuItem(UserPreset preset) {
         Component[] menuComponents = presetsMenu.getComponents();
         for (Component item : menuComponents) {

src/main/java/pixelitor/tools/gui/ToolsPanel.java

@@ -21,6 +21,8 @@
 import pixelitor.colors.FgBgColors;
 import pixelitor.gui.GlobalEvents;
 import pixelitor.gui.PixelitorWindow;
+import pixelitor.gui.StatusBar;
+import pixelitor.gui.WorkSpace;
 import pixelitor.gui.utils.TaskAction;
 import pixelitor.layers.AddTextLayerAction;
 import pixelitor.tools.Tool;
@@ -30,6 +32,10 @@
 import java.awt.BorderLayout;
 import java.awt.Dimension;
 import java.awt.event.ActionEvent;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 /**
  * The panel with the tool buttons and the color selector
@@ -38,41 +44,69 @@ public class ToolsPanel extends JPanel {
     public ToolsPanel(PixelitorWindow pw, Dimension screenSize) {
         Dimension buttonSize = calcToolButtonSize(screenSize, pw);
 
-        // We need to give a hint to the layout manager, but at
-        // this point neither the panel nor the window size is known.
-        int heightHint = Math.max(screenSize.height - 168, 0);
+        JComponent colorSelector = createColorSelector(pw);
+        int heightHint = calcHeightHint(pw, colorSelector, buttonSize);
 
         JPanel buttonsPanel = new JPanel(new ToolButtonsLayout(buttonSize.width, buttonSize.height, 0, heightHint));
         addToolButtons(buttonsPanel);
 
         setLayout(new BorderLayout());
         add(buttonsPanel, BorderLayout.CENTER);
-        addColorSelector(pw);
+        add(colorSelector, BorderLayout.SOUTH);
 
         setupTShortCut();
     }
 
-    private static void addToolButtons(JPanel toolsPanel) {
+    private static int calcHeightHint(PixelitorWindow pw, JComponent colorSelector, Dimension buttonSize) {
+        // get the preferred heights of all other components that take up vertical space.
+        int menuBarHeight = pw.getJMenuBar().getPreferredSize().height;
+        WorkSpace workSpace = pw.getWorkSpace();
+        int toolSettingsHeight = workSpace.areToolsVisible() ? ToolSettingsPanelContainer.get().getPreferredSize().height : 0;
+        int statusBarHeight = workSpace.isStatusBarVisible() ? StatusBar.get().getPreferredSize().height : 0;
+        int colorSelectorHeight = colorSelector.getPreferredSize().height;
+
+        // the window's insets include the title bar
+        int windowInsetsHeight = pw.getInsets().top + pw.getInsets().bottom;
+
+        // sum of all vertical space NOT available to the buttons panel
+        int totalOtherHeight = menuBarHeight + toolSettingsHeight + statusBarHeight + colorSelectorHeight + windowInsetsHeight;
+
+        // the total window height minus all other components
+        int heightHint = pw.getHeight() - totalOtherHeight;
+
+        // ensure the hint is a positive value
+        heightHint = Math.max(heightHint, buttonSize.height);
+        return heightHint;
+    }
+
+    private static void addToolButtons(JPanel buttonContainer) {
         ButtonGroup group = new ButtonGroup();
-        Tool[] tools = Tools.getAll();
-        for (Tool tool : tools) {
+
+        List<Tool[]> sharedHotkeyGroups = Tools.getSharedHotkeyGroups();
+        for (Tool[] toolGroup : sharedHotkeyGroups) {
+            setupSharedHotkey(toolGroup);
+        }
+
+        Set<Tool> toolsWithSharedHotkeys = new HashSet<>();
+        for (Tool[] toolGroup : sharedHotkeyGroups) {
+            Collections.addAll(toolsWithSharedHotkeys, toolGroup);
+        }
+
+        for (Tool tool : Tools.getAll()) {
             ToolButton toolButton = new ToolButton(tool);
-            toolsPanel.add(toolButton);
+            buttonContainer.add(toolButton);
             group.add(toolButton);
-            if (!tool.hasSharedHotkey()) {
+
+            if (!toolsWithSharedHotkeys.contains(tool)) {
                 setupHotkey(tool);
             }
         }
-        // manually register the hotkeys of the sharing tools
-        setupSharedHotkey(Tools.RECTANGLE_SELECTION, Tools.ELLIPSE_SELECTION);
-        setupSharedHotkey(Tools.LASSO_SELECTION, Tools.POLY_SELECTION);
-        setupSharedHotkey(Tools.PEN, Tools.NODE, Tools.TRANSFORM_PATH);
     }
 
-    private void addColorSelector(PixelitorWindow pw) {
+    private static JComponent createColorSelector(PixelitorWindow pw) {
         FgBgColorSelector colorSelector = new FgBgColorSelector(pw);
         FgBgColors.setUI(colorSelector);
-        add(colorSelector, BorderLayout.SOUTH);
+        return colorSelector;
     }
 
     private static void setupTShortCut() {
@@ -103,17 +137,17 @@ private static Dimension calcToolButtonSize(Dimension screen, PixelitorWindow pw
     }
 
     private static void setupHotkey(Tool tool) {
-        Action activateAction = new TaskAction(() -> {
+        Action activateToolAction = new TaskAction(() -> {
             if (Tools.activeTool != tool) {
                 tool.activate();
             }
         });
 
-        GlobalEvents.registerHotkey(tool.getHotkey(), activateAction);
+        GlobalEvents.registerHotkey(tool.getHotkey(), activateToolAction);
     }
 
     private static void setupSharedHotkey(Tool... sharingTools) {
-        Action multiToolAction = new AbstractAction() {
+        Action cycleToolsAction = new AbstractAction() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 int activeIndex = -1;
@@ -130,7 +164,8 @@ public void actionPerformed(ActionEvent e) {
                 sharingTools[nextIndex].activate();
             }
         };
+        // all tools in a group are expected to have the same hotkey
         char key = sharingTools[0].getHotkey();
-        GlobalEvents.registerHotkey(key, multiToolAction);
+        GlobalEvents.registerHotkey(key, cycleToolsAction);
     }
 }

src/main/java/pixelitor/tools/pen/NodeTool.java

@@ -77,6 +77,9 @@ protected void toolDeactivated(View view) {
         super.toolDeactivated(view);
 
         lastActive = null;
+        if (view == null) {
+            return;
+        }
         view.repaint(); // hide the path
     }
 

src/main/java/pixelitor/tools/pen/PathTool.java

@@ -58,11 +58,6 @@ public void initSettingsPanel(ResourceBundle resources) {
             "Delete the path");
     }
 
-    @Override
-    public boolean hasSharedHotkey() {
-        return true;
-    }
-
     /**
      * Removes a path from the composition, without adding a history edit.
      */

src/main/java/pixelitor/tools/pen/PenTool.java

@@ -132,6 +132,9 @@ protected void toolActivated(View view) {
     @Override
     protected void toolDeactivated(View view) {
         super.toolDeactivated(view);
+        if (view == null) {
+            return;
+        }
 
         Path path = view.getComp().getActivePath();
         if (path != null) {