¿Cómo detectar que el usuario está utilizando el Trackpad y no el mouse en Java swing?

mouseevent

Question

Tengo una aplicación Java swing que usa un JComponent ''capaz de panear'' para mostrar datos grandes. Cuando el usuario mueve la rueda del mouse, escucho estos eventos y actualizo el contenido de JComponent a partir de la cantidad desplazada.

Me gustaría tener un comportamiento diferente dependiendo de si el usuario es

• usando un mouse clasico
• utilizando un panel táctil, como los que se pueden encontrar en las computadoras portátiles modernas Mac.

¿Cómo puedo detectar que el usuario está utilizando la rueda del mouse frente al trackpad para generar el evento de desplazamiento? Estoy confiando en java 1.6 swing, si no puedo ir a javaFX.

Historia detrás de la pregunta: solo quería agregar una sensación de inercia fresca al evento de desplazamiento cuando el usuario usa la rueda del mouse. Pero, por supuesto, en MacOSX, el trackpad tiene su propia inercia integrada. Así que quería decidir si debería generar el movimiento inercial o no.

Answer 1

Java Swing es una tecnología antigua, es compatible con los eventos tradicionales de rotación de la rueda del mouse.

Cuando use el ratón con la rueda vieja, o el track-pad de la rueda, leerá la rotación de la rueda de hardware.

Cuando utilice un mouse láser moderno, el movimiento del mouse se convertirá en movimiento de rotación.

Cuando use un trackpad táctil como el de las modernas computadoras portátiles Mac, el gesto de desplazamiento se traducirá en movimiento de rotación, con un simple y doble toque al hacer clic con el botón izquierdo y derecho (según la configuración del mouse pad).

Puede usar las bibliotecas para verificar los dispositivos de entrada en detalle, en caso de que su mouse o track-track esté conectado a su computadora a través de USB, puede probar la biblioteca J-USB .

En cuanto al hardware interno, primero debe identificar el tipo de sistema operativo y, en función de eso, puede obtener información sobre el sistema y el hardware en Java .

Finalmente, si su aplicación interactúa con un usuario, sugiero que pregunte al usuario qué tipo de mouse está usando, y guárdelo en el archivo de configuración o algo así.

Answer 2

Prueba este codigo

1. MetaDown se utiliza para hacer clic derecho

2. AltDown se utiliza para la rueda del ratón

.

public class Exp extends JFrame {

    private String string;
    private JLabel l;

    public Exp() {
        super("Title");    
        l = new JLabel("Status");
        add(l, BorderLayout.SOUTH);
        addMouseListener(new MouseClass());         
    }

    private class MouseClass extends MouseAdapter {
        public void mouseClicked(MouseEvent e) {                
            string = String.format("Clicked %d Times", e.getClickCount());              
            if(e.isMetaDown())
                string += " With Right Mouse Button";
            else if(e.isAltDown())
                string += " With Centre Mouse Button";
            else
                string += " With Left Mouse Button";                
            l.setText(string);
        }
    }   
}

Prueba también esto:

puede determinar cuál de los botones del mouse se presiona, mediante estos tres métodos de SwingUtilities:

isLeftMouseButton

isMiddleMouseButton

isRightMouseButton

Answer 3

La API del oyente de la rueda del ratón

Aunque MouseWheelListener tiene un solo método, tiene la clase de adaptador correspondiente: MouseAdapter . Esta capacidad permite que una aplicación tenga solo una instancia de clase de adaptador para que el componente administre todos los tipos de eventos desde el puntero del mouse.

mouseWheelMoved(MouseWheelEvent)    //Called when the mouse wheel is rotated.

El siguiente fragmento de código está relacionado con la gestión de eventos de la rueda del ratón:

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;

import javax.swing.*;

public class MouseWheelEventDemo extends JPanel
        implements MouseWheelListener {
    JTextArea textArea;
    JScrollPane scrollPane;
    static final String NEWLINE = System.getProperty("line.separator");

    public static void main(String[] args) {
        /* Use an appropriate Look and Feel */
        try {
            //UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
            //UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
            UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
        } catch (UnsupportedLookAndFeelException ex) {
            ex.printStackTrace();
        } catch (IllegalAccessException ex) {
            ex.printStackTrace();
        } catch (InstantiationException ex) {
            ex.printStackTrace();
        } catch (ClassNotFoundException ex) {
            ex.printStackTrace();
        }
        /* Turn off metal''s use of bold fonts */
        UIManager.put("swing.boldMetal", Boolean.FALSE);

        //Schedule a job for the event dispatch thread:
        //creating and showing this application''s GUI.
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }

    /**
     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event dispatch thread.
     */
    private static void createAndShowGUI() {
        //Create and set up the window.
        JFrame frame = new JFrame("MouseWheelEventDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        //Create and set up the content pane.
        JComponent newContentPane = new MouseWheelEventDemo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);

        //Display the window.
        frame.pack();
        frame.setVisible(true);
    }

    public MouseWheelEventDemo() {
        super(new BorderLayout());

        textArea = new JTextArea();
        textArea.setEditable(false);
        scrollPane = new JScrollPane(textArea);
        scrollPane.setVerticalScrollBarPolicy(
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
        scrollPane.setPreferredSize(new Dimension(400, 250));
        add(scrollPane, BorderLayout.CENTER);
        textArea.append("This text area displays information "
                + "about its mouse wheel events."
                + NEWLINE);

        //Register for mouse-wheel events on the text area.
        textArea.addMouseWheelListener(this);

        setPreferredSize(new Dimension(450, 350));
        setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
    }

    //Append to the text area and make sure the new text is visible.
    void eventOutput(String eventDescription, MouseWheelEvent e) {
        textArea.append(e.getComponent().getClass().getName()
        + ": "
                + eventDescription);
        textArea.setCaretPosition(textArea.getDocument().getLength());
    }

    public void mouseWheelMoved(MouseWheelEvent e) {
        String message;
        int notches = e.getWheelRotation();
        if (notches < 0) {
            message = "Mouse wheel moved UP "
                    + -notches + " notch(es)" + NEWLINE;
        } else {
            message = "Mouse wheel moved DOWN "         
                    + notches + " notch(es)" + NEWLINE;
        }
        if (e.getScrollType() == MouseWheelEvent.WHEEL_UNIT_SCROLL) {
            message += "    Scroll type: WHEEL_UNIT_SCROLL" + NEWLINE;
            message += "    Scroll amount: " + e.getScrollAmount()
            + " unit increments per notch" + NEWLINE;
            message += "    Units to scroll: " + e.getUnitsToScroll()
            + " unit increments" + NEWLINE;
            message += "    Vertical unit increment: "
                    + scrollPane.getVerticalScrollBar().getUnitIncrement(1)
                    + " pixels" + NEWLINE;
        } else { //scroll type == MouseWheelEvent.WHEEL_BLOCK_SCROLL
            message += "    Scroll type: WHEEL_BLOCK_SCROLL" + NEWLINE;
            message += "    Vertical block increment: "
                    + scrollPane.getVerticalScrollBar().getBlockIncrement(1)
                    + " pixels" + NEWLINE;
        }
        eventOutput(message, e);
    }
}

La salida de MouseWheelEventDemo para un sistema que usa incrementos de unidades para su rueda de mouse podría tener el siguiente aspecto:

javax.swing.JTextArea: Mouse wheel moved UP 1 notch(es)
    Scroll type: WHEEL_UNIT_SCROLL
    Scroll amount: 3 unit increments per notch
    Units to scroll: -3 unit increments
    Vertical unit increment: 16 pixels