java类com.google.gwt.event.dom.client.KeyUpEvent的实例源码

/**
 * @param eventBus
 */
private void addRVKeyUpEvent(HandlerManager eventBus) {
    eventBus.addHandler(RVKeyUpEvent.type, new RVKeyUpEventHandler() {

        @Override
        public void onKeyUp(RVKeyUpEvent event) {
            KeyUpEvent keyEvent = event.getEvent();
            if (keyEvent.isControlKeyDown()) {
                int keyCode = keyEvent.getNativeEvent().getKeyCode();
                switch (keyCode) {
                    case 'n':
                    case 'N':
                        keyNUpEvent(keyEvent);
                        break;
                    case 'p':
                    case 'P':
                        keyPUpEvent(keyEvent);
                        break;
                    default:
                        break;
                }
            }
        }

    });
}

/**
 * Called after construction.
 */
@PostConstruct
protected void postConstruct() {
    servicesPanel.add(serviceFlowListWidget);

    String filterTxt = (String)stateService.get(ApplicationStateKeys.SERVICES_LIBRARY_FILTER_TEXT);
    filterServicesTextBox.setText(filterTxt);

 filterServicesTextBox.addKeyUpHandler(new KeyUpHandler() {
        @Override
        public void onKeyUp(KeyUpEvent event) {
            stateService.put(ApplicationStateKeys.SERVICES_LIBRARY_FILTER_TEXT, filterServicesTextBox.getText());
            // Update status
            populateGrid(currentServices);
        }
    });

    // Tooltips
    createServiceButton.setTitle(i18n.format("dslibrary.createServiceButton.tooltip"));
    manageSourcesButton.setTitle(i18n.format("dslibrary.manageSourcesButton.tooltip"));
}

public static AriaStatus getInstance() {
    if (sStatus == null) {
        RootPanel statusPanel = RootPanel.get("UniTimeGWT:AriaStatus");
        if (statusPanel != null && "1".equals(Window.Location.getParameter("aria"))) {
            sStatus = new AriaStatus(statusPanel.getElement(), false);
            sStatus.setStyleName("unitime-VisibleAriaStatus");
        } else {
            sStatus  = new AriaStatus(false);
            RootPanel.get().add(sStatus);
        }

        RootPanel.get().addDomHandler(new KeyUpHandler() {
            @Override
            public void onKeyUp(KeyUpEvent event) {
                if (event.getNativeEvent().getKeyCode() == 191 && (event.isControlKeyDown() || event.isAltKeyDown())) {
                    sStatus.setHTML(sStatus.getHTML());
                }
            }
        }, KeyUpEvent.getType());
    }
    return sStatus;
}

private KeyUpHandler setEscapeHandler() {
    KeyUpHandler handler = new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_ESCAPE == event.getNativeEvent().getKeyCode()) {
                for (Control control : controls) {
                    try {
                        ((DrawFeature) control).cancel();
                    } catch (Exception e) {
                        LOGGER.error("ACTION CANCELED: "
                                + control.getControlId());
                    }
                }
            }
        }
    };
    return handler;
}

private KeyUpHandler setUndoHandler() {
    final KeyUpHandler handler = new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_U == event.getNativeEvent().getKeyCode()) {
                for (final Control control : controls) {
                    try {
                        ((DrawFeature) control).undo();
                    } catch (Exception e) {
                        LOGGER.error(
                                "ACTION UNDO: " + control.getControlId(), e);
                    }
                }
            }
        }
    };
    return handler;
}

private KeyUpHandler setRedoHandler() {
    final KeyUpHandler handler = new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_R == event.getNativeEvent().getKeyCode()) {
                for (final Control control : controls) {
                    try {
                        ((DrawFeature) control).redo();
                    } catch (Exception e) {
                        LOGGER.error("ACTION REDO: "
                                + control.getControlId());
                    }
                }
            }
        }
    };
    return handler;
}

/**
 * Installs a key handler for key events on this window.
 *
 * @param handler handler to receive key events.
 */
static void install(KeySignalHandler handler) {
  //
  // NOTE: There are three potential candidate elements for sinking keyboard
  // events: the window, the document, and the document body. IE7 does not
  // fire events on the window element, and GWT's RootPanel is already a
  // listener on the body, leaving the document as the only cross-browser
  // whole-window event-sinking 'element'.
  //
  DocumentPanel panel = new DocumentPanel(handler);
  panel.setElement(Document.get().<Element>cast());
  panel.addDomHandler(panel, KeyDownEvent.getType());
  panel.addDomHandler(panel, KeyPressEvent.getType());
  panel.addDomHandler(panel, KeyUpEvent.getType());
  RootPanel.detachOnWindowClose(panel);
  panel.onAttach();
}

/**
 * Triggered when a key was depressed.
 *
 * @param event
 *            The KeyUpEvent of the key depressed
 */
@Override
public void onKeyUp(KeyUpEvent event) {
    debug("VComboBoxMultiselect: onKeyUp(" + event.getNativeKeyCode() + ")");

    if (this.enabled && !this.readonly) {
        switch (event.getNativeKeyCode()) {
        case KeyCodes.KEY_ENTER:
        case KeyCodes.KEY_TAB:
        case KeyCodes.KEY_SHIFT:
        case KeyCodes.KEY_CTRL:
        case KeyCodes.KEY_ALT:
        case KeyCodes.KEY_DOWN:
        case KeyCodes.KEY_UP:
        case KeyCodes.KEY_PAGEDOWN:
        case KeyCodes.KEY_PAGEUP:
        case KeyCodes.KEY_ESCAPE:
            // NOP
            break;
        default:
            if (this.textInputEnabled) {
                // when filtering, we always want to see the results on the
                // first page first.
                filterOptions(0);
            }
            break;
        }
    }
}

@Override
protected void extend(final ServerConnector target) {
    textFieldWidget = (VTextField) ((ComponentConnector) target).getWidget();
    textFieldWidget.setImmediate(true);
    textFieldWidget.textChangeEventMode = "EAGER";
    panel.setWidget(select);
    panel.setStyleName("suggestion-popup");
    panel.setOwner(textFieldWidget);

    textFieldWidget.addKeyUpHandler(new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (panel.isAttached()) {
                handlePanelEventDelegation(event);
            } else if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
                rpc.executeQuery(textFieldWidget.getValue(), textFieldWidget.getCursorPos());
            } else {
                doAskForSuggestion();
            }
        }
    });
}

private void handlePanelEventDelegation(final KeyUpEvent event) {
    switch (event.getNativeKeyCode()) {
    case KeyCodes.KEY_DOWN:
        arrowKeyDown(event);
        break;
    case KeyCodes.KEY_UP:
        arrorKeyUp(event);
        break;
    case KeyCodes.KEY_ESCAPE:
        escapeKey();
        break;
    case KeyCodes.KEY_ENTER:
        enterKey();
        break;
    default:
        doAskForSuggestion();
    }
}

@UiHandler("projectName")
void onProjectNameChanged(KeyUpEvent event) {
  if (projectName.getValue() != null && projectName.getValue().contains(" ")) {
    String tmp = projectName.getValue();
    while (tmp.contains(" ")) {
      tmp = tmp.replaceAll(" ", "-");
    }
    projectName.setValue(tmp);
  }

  if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
    return;
  }

  delegate.projectNameChanged(projectName.getText());
}

@UiHandler({"filterField"})
void onFilterChanged(KeyUpEvent event) {
  switch (event.getNativeKeyCode()) {
    case KEY_UP:
      tree.getSelectionModel().selectPrevious();
      break;
    case KEY_DOWN:
      tree.getSelectionModel().selectNext();
      break;
    case KEY_ENTER:
      final List<Node> selectedNodes = tree.getSelectionModel().getSelectedNodes();

      if (!selectedNodes.isEmpty()) {
        final Node node = selectedNodes.get(0);

        if (node instanceof ExecutableCommandNode) {
          delegate.onCommandExecute(((ExecutableCommandNode) node).getData());
        } else if (node instanceof CommandGoalNode) {
          tree.setExpanded(node, !tree.isExpanded(node));
        }
      }
      break;
    default:
      delegate.onFilterChanged(filterField.getValue());
  }
}

@UiHandler("projectDescription")
void onProjectDescriptionChanged(KeyUpEvent event) {
  if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
    return;
  }
  delegate.onProjectDescriptionChanged(projectDescription.getValue());
}

private KeyUpHandler setEscapeHandler() {
    KeyUpHandler handler = new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_ESCAPE == event.getNativeEvent().getKeyCode()) {
                for (Control control : controls) {
                    try {
                        ((DrawFeature) control).cancel();
                    } catch (Exception e) {
                        LOGGER.error("ACTION CANCELED: "
                                + control.getControlId());
                    }
                }
            }
        }
    };
    return handler;
}

private KeyUpHandler setUndoHandler() {
    final KeyUpHandler handler = new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_U == event.getNativeEvent().getKeyCode()) {
                for (final Control control : controls) {
                    try {
                        ((DrawFeature) control).undo();
                    } catch (Exception e) {
                        LOGGER.error(
                                "ACTION UNDO: " + control.getControlId(), e);
                    }
                }
            }
        }
    };
    return handler;
}

private KeyUpHandler setRedoHandler() {
    final KeyUpHandler handler = new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_R == event.getNativeEvent().getKeyCode()) {
                for (final Control control : controls) {
                    try {
                        ((DrawFeature) control).redo();
                    } catch (Exception e) {
                        LOGGER.error("ACTION REDO: "
                                + control.getControlId());
                    }
                }
            }
        }
    };
    return handler;
}

public OwnTextArea() {
    super();
    sinkEvents(Event.ONPASTE);
    addKeyUpHandler(new KeyUpHandler() {
        @Override
        public void onKeyUp(KeyUpEvent event) {
            fireHandler();
        }
    });
}

private VideoFullScreenView getFullScreenView() {
    if (view == null) {
        view = fullScreenViewProvider.get();
        controlsHideTimer = mediaFactory.getVideoControlHideTimer(view);
        RootPanel.get().addDomHandler(this, KeyUpEvent.getType());
    }
    return view;
}

@Override
public void onKeyUp(KeyUpEvent event) {
    if (event.getNativeKeyCode() == KeyCodes.KEY_ESCAPE) {
        event.preventDefault();
        closeFullScreen();
    }

}

/**
 * Add key handler to diagram canvas.
 *  
 * @param panel
 */
protected  void addKeyHandler(DiagramCanvas panel){
    panel.addDomHandler(new KeyUpHandler() {
        @Override
        public void onKeyUp(KeyUpEvent event) {
            DiagramController.this.onKeyUp(event);
        }
    }, KeyUpEvent.getType());
}

/**
 * Trigger action when key up event fired
 * 
 * @param event
 */
protected  void onKeyUp(KeyUpEvent event){
    logger.info("key" +event.getNativeKeyCode() );
    if(event.getNativeKeyCode()== 46){
        logger.info("delete widget");
        deleteWidget();
    }
}

@Override
public void onKeyUp(KeyUpEvent event) {
    if (iCourses.getRowCount() < 2 || iCourses.getData(1) == null) return;
    int row = iCourses.getSelectedRow();
    if (event.getNativeKeyCode() == KeyCodes.KEY_DOWN) {
        if (row < 0 || iCourses.getSelectedRow() + 1 >= iCourses.getRowCount())
            iCourses.setSelected(1, true);
        else
            iCourses.setSelected(row + 1, true);
           scrollToSelectedRow();
           updateCourseDetails();
    } else if (event.getNativeKeyCode()==KeyCodes.KEY_UP) {
        if (row - 1 < 1)
            iCourses.setSelected(iCourses.getRowCount() - 1, true);
        else
            iCourses.setSelected(row - 1, true);
        scrollToSelectedRow();
        updateCourseDetails();
    } else if (event.isControlKeyDown() || event.isAltKeyDown()) {
        for (Map.Entry<Character, Integer> entry: iTabAccessKeys.entrySet())
            if (event.getNativeKeyCode() == Character.toLowerCase(entry.getKey()) || event.getNativeKeyCode() == Character.toUpperCase(entry.getKey())) {
                iCourseDetailsTabBar.selectTab(entry.getValue(), true);
                event.preventDefault();
                event.stopPropagation();
            }
    }
}

private KeyUpHandler createKeyHandler() {
    return new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_PAGEUP == event.getNativeEvent().getKeyCode()) {
                onRelease();
            }
        }
    };
}

private KeyUpHandler createKeyHandler() {
    KeyUpHandler handler=  new KeyUpHandler() {
        @Override
        public void onKeyUp(final KeyUpEvent event) {
            if (KeyCodes.KEY_PAGEDOWN == event.getNativeEvent().getKeyCode()) {
                onRelease();
            }
        }
    };

    return handler;
}

/**
 * Creates a new YoungAndroid project wizard.
 */
public InputTemplateUrlWizard(final NewUrlDialogCallback callback) {
  super(MESSAGES.inputNewUrlCaption(), true, true);

  // Initialize the UI.
  setStylePrimaryName("ode-DialogBox");
  HorizontalPanel panel = new HorizontalPanel();

  urlTextBox = new LabeledTextBox(MESSAGES.newUrlLabel());
  urlTextBox.getTextBox().setWidth("250px");
  urlTextBox.getTextBox().addKeyUpHandler(new KeyUpHandler() {
    @Override
    public void onKeyUp(KeyUpEvent event) {
      int keyCode = event.getNativeKeyCode();
      if (keyCode == KeyCodes.KEY_ENTER) {
        handleOkClick();
      } else if (keyCode == KeyCodes.KEY_ESCAPE) {
        handleCancelClick();
      }
    }
  });

  VerticalPanel page = new VerticalPanel();
  panel.add(urlTextBox);
  page.add(panel);
  addPage(page);

  // Create finish command (create a new Young Android project).
  initFinishCommand(new Command() {
    @Override
    public void execute() {
      String hostUrl = urlTextBox.getText();
      if (TemplateUploadWizard.hasUrl(hostUrl)) {
        Window.alert("The Url " + hostUrl + " already exists.");
      } else {
        callback.updateTemplateOptions(hostUrl);
      }
    }
  });
}

/**
 * Triggered when a key was depressed.
 *
 * @param event
 *            The KeyUpEvent of the key depressed
 */
@Override
public void onKeyUp(KeyUpEvent event) {
    debug("VComboBoxMultiselect: onKeyUp(" + event.getNativeKeyCode() + ")");

    if (this.enabled && !this.readonly) {
        switch (event.getNativeKeyCode()) {
        case KeyCodes.KEY_ENTER:
        case KeyCodes.KEY_TAB:
        case KeyCodes.KEY_SHIFT:
        case KeyCodes.KEY_CTRL:
        case KeyCodes.KEY_ALT:
        case KeyCodes.KEY_DOWN:
        case KeyCodes.KEY_UP:
        case KeyCodes.KEY_PAGEDOWN:
        case KeyCodes.KEY_PAGEUP:
        case KeyCodes.KEY_ESCAPE:
            // NOP
            break;
        default:
            if (this.textInputEnabled) {
                // when filtering, we always want to see the results on the
                // first page first.
                filterOptions(0);
            }
            break;
        }
    }
}

/**
 * isSearchableKey
 *
 * @param event
 * @return
 */
public static boolean isSearchableKey(KeyUpEvent event) {
    if (event != null) {
        return Util.isSearchableKey(event);
    } else {
        return true;
    }
}

/**
 * File textBox
 */
public FileTextBox() {
    textBox = new TextBox();
    textBox.addKeyUpHandler(new KeyUpHandler() {
        @Override
        public void onKeyUp(KeyUpEvent event) {
            switch (event.getNativeKeyCode()) {
                case (char) KeyCodes.KEY_ENTER:
                    switch (action) {
                        case ACTION_RENAME:
                            if (textBox.getText().length() > 0) {
                                Main.get().mainPanel.desktop.browser.fileBrowser.rename(textBox.getText());
                            } else {
                                Main.get().mainPanel.desktop.browser.fileBrowser.hideRename();
                            }
                            break;
                    }
                    Main.get().mainPanel.enableKeyShorcuts(); // Enables general keys applications
                    break;

                case (char) KeyCodes.KEY_ESCAPE:
                    switch (action) {
                        case ACTION_RENAME:
                            Main.get().mainPanel.desktop.browser.fileBrowser.hideRename();
                            break;
                    }
                    Main.get().mainPanel.enableKeyShorcuts(); // Enables general keys applications
                    break;
            }
        }
    });
    textBox.setVisibleLength(20);
    textBox.setStyleName("okm-FileBrowser-TextBox");
    initWidget(textBox);
}

@Override
public void onKeyUp(KeyUpEvent event) {
    if (enabled && !readonly) {
        switch (event.getNativeKeyCode()) {
            case KeyCodes.KEY_ENTER:
                String tbText = tb.getText() == null ? "" : tb.getText();
                String currentText = currentSuggestion == null ? "" : currentSuggestion.getReplacementString();
                if (!this.preventFilterAfterSelect && !tbText.equals(currentText))
                    filterOptions(currentPage);
                else {
                    if (!event.isAnyModifierKeyDown())
                        event.stopPropagation();
                }
                this.preventFilterAfterSelect = false;
                break;
            case KeyCodes.KEY_TAB:
            case KeyCodes.KEY_SHIFT:
            case KeyCodes.KEY_CTRL:
            case KeyCodes.KEY_ALT:
            case KeyCodes.KEY_DOWN:
            case KeyCodes.KEY_UP:
            case KeyCodes.KEY_PAGEDOWN:
            case KeyCodes.KEY_PAGEUP:
                // NOP
                break;
            case KeyCodes.KEY_ESCAPE:
                reset();
                break;
        }

        updateEditState();
    }
}

@Override
public void onKeyUp(KeyUpEvent event) {
    if (enabled && !readonly) {
        switch (event.getNativeKeyCode()) {
            case KeyCodes.KEY_ENTER:
            case KeyCodes.KEY_TAB:
            case KeyCodes.KEY_SHIFT:
            case KeyCodes.KEY_CTRL:
            case KeyCodes.KEY_ALT:
            case KeyCodes.KEY_DOWN:
            case KeyCodes.KEY_UP:
            case KeyCodes.KEY_PAGEDOWN:
            case KeyCodes.KEY_PAGEUP:
            case KeyCodes.KEY_ESCAPE:
                // NOP
                break;
            default:
                // special case for "clear" shortcut action
                if (event.isShiftKeyDown() && event.getNativeKeyCode() == KeyCodes.KEY_DELETE) {
                    suggestionPopup.hide();
                } else {
                    // do not show options popup if we handle shortcut action
                    if (!event.isControlKeyDown()
                            && !event.isAltKeyDown()) {
                        super.onKeyUp(event);
                    }
                }
                break;
        }
    }
}