español - Javafx 2 haga clic y haga doble clic

javafx tutorial netbeans pdf

Question

Me gustaría saber si fue posible detectar el doble clic en JavaFX 2. y cómo ?

Me gustaría hacer un evento diferente entre un clic y un doble clic.

Gracias

Answer 1

Adherirse a Java SE 8 expresiones lambda se vería así:

node.setOnMouseClicked(event -> {
    if(event.getButton().equals(MouseButton.PRIMARY) && event.getClickCount() == 2) {
        handleSomeAction();
    }
});

Una vez que te acostumbras a las expresiones lambda, terminan siendo más comprensibles que el método original de ejemplificación de clases y anulación (x). -En mi opinión-

Answer 2

Aquí hay otro fragmento de código que puede usarse si tiene que distinguir entre un solo clic y un doble clic y debe realizar una acción específica en cualquier caso.

import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.input.MouseButton;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class DoubleClickDetectionTest extends Application {

    boolean dragFlag = false;

    int clickCounter = 0;

    ScheduledThreadPoolExecutor executor;

    ScheduledFuture<?> scheduledFuture;

    public DoubleClickDetectionTest() {
        executor = new ScheduledThreadPoolExecutor(1);
        executor.setRemoveOnCancelPolicy(true);
    }

    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
        StackPane root = new StackPane();

        primaryStage.setScene(new Scene(root, 400, 400));
        primaryStage.show();

        root.setOnMouseDragged(new EventHandler<MouseEvent>() {
            @Override
            public void handle(MouseEvent e) {
                if (e.getButton().equals(MouseButton.PRIMARY)) {
                    dragFlag = true;
                }
            }
        });

        root.setOnMouseClicked(new EventHandler<MouseEvent>() {
            @Override
            public void handle(MouseEvent e) {
                if (e.getButton().equals(MouseButton.PRIMARY)) {
                    if (!dragFlag) {
                        System.out.println(++clickCounter + " " + e.getClickCount());
                        if (e.getClickCount() == 1) {
                            scheduledFuture = executor.schedule(() -> singleClickAction(), 500, TimeUnit.MILLISECONDS);
                        } else if (e.getClickCount() > 1) {
                            if (scheduledFuture != null && !scheduledFuture.isCancelled() && !scheduledFuture.isDone()) {
                                scheduledFuture.cancel(false);
                                doubleClickAction();
                            }
                        }
                    }
                    dragFlag = false;
                }
            }
        });
    }

    @Override
    public void stop() {
        executor.shutdown();
    }

    private void singleClickAction() {
        System.out.println("Single-click action executed.");
    }

    private void doubleClickAction() {
        System.out.println("Double-click action executed.");
    }
}

Answer 3

Así es como he implementado un doble clic

if (e.getEventType().equals(MouseEvent.MOUSE_CLICKED) && !drag_Flag) {
                long diff = 0;
            if(time1==0)
             time1=System.currentTimeMillis();
            else
            time2=System.currentTimeMillis();
            if(time1!=0 && time2!=0)
            diff=time2-time1;
            if((diff/1000)<=215 && diff>0)
            {
                isdblClicked=true;
            }
            else
            {
                isdblClicked=false;
            }

            System.out.println("IsDblClicked()"+isdblClicked); 

}

Answer 4

Dado que no es posible distinguir entre un solo clic y doble clic de manera predeterminada, usamos el siguiente enfoque:

Con un solo clic, ajustamos la operación de un solo clic en un ejecutable cancelable. Este ejecutable espera una cierta cantidad de tiempo (es decir, SINGLE_CLICK_DELAY ) antes de ser ejecutado.

Mientras tanto, si se produce un segundo clic, es decir, un doble clic, la operación de un solo clic se cancela y solo se realiza la operación de doble clic.

De esta forma, se realiza la operación de un solo clic o doble clic, pero nunca ambas.

A continuación está el código completo. Para usarlo, solo las tres líneas TODO deben ser reemplazadas por los manejadores deseados.

private static final int SINGLE_CLICK_DELAY = 250;
private ClickRunner latestClickRunner = null;

private class ClickRunner implements Runnable {

    private final Runnable onSingleClick;
    private boolean aborted = false;

    public ClickRunner(Runnable onSingleClick) {
        this.onSingleClick = onSingleClick;
    }

    public void abort() {
        this.aborted = true;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(SINGLE_CLICK_DELAY);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (!aborted) {
            System.out.println("Execute Single Click");
            Platform.runLater(() -> onSingleClick.run());
        }
    }
}

private void init() {
    container.setOnMouseClicked(me -> {
        switch (me.getButton()) {
            case PRIMARY:
                if (me.getClickCount() == 1) {
                    System.out.println("Single Click");
                    latestClickRunner = new ClickRunner(() -> {
                      // TODO: Single-left-click operation
                    });
                    CompletableFuture.runAsync(latestClickRunner);
                }
                if (me.getClickCount() == 2) {
                    System.out.println("Double Click");
                    if (latestClickRunner != null) {
                        System.out.println("-> Abort Single Click");
                        latestClickRunner.abort();
                    }
                    // TODO: Double-left-click operation
                }
                break;
            case SECONDARY:
                // TODO: Right-click operation
                break;
            default:
                break;
        }
    });
}

Answer 5

La respuesta de P. Pandey es el enfoque más simple que realmente distingue entre clics simples y dobles, pero no funcionó para mí. Por un lado, la función "currentTimeMillis" ya devuelve milisegundos, por lo que dividirlo por 1000 no parece ser necesario. La versión siguiente funcionó para mí de una manera más consistente.

 @Override
 public void handle(MouseEvent t) {

        long diff = 0;

        currentTime=System.currentTimeMillis();

        if(lastTime!=0 && currentTime!=0){
            diff=currentTime-lastTime;

            if( diff<=215)
                isdblClicked=true;
            else
                isdblClicked=false;
        }

        lastTime=currentTime;

        System.out.println("IsDblClicked()"+isdblClicked); 

       //use the isdblClicked flag...   
}

Answer 6

No funciona si desea manejar un clic Y hacer doble clic agregando

if(mouseEvent.getClickCount() == 2) 
{ 
  System.out.println("Doubleclicked"); 
} 
else if(mouseEvent.getClickCount() == 1)
{   
  System.out.println("Single clicked"); 
}

Resultados en: "Single clicked" siempre se activa.

Answer 7

Sí, puede detectar clics individuales, dobles o múltiples:

myNode.setOnMouseClicked(new EventHandler<MouseEvent>() {
    @Override
    public void handle(MouseEvent mouseEvent) {
        if(mouseEvent.getButton().equals(MouseButton.PRIMARY)){
            if(mouseEvent.getClickCount() == 2){
                System.out.println("Double clicked");
            }
        }
    }
});

MouseButton.PRIMARY se utiliza para determinar si el botón izquierdo (comúnmente) del mouse activa el evento. Lea la API de getClickCount() para concluir que tal vez haya varios clics de clics además de uno o dos. Sin embargo, me resulta difícil distinguir entre los eventos de clic simple y doble. Debido a que el primer clic en el doble clic se levantará un solo evento también.