Java InputMap类代码示例

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
@Override
public <T extends LayoutCell<?>> void apply(VirtualFlow<T> list,
                                            Relation relation) {

    Nodes.addInputMap(list, InputMap.consume(DOUBLE_SELECT, e -> {
        Route route = back.peek()
                          .getRoute(relation);
        if (route == null) {
            return;
        }
        JsonNode item = list.getSelectionModel()
                            .getSelectedItem();
        if (item == null) {
            return;
        }
        try {
            push(extract(route, item));
        } catch (QueryException ex) {
            log.error("Unable to push page: %s", route.getPath(), ex);
        }
    }));
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
public CustomCodeArea(String text, Highlight highlight, Syntax syntax, String name) {
    executor = Executors.newSingleThreadExecutor();
    this.highlight = highlight;
    this.syntax = syntax;
    this.lastText = "";
    this.name = name;

    InputMap<Event> prevent = InputMap.consume(
            anyOf(
                    keyPressed(TAB, SHORTCUT_ANY, SHIFT_ANY)
            )
    );
    Nodes.addInputMap(this, prevent);

    this.setOnKeyPressed(event -> {
        if (event.getCode() == KeyCode.TAB) {
            this.insertText(this.getCaretPosition(), "    ");
        }
    });
    caretPosition = CaretPosition.create();
    this.caretPositionProperty().addListener(listener -> caretPosition.compute(this));
    this.setParagraphGraphicFactory(LineNumberFactory.get(this));
    this.richChanges()
            .filter(this::isChangeable)
            .successionEnds(Duration.ofMillis(20))
            .supplyTask(this::computeHighlightingAsync)
            .awaitLatest(this.richChanges())
            .filterMap(this::getOptional)
            .subscribe(this::applyHighlighting);
    this.replaceText(0, 0, text);
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
@Override
public void start(Stage primaryStage) throws Exception {
    Layout model = new Layout() {
        @Override
        public <T extends LayoutCell<?>> void apply(VirtualFlow<T> list,
                                                    Relation relation) {
            Nodes.addInputMap(list,
                              InputMap.consume(DOUBLE_SELECT,
                                               e -> System.out.println("event: "
                                                                       + list.getSelectionModel()
                                                                             .getSelectedItem())));
        }
    };
    AutoLayout layout = new AutoLayout(Util.build(), model);
    URL url = getClass().getResource("/bootstrap3.css");
    if (url != null) {
        layout.getStylesheets()
              .add(url.toExternalForm());
    }
    AnchorPane.setTopAnchor(layout, 0.0);
    AnchorPane.setLeftAnchor(layout, 0.0);
    AnchorPane.setBottomAnchor(layout, 0.0);
    AnchorPane.setRightAnchor(layout, 0.0);
    AnchorPane root = new AnchorPane();
    root.getChildren()
        .add(layout);
    primaryStage.setScene(new Scene(root, 800, 800));
    primaryStage.show();

    JsonNode data = Util.testData();
    layout.measure(data);
    layout.updateItem(data);
    layout.autoLayout();
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
static <S, E extends Event> HandlerTemplateConsumer<S, E> from(
        InputMap.HandlerConsumer<E> hc, S target) {
    return new HandlerTemplateConsumer<S, E>() {
        @Override
        public <F extends E> void accept(
                EventType<? extends F> t, InputHandlerTemplate<S, ? super F> h) {
            hc.accept(t, evt -> h.process(target, evt));

        }
    };
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
@Test
public void test() {
    StringProperty res = new SimpleStringProperty();

    InputMapTemplate<Node, KeyEvent> imt1 = consume(keyPressed(A), (s, e) -> res.set("A"));
    InputMapTemplate<Node, KeyEvent> imt2 = consume(keyPressed(B), (s, e) -> res.set("B"));
    InputMapTemplate<Node, KeyEvent> imt = imt1.orElse(imt2);
    InputMap<KeyEvent> ignA = InputMap.ignore(keyPressed(A));

    Node node1 = new Region();
    Node node2 = new Region();

    Nodes.addInputMap(node1, ignA);
    InputMapTemplate.installFallback(imt, node1);
    InputMapTemplate.installFallback(imt, node2);

    KeyEvent aPressed = new KeyEvent(KEY_PRESSED, "", "", A, false, false, false, false);
    KeyEvent bPressed = new KeyEvent(KEY_PRESSED, "", "", B, false, false, false, false);

    InputMapTest.dispatch(aPressed, node1);
    assertNull(res.get());
    assertFalse(aPressed.isConsumed());

    InputMapTest.dispatch(aPressed, node2);
    assertEquals("A", res.get());
    assertTrue(aPressed.isConsumed());

    InputMapTest.dispatch(bPressed, node1);
    assertEquals("B", res.get());
    assertTrue(bPressed.isConsumed());
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
@Override
public <T extends LayoutCell<?>> void apply(VirtualFlow<T> list,
                                            Relation relation) {
    Nodes.addInputMap(list, InputMap.consume(DOUBLE_SELECT, e -> {
        doubleClick(list.getSelectionModel()
                        .getSelectedItem(),
                    relation);
    }));
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
/**
 * Converts this InputMapTemplate into an {@link InputMap} for the given {@code target}
 */
public final InputMap<E> instantiate(S target) {
    return new InputMapTemplateInstance<>(this, target);
}
 

import org.fxmisc.wellbehaved.event.InputMap; //导入依赖的package包/类
@Override
public void start(Stage primaryStage) {
    InlineCssTextArea area = new InlineCssTextArea();

    InputMap<Event> preventSelectionOrRightArrowNavigation = InputMap.consume(
            anyOf(
                    // prevent selection via (CTRL + ) SHIFT + [LEFT, UP, DOWN]
                    keyPressed(LEFT,    SHIFT_DOWN, SHORTCUT_ANY),
                    keyPressed(KP_LEFT, SHIFT_DOWN, SHORTCUT_ANY),
                    keyPressed(UP,    SHIFT_DOWN, SHORTCUT_ANY),
                    keyPressed(KP_UP, SHIFT_DOWN, SHORTCUT_ANY),
                    keyPressed(DOWN,    SHIFT_DOWN, SHORTCUT_ANY),
                    keyPressed(KP_DOWN, SHIFT_DOWN, SHORTCUT_ANY),

                    // prevent selection via mouse events
                    eventType(MouseEvent.MOUSE_DRAGGED),
                    eventType(MouseEvent.DRAG_DETECTED),
                    mousePressed().unless(e -> e.getClickCount() == 1 && !e.isShiftDown()),

                    // prevent any right arrow movement, regardless of modifiers
                    keyPressed(RIGHT,     SHORTCUT_ANY, SHIFT_ANY),
                    keyPressed(KP_RIGHT,  SHORTCUT_ANY, SHIFT_ANY)
            )
    );
    Nodes.addInputMap(area, preventSelectionOrRightArrowNavigation);

    area.replaceText(String.join("\n",
            "You can't move the caret to the right via the RIGHT arrow key in this area.",
            "Additionally, you cannot select anything either",
            "",
            ":-p"
    ));
    area.moveTo(0);

    CheckBox addExtraEnterHandlerCheckBox = new CheckBox("Temporarily add an EventHandler to area's `onKeyPressedProperty`?");
    addExtraEnterHandlerCheckBox.setStyle("-fx-font-weight: bold;");

    Label checkBoxExplanation = new Label(String.join("\n",
            "The added handler will insert a newline character at the caret's position when [Enter] is pressed.",
            "If checked, the default behavior and added handler will both occur: ",
            "\tthus, two newline characters should be inserted when user presses [Enter].",
            "When unchecked, the handler will be removed."
    ));
    checkBoxExplanation.setWrapText(true);

    EventHandler<KeyEvent> insertNewlineChar = e -> {
        if (e.getCode().equals(ENTER)) {
            area.insertText(area.getCaretPosition(), "\n");
            e.consume();
        }
    };
    addExtraEnterHandlerCheckBox.selectedProperty().addListener(
            (obs, ov, isSelected) -> area.setOnKeyPressed( isSelected ? insertNewlineChar : null)
    );

    VBox vbox = new VBox(area, addExtraEnterHandlerCheckBox, checkBoxExplanation);
    vbox.setSpacing(10);
    vbox.setPadding(new Insets(10));

    primaryStage.setScene(new Scene(vbox, 700, 350));
    primaryStage.show();
    primaryStage.setTitle("An area whose behavior has been overridden permanently and temporarily!");
}