MouseListener erweitern

[MJannek]

Ich habe mir eine Erweiterung des Interface MouseListener erstellt

package javaext.awt.event.listener.mouse;

import java.awt.event.*;

public interface CustomMouseListener extends MouseListener {
    void mouseDoubleClicked(MouseEvent e);
    void mouseRightClicked(MouseEvent e);
}

package javaext.awt.event.listener.mouse;

import java.awt.event.*;

public abstract class MouseListenerX implements CustomMouseListener {
    private long lastClickTime = 0;
    private int clickCount = 0;

    @Override
    public void mouseClicked(MouseEvent e) {
        long clickTime = System.currentTimeMillis();

        if (clickCount == 1 && (clickTime - lastClickTime < 500)) {
            mouseDoubleClicked(e);
            clickCount = 0;
        } else {
            clickCount = 1;
        }
        lastClickTime = clickTime;
    }
    @Override
    public abstract void mouseDoubleClicked(MouseEvent e);
    @Override
    public abstract void mouseRightClicked(MouseEvent e);
    @Override
    public abstract void mousePressed(MouseEvent e);

    @Override
    public abstract void mouseReleased(MouseEvent e);

    @Override
    public abstract void mouseEntered(MouseEvent e);

    @Override
    public abstract void mouseExited(MouseEvent e);
}

Kann man die abstrakte Klasse MouseListenerX als Interface darstellen, sodass folgender immer ausgeführt wird, auch wenn die Methode überschrieben wird.

    @Override
    public void mouseClicked(MouseEvent e) {
        long clickTime = System.currentTimeMillis();

        if (clickCount == 1 && (clickTime - lastClickTime < 500)) {
            mouseDoubleClicked(e);
            clickCount = 0;
        } else {
            clickCount = 1;
        }
        lastClickTime = clickTime;
    }

Ich möchte nach Möglichkeit nicht jedes mal wenn ich die Methode überschreibe folgenden Aufrufen

    @Override
    public void mouseClicked(MouseEvent e) {
        super.mouseClicked(e);
//neuer Code
    }

sondern

    @Override
    public void mouseClicked(MouseEvent e) {
        //neuer Code
    }

button.addMouseListener(new MouseListenerX() {
    @Override
    public void mouseClicked(MouseEvent e) {
        super.mouseClicked(e);
}

    @Override
    public void mouseDoubleClicked(MouseEvent e) {
System.out.print(2);
    }

    @Override
    public void mouseRightClicked(MouseEvent e) {

    }

    @Override
    public void mousePressed(MouseEvent e) {

    }

    @Override
    public void mouseReleased(MouseEvent e) {

    }

    @Override
    public void mouseEntered(MouseEvent e) {

    }

    @Override
    public void mouseExited(MouseEvent e) {

    }
});

frame.add(button);
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
    }

Das ist meine derzeitige Testnutzung. Vielen Dank

 

[mihe7]

Warum willst Du die Methode denn überschreiben? Du könntest z. B. auch eine Methode am Ende aufrufen.

Übrigens hat das MouseEvent eine Methode getClickCount(), die die Zahl der Klicks zurückgibt.

 

[MJannek]

Warum willst Du die Methode denn überschreiben? Du könntest z. B. auch eine Methode am Ende aufrufen.

Übrigens hat das MouseEvent eine Methode getClickCount(), die die Zahl der Klicks zurückgibt.

Danke für den Tipp. Die Methode

 @Override
    public void mouseClicked(MouseEvent e) {
        long clickTime = System.currentTimeMillis();

        if (clickCount == 1 && (clickTime - lastClickTime < 500)) {
            mouseDoubleClicked(e);
            clickCount = 0;
        } else {
            clickCount = 1;
        }
        lastClickTime = clickTime;
    }

im Interface MouseListener soll immer so ausgeführt werden, wenn ich auf ein Objekt klicke, dem ich ein MouseListenerX hinzugefügt wird.
Ich möchte die Methode public void mouseClicked(MouseEvent e) überschreiben um die eigentliche Funktionionalität hinzuzufügen (z.B. Ausgabe des Textes der auf dem Objekt steht). Dabei soll es aber weiterhin möglich sein eine Aktion per Doppelklick auszulösen.

 

[Oneixee5]

Du kannst die Methode als default final machen und darin eine andere Methode aufrufen, welche nicht final/überschreibbar ist.

 

[MJannek]

vielen Dank. Ich habe eine Lösung gefunden mit der ich zufrieden bin.

 

[MJannek]

Ich habe mir folgendes Interface erstellt.

package javaext.awt.event.listener.mouse;

import java.awt.event.*;

public interface CustomMouseListener extends MouseListener,MouseWheelListener, MouseMotionListener {
    void mouseDoubleClicked(MouseEvent e);

    void mouseRightClicked(MouseEvent e);

    void mouseMiddleClicked(MouseEvent e);
}

Dieses Interface wird von der abstrakten Klasse MouseListenerX implementiert.

package javaext.awt.event.listener.mouse;

import java.awt.event.*;

public abstract class MouseListenerX implements CustomMouseListener {

    @Override
    public abstract void mouseDoubleClicked(MouseEvent e);

    @Override
    public abstract void mouseRightClicked(MouseEvent e);

    @Override
    public abstract void mouseMiddleClicked(MouseEvent e);

    @Override
    public abstract void mousePressed(MouseEvent e);

    @Override
    public abstract void mouseReleased(MouseEvent e);

    @Override
    public abstract void mouseEntered(MouseEvent e);

    @Override
    public abstract void mouseExited(MouseEvent e);

    @Override
    public abstract void mouseWheelMoved(MouseWheelEvent e);

    @Override
    public abstract void mouseDragged(MouseEvent e);

    @Override
    public abstract void mouseMoved(MouseEvent e);
}

Außerdem habe ich mir noch die Klassen AdvancedMouseListener und ClickTracker erstellt.

    package javaext.awt.event.listener.mouse;

    import java.awt.event.*;
    import javaext.awt.event.*;
    public class AdvancedMouseListener extends MouseListenerX {
        private final MouseListenerX additionalListener;

        public AdvancedMouseListener(MouseListenerX listener) {
            this.additionalListener = listener;
        }

        @Override
        public void mouseClicked(MouseEvent e) {
            int btn = e.getButton();
            long lastClickTime = ClickTracker.getLastClickTime();
            long clickTime = System.currentTimeMillis();
            int clickCount = e.getClickCount();

            // Doppelklick erkennen
            if ((clickTime - lastClickTime < 500) && clickCount == 2) {
                mouseDoubleClicked(e);
                if (additionalListener != null) {
                    additionalListener.mouseDoubleClicked(e);
                }
            }

            // Den letzten Klickzeitpunkt im ClickTracker speichern
            ClickTracker.updateClickTimes(clickTime);

            // Weitere Maustastenbehandlung
            if (btn == MouseEvent.BUTTON3) {
                mouseRightClicked(e);
                if (additionalListener != null) {
                    additionalListener.mouseRightClicked(e);
                }
            }
            if (btn == MouseEvent.BUTTON2) {
                mouseMiddleClicked(e);
                if (additionalListener != null) {
                    additionalListener.mouseMiddleClicked(e);
                }
            }
        }

        @Override
        public void mouseDoubleClicked(MouseEvent e) {

        }

        @Override
        public void mouseRightClicked(MouseEvent e) {

        }

        @Override
        public void mouseMiddleClicked(MouseEvent e) {

        }

        @Override
        public void mousePressed(MouseEvent e) {
            if (additionalListener != null) {
                additionalListener.mousePressed(e);
            }
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            if (additionalListener != null) {
                additionalListener.mouseReleased(e);
            }
        }

        @Override
        public void mouseEntered(MouseEvent e) {
            if (additionalListener != null) {
                additionalListener.mouseEntered(e);
            }
        }

        @Override
        public void mouseExited(MouseEvent e) {
            if (additionalListener != null) {
                additionalListener.mouseExited(e);
            }
        }

        @Override
        public void mouseWheelMoved(MouseWheelEvent e) {
            if (additionalListener != null) {
                additionalListener.mouseWheelMoved(e);
            }
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            if (additionalListener != null) {
                additionalListener.mouseDragged(e);
            }
        }

        @Override
        public void mouseMoved(MouseEvent e) {
            if (additionalListener != null) {
                additionalListener.mouseMoved(e);
            }
        }

    }

package javaext.awt.event;

public class ClickTracker {
    private static long lastClickTime = 0;

    public static long getLastClickTime() {
        return lastClickTime;
    }


    public static void updateClickTimes(long clickTime) {
        lastClickTime = clickTime;
    }
}

Da ich mir der Erweiterung von JLabel erstellt habe und diese ein Interface implementiert, welches u.a. folgende Methoden enthält, funktioniert es nach meinen Vorstellungen.

    Component getComponent();

    private boolean isSupportedComponent(Component c) {
        return c instanceof JTextField ||
                c instanceof AbstractButton ||
                c instanceof JLabel ||
                c instanceof JPanel ||
                c instanceof JComboBox ||
                c instanceof JFrame ||
                c instanceof JMenuBar ||
                c instanceof JTabbedPane;
    }
    default void addMouseListener(MouseListenerX listener) {
        Component c = getComponent();

        // Überprüfung, ob die Komponente unterstützt wird
        if (isSupportedComponent(c)) {
            // Erstellen eines AdvancedMouseListener mit dem übergebenen Listener
            AdvancedMouseListener advancedMouseListener = new AdvancedMouseListener(listener);

            // Hinzufügen des erweiterten Listeners
            c.addMouseListener(advancedMouseListener);
            c.addMouseMotionListener(advancedMouseListener);
            c.addMouseWheelListener(advancedMouseListener);
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for components implementing " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }

Ich hatte mir kurzzeitig noch in CustomMouseListener

void mouseTripleClicked(MouseEvent e);

Um einen dreifachen Klick auf einem Objekt abfragen, wenn ich es jedoch, mit folgender Implementierung abfrage, wird die Aktion, die auf dem Doppelklick liegt und die Aktion, die auf dem 3-fachen Klick liegt ausgelöst. Die allgemeine Implementierung habe ich in AdvancedMouseListener erstellt.

        @Override
        public void mouseClicked(MouseEvent e) {
            int btn = e.getButton();
            long lastClickTime = ClickTracker.getLastClickTime();
            long clickTime = System.currentTimeMillis();
            int clickCount = e.getClickCount();

            // Doppelklick erkennen
            if ((clickTime - lastClickTime < 500) && clickCount == 2) {
                mouseDoubleClicked(e);
                
            }
// Tripleklick erkennen
           else if ((clickTime - lastClickTime < 500) && clickCount == 3) {
                mouseTripleClicked(e);
              
            }

            // Den letzten Klickzeitpunkt im ClickTracker speichern
            ClickTracker.updateClickTimes(clickTime);

            // Weitere Maustastenbehandlung
            if (btn == MouseEvent.BUTTON3) {
                mouseRightClicked(e);
                if (additionalListener != null) {
                    additionalListener.mouseRightClicked(e);
                }
            }
            if (btn == MouseEvent.BUTTON2) {
                mouseMiddleClicked(e);
                if (additionalListener != null) {
                    additionalListener.mouseMiddleClicked(e);
                }
            }
        }

 

[mihe7]

Du hast mich bzgl. getClickCount() entweder falsch verstanden, oder willst tatsächlich etwas anderes.

Fangen wir mal von vorne an: was ist ein Mausklick? Es ist ein Drücken der Maustaste, gefolgt von einem Loslassen der Maustaste, wobei das Drücken und Loslassen in der Regel auf derselben Komponente erfolgen muss. Ein mehrfaches Klicken innerhalb einer gewissen Zeitspanne, dem click-interval, erhöht einen Zähler. Findet innerhalb der Zeitspanne kein Click statt, beginnt der Zähler wieder von vorne. Bei einem Dreifachklick werden mousePressed, mouseReleased und mouseClicked also jeweils dreimal aufgerufen - mit den "click counts" 1, 2 und 3.

Das click-interval ist vom System vorgegeben. Wenn das Intervall für Dich in Ordnung ist, kannst Du also einfach über getClickCount() gehen. Ansonsten musst Du halt selbst zählen.

Im einfachsten Fall:

    @Override
    default void mouseClicked(MouseEvent e) {
        if (SwingUtilities.isLeftMouseButton(e)) {
            switch (e.getClickCount()) {
                case 1 -> mouseSingleClicked(e);
                case 2 -> mouseDoubleClicked(e);
                case 3 -> mouseTripleClicked(e);
            }
        } else if (SwingUtilities.isMiddleMouseButton(e)) {
            mouseMiddleClicked(e);
        } else if (SwingUtilities.isRightMouseButton(e)) {
            mouseRightClicked(e);
        }          
    }

Unter Windows(!) kannst Du das click-interval übrigens über die Desktop-Property "awt.multiClickInterval" herausfinden:

jshell> System.out.println(java.awt.Toolkit.getDefaultToolkit().getDesktopProperty("awt.multiClickInterval"))
500

(vgl. https://docs.oracle.com/javase/8/docs/technotes/guides/swing/1.4/w2k_props.html)

Wenn Du zwischen einem doppelten und einem dreifachen Mausklick exklusiv unterscheiden willst, brauchst Du einen Timer. Ein Doppelklick kann erst nach Ablauf der Zeit von einem Dreifachklick unterschieden werden.

 

[MJannek]

Vielen Dank. Ich möchte mir einfach den MouseListener erweitern

 

[namenlos1]

@MJannek beschreibt doch noch mal bitte kurz, was du hier versuchst zu machen.

 

[MJannek]

@namenlos1 ich habe es hinbekommen. Der gesamte Code ist in diesem Beitrag gepostet, jedoch möchte ich noch ein Methode, die Dreifachklick betrachtet

 

[mihe7]

@namenlos1 ich habe es hinbekommen. Der gesamte Code ist in diesem Beitrag gepostet, jedoch möchte ich noch ein Methode, die Dreifachklick betrachtet

Hast Du meinen Kommentar gelesen?!?

 

[namenlos1]

Stimmt @mihe7 und @MJannek, damit hast du die Funktionalität bereits auf dem Servierteller...

Schaue auch mal hier: https://docs.oracle.com/javase/8/docs/api/java/awt/event/MouseEvent.html#getClickCount--

Man kann das zwar nach-implementieren, aber es gibt es schon. Zudem müsstest du sonst selber den maxZeitabstand zwischen zwei Klicks definieren. Und ob du das willst?

 

[MJannek]

Ich habe jetzt folgende Lösung:
Zuerst habe ich mir ein neues Interface CustomMouseListener erstellt, in der ich die neuen Methoden definiert habe.

package javaext.awt.event.mouse.listener;

import java.awt.event.*;

public interface CustomMouseListener extends MouseListener,MouseWheelListener, MouseMotionListener {
    void mouseDoubleClicked(MouseEvent e);
    void mouseTripleClicked(MouseEvent e);
    void mouseRightClicked(MouseEvent e);
    void mouseMiddleClicked(MouseEvent e);
    void mouseWheelScrolledUp(MouseWheelEvent e);
    void mouseWheelScrolledDown(MouseWheelEvent e);

}

Danach habe ich mir das Interface MouseListenerX erstellt, welches CustomMouseListener erweitert

package javaext.awt.event.mouse.listener;

import java.awt.event.*;

public interface MouseListenerX extends CustomMouseListener {

    void mouseDoubleClicked(MouseEvent e);
    void mouseTripleClicked(MouseEvent e);

    void mouseRightClicked(MouseEvent e);

    void mouseMiddleClicked(MouseEvent e);

    void mousePressed(MouseEvent e);

    void mouseReleased(MouseEvent e);

    void mouseEntered(MouseEvent e);

    void mouseExited(MouseEvent e);

    void mouseWheelMoved(MouseWheelEvent e);

    void mouseDragged(MouseEvent e);

    void mouseMoved(MouseEvent e);

    void mouseWheelScrolledUp(MouseWheelEvent e);

    void mouseWheelScrolledDown(MouseWheelEvent e);

    }

Außerdem habe ich mir die abtrakte Klasse MouseAdapterX erstellt, welche MouseAdapter erweitert und CustomMouseListener implementiert.

package javaext.awt.event.mouse.adapter;

import java.awt.event.*;
import javaext.awt.event.mouse.listener.*;

public abstract class MouseAdapterX extends MouseAdapter implements CustomMouseListener {


    public void mouseDoubleClicked(MouseEvent e){}

    public void mouseTripleClicked(MouseEvent e){}

    public void mouseRightClicked(MouseEvent e){}

    public void mouseMiddleClicked(MouseEvent e){}

    public void mousePressed(MouseEvent e){}

    public void mouseReleased(MouseEvent e){}

    public void mouseEntered(MouseEvent e){}

    public void mouseExited(MouseEvent e){}

    public void mouseWheelMoved(MouseWheelEvent e){}

    public void mouseDragged(MouseEvent e){}

    public void mouseMoved(MouseEvent e){}
    public void mouseWheelScrolledUp(MouseWheelEvent e){}
    public void mouseWheelScrolledDown(MouseWheelEvent e){}


}

Des Weiteren habe ich mir die Hilfsklasse MouseHelper.

package javaext.awt.event.mouse;

import java.awt.*;
import java.awt.event.*;
import javaext.awt.event.mouse.adapter.*;
import javaext.awt.event.mouse.listener.*;
import javax.swing.*;

public class MouseHelper {
    private final int clickInterval = (int) Toolkit.getDefaultToolkit().getDesktopProperty("awt.multiClickInterval");
    private Timer clickTimer;
    private int clickCount = 0;

    public void listenerClickEvent(MouseListenerX additionalListener, MouseEvent e) {
        int btn = e.getButton();
        switch (btn) {
            case MouseEvent.BUTTON1 -> {
                clickCount++;
                if (clickTimer == null) {
                    clickTimer = new Timer(clickInterval, event -> {
                        if (additionalListener != null) {
                            switch (clickCount) {
                                case 1 -> additionalListener.mouseClicked(e);
                                case 2 -> additionalListener.mouseDoubleClicked(e);
                                case 3 -> additionalListener.mouseTripleClicked(e);
                            }
                        }
                        clickCount = 0;
                        clickTimer.stop();
                    });
                    clickTimer.setRepeats(false);
                    clickTimer.start();
                } else {
                    clickTimer.restart();
                }
            }
            case MouseEvent.BUTTON2 -> {
                if (additionalListener != null) {
                    additionalListener.mouseMiddleClicked(e);
                }
            }
            case MouseEvent.BUTTON3 -> {
                if (additionalListener != null) {
                    additionalListener.mouseRightClicked(e);
                }
            }
        }
    }

    public void adapterClickEvent(MouseAdapterX additionalAdapter, MouseEvent e) {
        int btn = e.getButton();
        switch (btn) {
            case MouseEvent.BUTTON1 -> {
                clickCount++;
                if (clickTimer == null) {
                    clickTimer = new Timer(clickInterval, event -> {
                        if (additionalAdapter != null) {
                            switch (clickCount) {
                                case 1 -> additionalAdapter.mouseClicked(e);
                                case 2 -> additionalAdapter.mouseDoubleClicked(e);
                                case 3 -> additionalAdapter.mouseTripleClicked(e);
                            }
                        }
                        clickCount = 0;
                        clickTimer.stop();
                    });
                    clickTimer.setRepeats(false);
                    clickTimer.start();
                } else {
                    clickTimer.restart();
                }
            }
            case MouseEvent.BUTTON2 -> {
                if (additionalAdapter != null) {
                    additionalAdapter.mouseMiddleClicked(e);
                }
            }
            case MouseEvent.BUTTON3 -> {
                if (additionalAdapter != null) {
                    additionalAdapter.mouseRightClicked(e);
                }
            }
        }
    }

}

Um "allgemeine Fälle" zu definieren habe ich eine Klasse AdvancedMouseListener erstellt, die MouseListenerX implementiert, und eine Klasse AdvancedMouseAdapter, die MouseAdapterX erweitert.

package javaext.awt.event.mouse.listener.advanced;

import java.awt.event.*;
import javaext.awt.event.mouse.*;
import javaext.awt.event.mouse.listener.*;

public class AdvancedMouseListener implements MouseListenerX {
    private final MouseListenerX additionalListener;
    private final MouseHelper mouseHelper = new MouseHelper();

    public AdvancedMouseListener(MouseListenerX listener) {
        this.additionalListener = listener;
    }


    @Override
    public void mouseClicked(MouseEvent e) {
        mouseHelper.listenerClickEvent(additionalListener, e);
    }

    @Override
    public void mouseDoubleClicked(MouseEvent e) {

    }

    @Override
    public void mouseTripleClicked(MouseEvent e) {

    }

    @Override
    public void mouseRightClicked(MouseEvent e) {

    }

    @Override
    public void mouseMiddleClicked(MouseEvent e) {

    }

    @Override
    public void mousePressed(MouseEvent e) {
        additionalListener.mousePressed(e);
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        additionalListener.mouseReleased(e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        additionalListener.mouseEntered(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        additionalListener.mouseExited(e);
    }

    @Override
    public void mouseWheelMoved(MouseWheelEvent e) {
        additionalListener.mouseWheelMoved(e);
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        additionalListener.mouseDragged(e);
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        additionalListener.mouseMoved(e);
    }

    @Override
    public void mouseWheelScrolledUp(MouseWheelEvent e) {
        if (e.getWheelRotation() < 0) {
            additionalListener.mouseWheelScrolledUp(e);
        }
    }

    @Override
    public void mouseWheelScrolledDown(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            additionalListener.mouseWheelScrolledDown(e);
        }

    }

}

package javaext.awt.event.mouse.adapter.advanced;

import java.awt.event.*;
import javaext.awt.event.mouse.*;
import javaext.awt.event.mouse.adapter.*;

public class AdvancedMouseAdapter extends MouseAdapterX {
    private final MouseAdapterX additionalAdapter;
    private final MouseHelper mouseHelper = new MouseHelper();

    public AdvancedMouseAdapter(MouseAdapterX adapter) {
        this.additionalAdapter = adapter;
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        mouseHelper.adapterClickEvent(additionalAdapter, e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        additionalAdapter.mouseEntered(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        additionalAdapter.mouseExited(e);
    }

    @Override
    public void mouseWheelScrolledUp(MouseWheelEvent e) {
        if (e.getWheelRotation() < 0) {
            additionalAdapter.mouseWheelScrolledUp(e);
        }
    }

    @Override
    public void mouseWheelScrolledDown(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            additionalAdapter.mouseWheelScrolledDown(e);
        }

    }
}

Um das nutzen zu können, habe ich die Klassen graphischer Objekte erweitert. So z.B. JLabel durch die Klasse LabelX. Diese Klasse implemtiert ein Interface, welches u.a. folgende Methoden einhält.

    Component getComponent();

    private boolean isSupportedComponent(Component c) {
        return c instanceof JTextField ||
                c instanceof AbstractButton ||
                c instanceof JLabel ||
                c instanceof JPanel ||
                c instanceof JComboBox ||
                c instanceof JFrame ||
                c instanceof JMenuBar ||
                c instanceof JTabbedPane;
    }
    default void addMouseListener(MouseListenerX listener) {
        Component c = getComponent();

        if (isSupportedComponent(c)) {
            AdvancedMouseListener advancedMouseListener = new AdvancedMouseListener(listener);

            c.addMouseListener(advancedMouseListener);
            c.addMouseMotionListener(advancedMouseListener);
            c.addMouseWheelListener(advancedMouseListener);
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for components implementing " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }

    default void addMouseListener(MouseAdapterX adapter) {
        Component c = getComponent();

        if (isSupportedComponent(c)) {
            AdvancedMouseAdapter advancedMouseListener = new AdvancedMouseAdapter(adapter);

            c.addMouseListener(advancedMouseListener);
            c.addMouseMotionListener(advancedMouseListener);
            c.addMouseWheelListener(advancedMouseListener);
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for components implementing " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }

Die Methode getComponent() aus diesem Interface wird in LabeX überschrieben, bzw. implentiert und gibt this zurück.

 

[Ebi]

Kann man alles machen, aber was genau spricht gegen diese Lösung?

public interface CustomMouseListener extends MouseListener, MouseWheelListener, MouseMotionListener {

    @Override
    default void mouseClicked(MouseEvent e) {

        if (e.getButton() == MouseEvent.BUTTON1) {
            if (e.getClickCount() == 2) {
                mouseDoubleClicked(e);
            } else if (e.getClickCount() == 3) {
                mouseTripleClicked(e);
            }
        }

        if (e.getButton() == MouseEvent.BUTTON2) {
            mouseMiddleClicked(e);
        }

        if (e.getButton() == MouseEvent.BUTTON3) {
            mouseRightClicked(e);
        }
    }

    void mouseDoubleClicked(MouseEvent e);

    void mouseTripleClicked(MouseEvent e);

    void mouseRightClicked(MouseEvent e);

    void mouseMiddleClicked(MouseEvent e);

    @Override
    default void mouseWheelMoved(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            mouseWheelScrolledDown(e);
        } else {
            mouseWheelScrolledUp(e);
        }
    }

    void mouseWheelScrolledUp(MouseWheelEvent e);

    void mouseWheelScrolledDown(MouseWheelEvent e);
}

 

[MJannek]

An sich bin ich mit dieser Implentierung sehr zufrieden, jedoch möchte ich Die non-sealed Klasse MouseEvent erweitern durch die Klasse MouseEventX. In dieser neuen Klasse, möchte ich neue MouseEvents definieren (z.B. MOUSE_CLICKED_DOUBLE_LEFT als Doppelklick des linken Mausbuttons). Ich möchte meinen Code so verändern, dass das Interface MouseListenerX das Interface EventListener erweitert. Die Methoden in MouseListenerX sollen wie folgt aussehen.

    void mouseClicked(MouseEventX e);

    void mousePressed(MouseEventX e);

    void mouseReleased(MouseEventX e);
    
    void mouseEntered(MouseEventX e);

    void mouseExited(MouseEventX e);

Meine Klasse MouseEventX (enthält noch Fehler) sieht wie folgt aus.

package javaext.awt.event.mouse;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MouseEventX extends MouseEvent {
    private static final int clickInterval = (int) Toolkit.getDefaultToolkit().getDesktopProperty("awt.multiClickInterval");
    private Timer clickTimer;
    private int customId;

    // Neue Event-Konstanten
    public static final int MOUSE_CLICK_RIGHT = 1001;
    public static final int MOUSE_CLICKED_LEFT_DOUBLE = 1002;
    public static final int MOUSE_CLICKED_LEFT_TRIPLE = 1003;
    public static final int MOUSE_CLICKED_MIDDLE = 1004;

    // Konstruktoren
    public MouseEventX(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger, int button) {
        super(source, id, when, modifiers, x, y, clickCount, popupTrigger, button);
        this.customId = id;
    }

    public MouseEventX(Component source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger) {
        super(source, id, when, modifiers, x, y, clickCount, popupTrigger);
        this.customId = id;
    }

    public MouseEventX(Component source, int id, long when, int modifiers, int x, int y, int xAbs, int yAbs, int clickCount, boolean popupTrigger, int button) {
        super(source, id, when, modifiers, x, y, xAbs, yAbs, clickCount, popupTrigger, button);
        this.customId = id;
    }

    public static MouseEventX createCustomEvent(MouseEvent e) {
        int customId = MouseEvent.MOUSE_CLICKED;

        Timer clickTimer = new Timer(clickInterval, null);

        switch (e.getButton()) {
            case MouseEvent.BUTTON1: // Linke Maustaste
                if (clickTimer == null) {
                    clickTimer = new Timer(clickInterval, event -> {
                        switch (e.getClickCount()) {
                            case 1:
                                customId = MouseEvent.MOUSE_CLICKED;
                                break;
                            case 2:
                                customId = MOUSE_CLICKED_LEFT_DOUBLE;
                                break;
                            case 3:
                                customId = MOUSE_CLICKED_LEFT_TRIPLE;
                                break;
                        }
                        clickTimer.stop();
                    });
                    clickTimer.setRepeats(false); // Der Timer soll nur einmal laufen
                    clickTimer.start();
                } else {
                    clickTimer.restart();
                }
                break;
            case MouseEvent.BUTTON2: // Mittlere Maustaste
                customId = MOUSE_CLICKED_MIDDLE;
                break;
            case MouseEvent.BUTTON3: // Rechte Maustaste
                customId = MOUSE_CLICK_RIGHT;
                break;
            default:
                customId = MouseEvent.MOUSE_CLICKED;
                break;
        }

        return new MouseEventX(e.getComponent(), customId, e.getWhen(), e.getModifiers(), e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(), e.getButton());
    }
}

Ich möchte des Weiteren das Interface MouseMotionListener erweitern. MouseMotionListenerX soll folgende Methoden enthalten.

void mouseDragged(MouseEventX e);
void mouseMoved(MouseEventX e);

Außerdem möchte ich eine abstrakte Klasse MouseMotionAdapterX erstellen, die MouseListenerX implementiert und wie folgt aus sehen soll.

package javaext.awt.event.mouse.motion;

import javaext.awt.event.mouse.*;

public abstract class MouseMotionAdapterX implements MouseMotionListenerX{
    protected MouseMotionAdapterX(){}
    public void mouseDragged(MouseEventX e){}

    public void mouseMoved(MouseEventX e){}

}

Die abstrakte Klasse MouseAdapterX soll MouseListenerX, MouseWheelListener und MouseMotionListenerX implementieren.
Ich möchte nun die Methode default void addMouseListener(MouseListenerX l) so verändern, dass dem Objekt ein MouseListener hinzugefügt wird. Bei der Implementierung möchte ich java.awt.event.MouseListener und java.awt.event
.MouseAdapter nicht verwenden.

 

[MJannek]

Kann man alles machen, aber was genau spricht gegen diese Lösung?

public interface CustomMouseListener extends MouseListener, MouseWheelListener, MouseMotionListener {

    @Override
    default void mouseClicked(MouseEvent e) {

        if (e.getButton() == MouseEvent.BUTTON1) {
            if (e.getClickCount() == 2) {
                mouseDoubleClicked(e);
            } else if (e.getClickCount() == 3) {
                mouseTripleClicked(e);
            }
        }

        if (e.getButton() == MouseEvent.BUTTON2) {
            mouseMiddleClicked(e);
        }

        if (e.getButton() == MouseEvent.BUTTON3) {
            mouseRightClicked(e);
        }
    }

    void mouseDoubleClicked(MouseEvent e);

    void mouseTripleClicked(MouseEvent e);

    void mouseRightClicked(MouseEvent e);

    void mouseMiddleClicked(MouseEvent e);

    @Override
    default void mouseWheelMoved(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            mouseWheelScrolledDown(e);
        } else {
            mouseWheelScrolledUp(e);
        }
    }

    void mouseWheelScrolledUp(MouseWheelEvent e);

    void mouseWheelScrolledDown(MouseWheelEvent e);
}

@Ebi Dagen spricht, dass ich dann nicht mehr ohne super.mouseClicked(e) arbeiten kann.
Ich wende es wie folgt an:
In Main Klasse:

 LabelX label = new LabelX("klick");
 label.setBounds(10,10,100,50);
        label.addMouseListener(new MouseListenerX() {
            @Override
            public void mouseDoubleClicked(MouseEvent e) {
                System.out.println(2);
            }

            @Override
            public void mouseTripleClicked(MouseEvent e) {
                System.out.println(3);
            }

            @Override
            public void mouseRightClicked(MouseEvent e) {

            }

            @Override
            public void mouseMiddleClicked(MouseEvent e) {

            }

            @Override
            public void mousePressed(MouseEvent e) {

            }

            @Override
            public void mouseReleased(MouseEvent e) {

            }

            @Override
            public void mouseEntered(MouseEvent e) {

            }

            @Override
            public void mouseExited(MouseEvent e) {

            }

            @Override
            public void mouseWheelMoved(MouseWheelEvent e) {

            }

            @Override
            public void mouseDragged(MouseEvent e) {

            }

            @Override
            public void mouseMoved(MouseEvent e) {

            }

            @Override
            public void mouseWheelScrolledUp(MouseWheelEvent e) {
                System.out.println("U");
            }

            @Override
            public void mouseWheelScrolledDown(MouseWheelEvent e) {
                System.out.println("D");
            }

            @Override
            public void mouseClicked(MouseEvent e) {
                System.out.println(1);
            }
        });

LabelX impementiert ein Interface welches folgende Methoden enthält:

Component getComponent();

    private boolean isSupportedComponent(Component c) {
        return c instanceof JTextField ||
                c instanceof AbstractButton ||
                c instanceof JLabel ||
                c instanceof JPanel ||
                c instanceof JComboBox ||
                c instanceof JFrame ||
                c instanceof JMenuBar ||
                c instanceof JTabbedPane;
    }
    default void addMouseListener(MouseListenerX listener) {
        Component c = getComponent();

        if (isSupportedComponent(c)) {
            AdvancedMouseListener advancedMouseListener = new AdvancedMouseListener(listener);

            c.addMouseListener(advancedMouseListener);
            c.addMouseMotionListener(advancedMouseListener);
            c.addMouseWheelListener(advancedMouseListener);
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for components implementing " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }

AdvancedMouseListener sieht wie folgt aus:

package javaext.awt.event.mouse.listener.advanced;

import java.awt.event.*;
import javaext.awt.event.mouse.*;
import javaext.awt.event.mouse.listener.*;

public class AdvancedMouseListener implements MouseListenerX {
    private final MouseListenerX additionalListener;

    public AdvancedMouseListener(MouseListenerX listener) {
        this.additionalListener = listener;
    }


    @Override
    public void mouseClicked(MouseEvent e) {
       additionalListener.mouseClicked(e);
    }

    @Override
    public void mouseDoubleClicked(MouseEvent e) {

    }

    @Override
    public void mouseTripleClicked(MouseEvent e) {

    }

    @Override
    public void mouseRightClicked(MouseEvent e) {

    }

    @Override
    public void mouseMiddleClicked(MouseEvent e) {

    }

    @Override
    public void mousePressed(MouseEvent e) {
        additionalListener.mousePressed(e);
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        additionalListener.mouseReleased(e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        additionalListener.mouseEntered(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        additionalListener.mouseExited(e);
    }

    @Override
    public void mouseWheelMoved(MouseWheelEvent e) {
        additionalListener.mouseWheelMoved(e);
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        additionalListener.mouseDragged(e);
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        additionalListener.mouseMoved(e);
    }

    @Override
    public void mouseWheelScrolledUp(MouseWheelEvent e) {
        if (e.getWheelRotation() < 0) {
            additionalListener.mouseWheelScrolledUp(e);
        }
    }

    @Override
    public void mouseWheelScrolledDown(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            additionalListener.mouseWheelScrolledDown(e);
        }

    }

}

Außerdem existiert das Interface MouseListenerX welches so aussieht:

package javaext.awt.event.mouse.listener;

import java.awt.event.*;

public interface MouseListenerX extends CustomMouseListener {

    void mouseDoubleClicked(MouseEvent e);
    void mouseTripleClicked(MouseEvent e);

    void mouseRightClicked(MouseEvent e);

    void mouseMiddleClicked(MouseEvent e);

    void mousePressed(MouseEvent e);

    void mouseReleased(MouseEvent e);

    void mouseEntered(MouseEvent e);

    void mouseExited(MouseEvent e);

    void mouseWheelMoved(MouseWheelEvent e);

    void mouseDragged(MouseEvent e);

    void mouseMoved(MouseEvent e);

    void mouseWheelScrolledUp(MouseWheelEvent e);

    void mouseWheelScrolledDown(MouseWheelEvent e);

    }

Meine Ausgabe bei dieser Implementierung.

1
bei einfachem Klick

1
1
bei doppeltem Klick

1
1
1
bei dreifachem Klick

Wenn ich jedoch meine ursprüngliche Implentierung beibehalte, erhalte ich folgende Ausgabe:
1
bei einfachem Klick

2
bei doppeltem Klick

3
bei dreifachem Klick

 

[MJannek]

Ich habe jetzt folgende Lösung:
Zuerst habe ich mir ein neues Interface CustomMouseListener erstellt, in der ich die neuen Methoden definiert habe.

package javaext.awt.event.mouse.listener;

import java.awt.event.*;

public interface CustomMouseListener extends MouseListener,MouseWheelListener, MouseMotionListener {
    void mouseDoubleClicked(MouseEvent e);
    void mouseTripleClicked(MouseEvent e);
    void mouseRightClicked(MouseEvent e);
    void mouseMiddleClicked(MouseEvent e);
    void mouseWheelScrolledUp(MouseWheelEvent e);
    void mouseWheelScrolledDown(MouseWheelEvent e);

}

Danach habe ich mir das Interface MouseListenerX erstellt, welches CustomMouseListener erweitert

package javaext.awt.event.mouse.listener;

import java.awt.event.*;

public interface MouseListenerX extends CustomMouseListener {

    void mouseDoubleClicked(MouseEvent e);
    void mouseTripleClicked(MouseEvent e);

    void mouseRightClicked(MouseEvent e);

    void mouseMiddleClicked(MouseEvent e);

    void mousePressed(MouseEvent e);

    void mouseReleased(MouseEvent e);

    void mouseEntered(MouseEvent e);

    void mouseExited(MouseEvent e);

    void mouseWheelMoved(MouseWheelEvent e);

    void mouseDragged(MouseEvent e);

    void mouseMoved(MouseEvent e);

    void mouseWheelScrolledUp(MouseWheelEvent e);

    void mouseWheelScrolledDown(MouseWheelEvent e);

    }

Außerdem habe ich mir die abtrakte Klasse MouseAdapterX erstellt, welche MouseAdapter erweitert und CustomMouseListener implementiert.

package javaext.awt.event.mouse.adapter;

import java.awt.event.*;
import javaext.awt.event.mouse.listener.*;

public abstract class MouseAdapterX extends MouseAdapter implements CustomMouseListener {


    public void mouseDoubleClicked(MouseEvent e){}

    public void mouseTripleClicked(MouseEvent e){}

    public void mouseRightClicked(MouseEvent e){}

    public void mouseMiddleClicked(MouseEvent e){}

    public void mousePressed(MouseEvent e){}

    public void mouseReleased(MouseEvent e){}

    public void mouseEntered(MouseEvent e){}

    public void mouseExited(MouseEvent e){}

    public void mouseWheelMoved(MouseWheelEvent e){}

    public void mouseDragged(MouseEvent e){}

    public void mouseMoved(MouseEvent e){}
    public void mouseWheelScrolledUp(MouseWheelEvent e){}
    public void mouseWheelScrolledDown(MouseWheelEvent e){}


}

Des Weiteren habe ich mir die Hilfsklasse MouseHelper.

package javaext.awt.event.mouse;

import java.awt.*;
import java.awt.event.*;
import javaext.awt.event.mouse.adapter.*;
import javaext.awt.event.mouse.listener.*;
import javax.swing.*;

public class MouseHelper {
    private final int clickInterval = (int) Toolkit.getDefaultToolkit().getDesktopProperty("awt.multiClickInterval");
    private Timer clickTimer;
    private int clickCount = 0;

    public void listenerClickEvent(MouseListenerX additionalListener, MouseEvent e) {
        int btn = e.getButton();
        switch (btn) {
            case MouseEvent.BUTTON1 -> {
                clickCount++;
                if (clickTimer == null) {
                    clickTimer = new Timer(clickInterval, event -> {
                        if (additionalListener != null) {
                            switch (clickCount) {
                                case 1 -> additionalListener.mouseClicked(e);
                                case 2 -> additionalListener.mouseDoubleClicked(e);
                                case 3 -> additionalListener.mouseTripleClicked(e);
                            }
                        }
                        clickCount = 0;
                        clickTimer.stop();
                    });
                    clickTimer.setRepeats(false);
                    clickTimer.start();
                } else {
                    clickTimer.restart();
                }
            }
            case MouseEvent.BUTTON2 -> {
                if (additionalListener != null) {
                    additionalListener.mouseMiddleClicked(e);
                }
            }
            case MouseEvent.BUTTON3 -> {
                if (additionalListener != null) {
                    additionalListener.mouseRightClicked(e);
                }
            }
        }
    }

    public void adapterClickEvent(MouseAdapterX additionalAdapter, MouseEvent e) {
        int btn = e.getButton();
        switch (btn) {
            case MouseEvent.BUTTON1 -> {
                clickCount++;
                if (clickTimer == null) {
                    clickTimer = new Timer(clickInterval, event -> {
                        if (additionalAdapter != null) {
                            switch (clickCount) {
                                case 1 -> additionalAdapter.mouseClicked(e);
                                case 2 -> additionalAdapter.mouseDoubleClicked(e);
                                case 3 -> additionalAdapter.mouseTripleClicked(e);
                            }
                        }
                        clickCount = 0;
                        clickTimer.stop();
                    });
                    clickTimer.setRepeats(false);
                    clickTimer.start();
                } else {
                    clickTimer.restart();
                }
            }
            case MouseEvent.BUTTON2 -> {
                if (additionalAdapter != null) {
                    additionalAdapter.mouseMiddleClicked(e);
                }
            }
            case MouseEvent.BUTTON3 -> {
                if (additionalAdapter != null) {
                    additionalAdapter.mouseRightClicked(e);
                }
            }
        }
    }

}

Um "allgemeine Fälle" zu definieren habe ich eine Klasse AdvancedMouseListener erstellt, die MouseListenerX implementiert, und eine Klasse AdvancedMouseAdapter, die MouseAdapterX erweitert.

package javaext.awt.event.mouse.listener.advanced;

import java.awt.event.*;
import javaext.awt.event.mouse.*;
import javaext.awt.event.mouse.listener.*;

public class AdvancedMouseListener implements MouseListenerX {
    private final MouseListenerX additionalListener;
    private final MouseHelper mouseHelper = new MouseHelper();

    public AdvancedMouseListener(MouseListenerX listener) {
        this.additionalListener = listener;
    }


    @Override
    public void mouseClicked(MouseEvent e) {
        mouseHelper.listenerClickEvent(additionalListener, e);
    }

    @Override
    public void mouseDoubleClicked(MouseEvent e) {

    }

    @Override
    public void mouseTripleClicked(MouseEvent e) {

    }

    @Override
    public void mouseRightClicked(MouseEvent e) {

    }

    @Override
    public void mouseMiddleClicked(MouseEvent e) {

    }

    @Override
    public void mousePressed(MouseEvent e) {
        additionalListener.mousePressed(e);
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        additionalListener.mouseReleased(e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        additionalListener.mouseEntered(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        additionalListener.mouseExited(e);
    }

    @Override
    public void mouseWheelMoved(MouseWheelEvent e) {
        additionalListener.mouseWheelMoved(e);
    }

    @Override
    public void mouseDragged(MouseEvent e) {
        additionalListener.mouseDragged(e);
    }

    @Override
    public void mouseMoved(MouseEvent e) {
        additionalListener.mouseMoved(e);
    }

    @Override
    public void mouseWheelScrolledUp(MouseWheelEvent e) {
        if (e.getWheelRotation() < 0) {
            additionalListener.mouseWheelScrolledUp(e);
        }
    }

    @Override
    public void mouseWheelScrolledDown(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            additionalListener.mouseWheelScrolledDown(e);
        }

    }

}

package javaext.awt.event.mouse.adapter.advanced;

import java.awt.event.*;
import javaext.awt.event.mouse.*;
import javaext.awt.event.mouse.adapter.*;

public class AdvancedMouseAdapter extends MouseAdapterX {
    private final MouseAdapterX additionalAdapter;
    private final MouseHelper mouseHelper = new MouseHelper();

    public AdvancedMouseAdapter(MouseAdapterX adapter) {
        this.additionalAdapter = adapter;
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        mouseHelper.adapterClickEvent(additionalAdapter, e);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        additionalAdapter.mouseEntered(e);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        additionalAdapter.mouseExited(e);
    }

    @Override
    public void mouseWheelScrolledUp(MouseWheelEvent e) {
        if (e.getWheelRotation() < 0) {
            additionalAdapter.mouseWheelScrolledUp(e);
        }
    }

    @Override
    public void mouseWheelScrolledDown(MouseWheelEvent e) {
        if (e.getWheelRotation() > 0) {
            additionalAdapter.mouseWheelScrolledDown(e);
        }

    }
}

Um das nutzen zu können, habe ich die Klassen graphischer Objekte erweitert. So z.B. JLabel durch die Klasse LabelX. Diese Klasse implemtiert ein Interface, welches u.a. folgende Methoden einhält.

    Component getComponent();

    private boolean isSupportedComponent(Component c) {
        return c instanceof JTextField ||
                c instanceof AbstractButton ||
                c instanceof JLabel ||
                c instanceof JPanel ||
                c instanceof JComboBox ||
                c instanceof JFrame ||
                c instanceof JMenuBar ||
                c instanceof JTabbedPane;
    }
    default void addMouseListener(MouseListenerX listener) {
        Component c = getComponent();

        if (isSupportedComponent(c)) {
            AdvancedMouseListener advancedMouseListener = new AdvancedMouseListener(listener);

            c.addMouseListener(advancedMouseListener);
            c.addMouseMotionListener(advancedMouseListener);
            c.addMouseWheelListener(advancedMouseListener);
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for components implementing " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }

    default void addMouseListener(MouseAdapterX adapter) {
        Component c = getComponent();

        if (isSupportedComponent(c)) {
            AdvancedMouseAdapter advancedMouseListener = new AdvancedMouseAdapter(adapter);

            c.addMouseListener(advancedMouseListener);
            c.addMouseMotionListener(advancedMouseListener);
            c.addMouseWheelListener(advancedMouseListener);
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for components implementing " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }

Die Methode getComponent() aus diesem Interface wird in LabeX überschrieben, bzw. implentiert und gibt this zurück.

Ich habe die Klasse MouseEventX wie folgt überarbeitet

package javaext.awt.event.mouse;

import java.awt.*;
import java.awt.event.MouseEvent;

public class MouseEventX extends MouseEvent {
    public static final int MOUSE_LEFT_DOUBLE_CLICKED = MOUSE_LAST + 1;
    public MouseEventX(Component source, int id, long when, int modifiers,
                       int x, int y, int clickCount, boolean popupTrigger,
                       int button) {
        super(source, id, when, modifiers, x, y, 0, 0, clickCount, popupTrigger, button);
    }

    public MouseEventX(Component source, int id, long when, int modifiers,
                       int x, int y, int clickCount, boolean popupTrigger) {
        super(source, id, when, modifiers, x, y, clickCount, popupTrigger, NOBUTTON);
    }

    public MouseEventX(Component source, int id, long when, int modifiers,
                       int x, int y, int xAbs, int yAbs,
                       int clickCount, boolean popupTrigger, int button) {
        super(source, id, when, modifiers, x, y, clickCount, popupTrigger, button);
    }


    public static MouseEvent createLeftDoubleClickEvent(Component source, long when, int x, int y) {
        // Doppelklick: clickCount = 2, Button: LEFT (BUTTON1), Event ID: MOUSE_LEFT_DOUBLE_CLICKED
        return new MouseEventX(source, MOUSE_LEFT_DOUBLE_CLICKED, when, 0, x, y, 2, false, MouseEvent.BUTTON1);
    }
}

Wie kann ich jetzt in dem Interface das von LabelX implementiert wird die Methode addMouseListener(MouseListenerX l) so ändern, dass ich MouseEvent, MouseListener und MouseAdapter nicht verwenden muss innerhalb dieser Methode und auch nicht in Hilfsmethoden.

package javaext.awt.event.mouse;

import java.awt.*;
import java.awt.event.MouseEvent;

public class MouseEventX extends MouseEvent {
    public static final int MOUSE_LEFT_DOUBLE_CLICKED = MOUSE_LAST + 1;
    public MouseEventX(Component source, int id, long when, int modifiers,
                       int x, int y, int clickCount, boolean popupTrigger,
                       int button) {
        super(source, id, when, modifiers, x, y, 0, 0, clickCount, popupTrigger, button);
    }

    public MouseEventX(Component source, int id, long when, int modifiers,
                       int x, int y, int clickCount, boolean popupTrigger) {
        super(source, id, when, modifiers, x, y, clickCount, popupTrigger, NOBUTTON);
    }

    public MouseEventX(Component source, int id, long when, int modifiers,
                       int x, int y, int xAbs, int yAbs,
                       int clickCount, boolean popupTrigger, int button) {
        super(source, id, when, modifiers, x, y, clickCount, popupTrigger, button);
    }


    public static MouseEvent createLeftDoubleClickEvent(Component source, long when, int x, int y) {
        // Doppelklick: clickCount = 2, Button: LEFT (BUTTON1), Event ID: MOUSE_LEFT_DOUBLE_CLICKED
        return new MouseEventX(source, MOUSE_LEFT_DOUBLE_CLICKED, when, 0, x, y, 2, false, MouseEvent.BUTTON1);
    }
}

 

[MJannek]

Ich habe die obigen Probleme alle gelöst. Jedoch habe ich ein neues.
Ich habe MouseListenerX so überarbeitet, dass es EventListener direkt erweitert:

package javaext.awt.event.mouse.standard.listener;

import java.awt.event.MouseEvent;
import java.util.EventListener;
import javaext.awt.event.mouse.standard.*;

public interface MouseListenerX extends EventListener {

    void mouseClicked(MouseEvent e);
    void mousePressed(MouseEvent e);
    void mouseReleased(MouseEvent e);
    void mouseEntered(MouseEvent e);
    void mouseExited(MouseEvent e);
    void mouseLeftDoubleClicked(MouseEvent event);
    void mouseLeftTripleClicked(MouseEvent event);
    void mouseMiddleClicked(MouseEvent e);
    void mouseMiddleDoubleClicked(MouseEvent e);
    void mouseMiddleTripleClicked(MouseEvent e);
    void mouseRightClicked(MouseEvent e);
    void mouseRightDoubleClicked(MouseEvent e);
    void mouseRightTripleClicked(MouseEvent e);
}

Außerdem habe ich MouseEventX wie folgt überarbeitet:

package javaext.awt.event.mouse.standard;

import java.awt.*;
import java.awt.event.*;

public class MouseEventX extends MouseEvent {
    private final MouseEventType type;
    public MouseEventX(Object source, int id, long when, int modifiers, int x, int y, int clickCount, boolean popupTrigger, int button, MouseEventType type) {
        super((Component) source, id, when, modifiers, x, y, clickCount, popupTrigger, button);
        this.type = type;
    }

    public MouseEventType getType() {
        return type;
    }

    public enum MouseEventType {
        MOUSE_LEFT_CLICKED,
        MOUSE_LEFT_CLICKED_DOUBLE,
        MOUSE_LEFT_CLICKED_TRIPLE,
        MOUSE_MIDDLE_CLICKED,
        MOUSE_MIDDLE_CLICKED_DOUBLE,
        MOUSE_MIDDLE_CLICKED_TRIPLE,
        MOUSE_RIGHT_CLICKED,
        MOUSE_RIGHT_CLICKED_DOUBLE,
        MOUSE_RIGHT_CLICKED_TRIPLE,
        MOUSE_ENTERED,
        MOUSE_EXITED,
    }
}

Des Weiteren habe ich mir eine Klasse MouseEventHandler erstellt:

package javaext.awt.event.mouse.standard;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

import javaext.awt.event.mouse.standard.listener.*;

public class MouseEventHandler {
    private final int clickInterval = (int) Toolkit.getDefaultToolkit().getDesktopProperty("awt.multiClickInterval");
    private final Timer clickTimerLeft;
    private final Timer clickTimerMiddle;
    private final Timer clickTimerRight;
    private int clickCountLeft = 0;
    private int clickCountMiddle = 0;
    private int clickCountRight = 0;
    private MouseListenerX listener;
    private MouseEvent lastEvent;
    private int lastBtn;

    public MouseEventHandler() {
        this.clickTimerLeft = new Timer(clickInterval, timerEvent -> {
            if (listener != null && lastEvent != null && lastBtn == MouseEvent.BUTTON1) {
                MouseEventX event = createEvent(lastEvent, clickCountLeft, resolveType(clickCountLeft, lastBtn));
                listenerEventDispatch(listener, event);
            }
            resetClickStateLeft();
        });
        this.clickTimerLeft.setRepeats(false);

        this.clickTimerMiddle = new Timer(clickInterval, timerEvent -> {
            if (listener != null && lastEvent != null && lastBtn == MouseEvent.BUTTON2) {
                MouseEventX event = createEvent(lastEvent, clickCountMiddle, resolveType(clickCountMiddle, lastBtn));
                listenerEventDispatch(listener, event);
            }
            resetClickStateMiddle();
        });
        this.clickTimerMiddle.setRepeats(false);

        this.clickTimerRight = new Timer(clickInterval, timerEvent -> {
            if (listener != null && lastEvent != null && lastBtn == MouseEvent.BUTTON3) {
                MouseEventX event = createEvent(lastEvent, clickCountRight, resolveType(clickCountRight, lastBtn));
                listenerEventDispatch(listener, event);
            }
            resetClickStateRight();
        });
        this.clickTimerRight.setRepeats(false);
    }

    public void handleMouseEvent(MouseListenerX listener, MouseEvent e) {
        this.listener = listener;
        this.lastEvent = e;
        this.lastBtn = e.getButton();
        handleClick(e);
    }

    private MouseEventX createEvent(MouseEvent e, int clickCount, MouseEventX.MouseEventType type) {
        return new MouseEventX(
                e.getSource(),
                e.getID(),
                System.currentTimeMillis(),
                e.getModifiersEx(),
                e.getX(),
                e.getY(),
                clickCount,
                e.isPopupTrigger(),
                e.getButton(),
                type
        );
    }

    private void handleClick(MouseEvent e) {
        int button = e.getButton();
        switch (button) {
            case MouseEvent.BUTTON1 -> {
                clickCountLeft++;
                if (!clickTimerLeft.isRunning()) {
                    clickTimerLeft.start();
                } else {
                    clickTimerLeft.restart();
                }
            }
            case MouseEvent.BUTTON2 -> {
                clickCountMiddle++;
                if (!clickTimerMiddle.isRunning()) {
                    clickTimerMiddle.start();
                } else {
                    clickTimerMiddle.restart();
                }
            }
            case MouseEvent.BUTTON3 -> {
                clickCountRight++;
                if (!clickTimerRight.isRunning()) {
                    clickTimerRight.start();
                } else {
                    clickTimerRight.restart();
                }
            }
        }
    }

    private MouseEventX.MouseEventType resolveType(int clickCount, int button) {
        switch (button) {
            case MouseEvent.BUTTON1 -> {
                return switch (clickCount) {
                    case 1 -> MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED;
                    case 2 -> MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED_DOUBLE;
                    case 3 -> MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED_TRIPLE;
                    default -> MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED; // Fallback
                };
            }
            case MouseEvent.BUTTON2 -> {
                return switch (clickCount) {
                    case 1 -> MouseEventX.MouseEventType.MOUSE_MIDDLE_CLICKED;
                    case 2 -> MouseEventX.MouseEventType.MOUSE_MIDDLE_CLICKED_DOUBLE;
                    case 3 -> MouseEventX.MouseEventType.MOUSE_MIDDLE_CLICKED_TRIPLE;
                    default -> MouseEventX.MouseEventType.MOUSE_MIDDLE_CLICKED; // Fallback
                };
            }
            case MouseEvent.BUTTON3 -> {
                return switch (clickCount) {
                    case 1 -> MouseEventX.MouseEventType.MOUSE_RIGHT_CLICKED;
                    case 2 -> MouseEventX.MouseEventType.MOUSE_RIGHT_CLICKED_DOUBLE;
                    case 3 -> MouseEventX.MouseEventType.MOUSE_RIGHT_CLICKED_TRIPLE;
                    default -> MouseEventX.MouseEventType.MOUSE_RIGHT_CLICKED; // Fallback
                };
            }
            default -> {
                if (lastEvent != null) {
                    switch (lastEvent.getID()) {
                        case MouseEvent.MOUSE_ENTERED -> {
                            return MouseEventX.MouseEventType.MOUSE_ENTERED;
                        }
                        case MouseEvent.MOUSE_EXITED -> {
                            return MouseEventX.MouseEventType.MOUSE_EXITED;
                        }
                    }
                }
                return MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED; // Default fallback
            }
        }
    }

    private void listenerEventDispatch(MouseListenerX listener, MouseEventX event) {
        switch (event.getType()) {
            case MOUSE_LEFT_CLICKED -> listener.mouseClicked(event);
            case MOUSE_LEFT_CLICKED_DOUBLE -> listener.mouseLeftDoubleClicked(event);
            case MOUSE_LEFT_CLICKED_TRIPLE -> listener.mouseLeftTripleClicked(event);
            case MOUSE_MIDDLE_CLICKED -> listener.mouseMiddleClicked(event);
            case MOUSE_MIDDLE_CLICKED_DOUBLE -> listener.mouseMiddleDoubleClicked(event);
            case MOUSE_MIDDLE_CLICKED_TRIPLE -> listener.mouseMiddleTripleClicked(event);
            case MOUSE_RIGHT_CLICKED -> listener.mouseRightClicked(event);
            case MOUSE_RIGHT_CLICKED_DOUBLE -> listener.mouseRightDoubleClicked(event);
            case MOUSE_RIGHT_CLICKED_TRIPLE -> listener.mouseRightTripleClicked(event);
            case MOUSE_ENTERED -> listener.mouseEntered(event);
            case MOUSE_EXITED -> listener.mouseExited(event);
        }
    }

    private void resetClickStateLeft() {
        clickCountLeft = 0;
        lastEvent = null;
        clickTimerLeft.stop();
    }

    private void resetClickStateMiddle() {
        clickCountMiddle = 0;
        lastEvent = null;
        clickTimerMiddle.stop();
    }

    private void resetClickStateRight() {
        clickCountRight = 0;
        lastEvent = null;
        clickTimerRight.stop();
    }
}

Ich habe mir noch die Klasse AdvancedMouseListener erstellt, um einem Standard MouseListener zu definieren. Ich habe in einem weiteren Interface folgende Methoden:

Component getComponent();

    private boolean isSupportedComponent(Component c) {
        return c instanceof JTextField ||
                c instanceof AbstractButton ||
                c instanceof JLabel ||
                c instanceof JPanel ||
                c instanceof JComboBox ||
                c instanceof JFrame ||
                c instanceof JMenuBar ||
                c instanceof JTabbedPane;
    }

    default void addMouseListener(MouseListenerX listener) {
        Component c = getComponent();

        if (c == null) {
            throw new UnsupportedOperationException("Component cannot be null.");
        }

        if (isSupportedComponent(c)) {
            AdvancedMouseListener advancedMouseListener = new AdvancedMouseListener(listener);
            c.addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    advancedMouseListener.mouseClicked(new MouseEventX(
                            e.getSource(), e.getID(), e.getWhen(), e.getModifiersEx(),
                            e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(),
                            e.getButton(), MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED));
                }

                @Override
                public void mousePressed(MouseEvent e) {
                    advancedMouseListener.mousePressed(new MouseEventX(
                            e.getSource(), e.getID(), e.getWhen(), e.getModifiersEx(),
                            e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(),
                            e.getButton(), MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED));
                }

                @Override
                public void mouseReleased(MouseEvent e) {
                    advancedMouseListener.mouseReleased(new MouseEventX(
                            e.getSource(), e.getID(), e.getWhen(), e.getModifiersEx(),
                            e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(),
                            e.getButton(), MouseEventX.MouseEventType.MOUSE_LEFT_CLICKED));
                }

                @Override
                public void mouseEntered(MouseEvent e) {
                    advancedMouseListener.mouseEntered(new MouseEventX(
                            e.getSource(), e.getID(), e.getWhen(), e.getModifiersEx(),
                            e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(),
                            e.getButton(), MouseEventX.MouseEventType.MOUSE_ENTERED));
                }

                @Override
                public void mouseExited(MouseEvent e) {
                    advancedMouseListener.mouseExited(new MouseEventX(
                            e.getSource(), e.getID(), e.getWhen(), e.getModifiersEx(),
                            e.getX(), e.getY(), e.getClickCount(), e.isPopupTrigger(),
                            e.getButton(), MouseEventX.MouseEventType.MOUSE_EXITED));
                }
            });
        } else {
            throw new UnsupportedOperationException(
                    "This method is only supported for the following components: " +
                            "JTextField, AbstractButton, JLabel, JPanel, JComboBox, " +
                            "JTabbedPane, JFrame, or JMenuBar."
            );
        }
    }
default void removeMouseListener(MouseListenerX listener) { Component c = getComponent();
        c.removeMouseListener(listener);
    }

Die Methode addMouseListener tut genau das was sie soll, jedoch weiß ich bei removeMouseListener() nicht weiter.
Wenn ich es so lasse, kommt fogende Fehlermeldung

java: Inkompatible Typen: javaext.awt.event.mouse.standard.listener.MouseListenerX kann nicht in java.awt.event.MouseListener konvertiert werden

und wenn ich es zu einem MouseListener caste passiert garnichts (die Aktionen des jeweiligen MoudeListenerX werden weiterhin ausgeführt).
Hat jemand einen Tipp?
Vielen Dank im vorraus.

 

[Marinek]

Hi,
also dein MouseListenerX ist ein EventListener. Müsste aber ein MouseListener (Unterklasse von EventListner) sein. Da hilft auch kein Casting, denn aus einem Hund, bekommst du nie ein Pferd raus.

Du musst also aus dem MousListenerX ein MouseListener machen und das Interface implementieren.

---

Bitte beachte, dass dein Vorgehen nicht sauber ist. Dein MouseListenerX macht auf komplizierte weise das gleiche, was der vorhandene MouseListenerAdapter macht. Erst sein MouseEventHandler macht ja deine Custom Logik und der braucht ja kein MouseListenerX. Das sieht man vor allem daran, dass du alle Werte einfach kopierst und dann in deiner Klasse wiederverwendest. Das ist nicht Sinn der Sache.

Außerdem startet dein MouseEventHandler hunderte Timer. Eigentlich wolte ich darauf hinaus, dass jeder deiner Listener, die in anbetracht deiner Komponenten, die du überwachst 3 mal so viele Timer startet, wie du Komponenten in der GUI hast. Das ist jedes mal ein anderer Thread, der auch gemanaged werden will. Das wird - wie gesagt keine AHnung was du machst - in vielen Anwendungen für viel Lag sorgen.

Hier wäre es eigentlich Lister System.currentTimeMillis zu verwenden, um die Clickcounts zu zählen oder?

 

[MJannek]

@Marinek Das ist verständlich. Kann man den MouseListenerX auch so umsetzen, dass man den Methoden von Anfang an Objekte von MouseEventX übergibt? Falls nicht, ist das nicht schlimm.

 

[mihe7]

Sicher kannst Du ein Interface MouseListenerX definieren, das als Parameter Objekte vom Typ MouseEventX erwartet. Dieses Interface ist dann aber keine Erweiterung von java.awt.event.MouseListener. Das ist aber nicht unbedingt ein Problem, denn Du benötigst ja sowieso einen Adapter, der auf der einen Seite einen MouseListener implementiert, um die Methoden von MouseListenerX aufzurufen.