/** * Handle the keys which change the terminal font size. * * @param event The key event (key pressed/released/typed) * @param ch The key code (for pressed/release events) or character (for key typed events) */ private boolean handleFontsizeKeys(KeyEvent event, int ch) { boolean handled = false; // Note the following works because VK_EQUALS, VK_PLUS and VK_MINUS // are actually defined as their ASCII (and thus unicode) equivalent. // Since they are final constants this cannot become untrue in the // future. switch (ch) { case KeyEvent.VK_EQUALS: // increase the font size case KeyEvent.VK_PLUS: // increase the font size (non-uk keyboards) if (event.getModifiers() == SHORTCUT_MASK) { PrefMgr.setEditorFontSize(terminalFontSize + 1); event.consume(); handled = true; break; } case KeyEvent.VK_MINUS: // decrease the font size if (event.getModifiers() == SHORTCUT_MASK) { PrefMgr.setEditorFontSize(terminalFontSize - 1); event.consume(); handled = true; break; } } return handled; }
private void PrecioKeyTyped(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_PrecioKeyTyped // TODO add your handling code here: int cont = 0; char caracter = evt.getKeyChar(); if (cont == 0) { if (((caracter < '0') || (caracter > '9')) && (caracter != KeyEvent.VK_BACK_SPACE) && (caracter != '.')) { evt.consume(); } else if (caracter == '.') { String s = Precio.getText(); if (s.length() == 0) { Precio.setText(0 + s); } cont++; } } else { if ((caracter < '0' || caracter > '9')) evt.consume(); } if ((int) caracter == 8) { if (Precio.getText().equals("")) { cont = 0; } } } // GEN-LAST:event_PrecioKeyTyped
@Override public void keyPressed(KeyEvent e, Point2D imagePoint, IcyCanvas canvas) { if (!isActiveFor(canvas)) return; if (!e.isConsumed()) { switch (e.getKeyCode()) { case KeyEvent.VK_ESCAPE: // shape selected ? --> unselect the ROI if (ROI2D.this.selected) { ROI2D.this.setSelected(false, false); e.consume(); } break; case KeyEvent.VK_DELETE: case KeyEvent.VK_BACK_SPACE: // roi selected ? if (ROI2D.this.selected) { // remove selected control point if there is one if (removeSelectedPoint(canvas, imagePoint)) e.consume(); else { // else simply delete ROI ROI2D.this.delete(); e.consume(); } } // roi focused ? --> delete ROI else if (ROI2D.this.focused) { ROI2D.this.delete(); e.consume(); } break; } } }
private void tf_valorKeyTyped(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_tf_valorKeyTyped // TODO add your handling code here: if (list_filtros.getSelectedItem() == "Nombre") { ch = evt.getKeyChar(); if (Character.isDigit(ch)) { getToolkit().beep(); evt.consume(); } } if (list_filtros.getSelectedItem() == "Empleado") { ch = evt.getKeyChar(); if (Character.isDigit(ch)) { getToolkit().beep(); evt.consume(); } else { if (list_filtros.getSelectedItem() == "Código") { ch = evt.getKeyChar(); if (!Character.isDigit(ch)) { getToolkit().beep(); evt.consume(); } } } } } // GEN-LAST:event_tf_valorKeyTyped
@Override public void keyPressed(KeyEvent evt) { if (evt.isConsumed()) return; Component comp = getFocusOwner(); if (evt.getKeyCode() == KeyEvent.VK_ENTER && enterEnabled) { while (comp != null) { if (comp instanceof JComboBox) { JComboBox<?> combo = (JComboBox<?>) comp; if (combo.isEditable()) { Object selected = combo.getEditor().getItem(); if (selected != null) combo.setSelectedItem(selected); } if (combo.isPopupVisible()) { evt.consume(); combo.setPopupVisible(false); } return; } // TODO: add other classes that need custom key handling here. comp = comp.getParent(); } evt.consume(); ok(); } else if (evt.getKeyCode() == KeyEvent.VK_ESCAPE || isCloseBufferShortcut(evt)) { evt.consume(); if (comp instanceof JComboBox) { JComboBox<?> combo = (JComboBox<?>) comp; if (combo.isPopupVisible()) combo.setPopupVisible(false); else cancel(); } else cancel(); } }
@Override public void keyTyped(KeyEvent ke) { if (ke.getSource() == jtxtCodigo) { char c; // capturar el caracter digitado c = ke.getKeyChar(); if (jtxtCodigo.getText().length() >= 5 || (c < '0' || c > '9') && (c != (char) KeyEvent.VK_BACK_SPACE) && (c != (char) KeyEvent.VK_DELETE)) { ke.consume(); // ignora el caracter digitado Toolkit.getDefaultToolkit().beep(); } } if (ke.getSource() == jtxtPrecio) { char c; // capturar el caracter digitado c = ke.getKeyChar(); if (jtxtPrecio.getText().length() >= 10 || (c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c != (char) KeyEvent.VK_BACK_SPACE) && (c != (char) KeyEvent.VK_DELETE)) { ke.consume(); // ignora el caracter digitado Toolkit.getDefaultToolkit().beep(); } } }
@Override public void keyPressed(KeyEvent evt) { Figure f = getOwner(); if (f.isTransformable()) { AffineTransform tx = new AffineTransform(); switch (evt.getKeyCode()) { case KeyEvent.VK_UP: tx.translate(0, -1); evt.consume(); break; case KeyEvent.VK_DOWN: tx.translate(0, +1); evt.consume(); break; case KeyEvent.VK_LEFT: tx.translate(-1, 0); evt.consume(); break; case KeyEvent.VK_RIGHT: tx.translate(+1, 0); evt.consume(); break; } f.willChange(); f.transform(tx); f.changed(); fireUndoableEditHappened(new TransformEdit(f, tx)); } }
// #{GxwCbkHost_ public static final boolean ExecKeyEvent(GxwCbkHost host, KeyEvent e) { boolean rv = true; int id = e.getID(), val = e.getKeyCode(); boolean isAltF4 = false; if (e.isAltDown() && val == IptKey_.F4.Val()) { isAltF4 = true; } if (id == KeyEvent.KEY_TYPED) { IptEvtDataKeyHeld keyHeldData = IptEvtDataKeyHeld.char_(e.getKeyChar()); rv = host.KeyHeldCbk(keyHeldData); if (keyHeldData.Handled()) rv = false; } else { if (e.isShiftDown()) val |= IptKey_.Shift.Val(); if (e.isControlDown()) val |= IptKey_.Ctrl.Val(); if (e.isAltDown()) val |= IptKey_.Alt.Val(); IptEvtDataKey keyData = IptEvtDataKey.int_(val); // Tfds.Write(e.getKeyChar(), e.getKeyCode(), val, id); if (id == KeyEvent.KEY_PRESSED) rv = host.KeyDownCbk(keyData); else if (id == KeyEvent.KEY_RELEASED) rv = host.KeyUpCbk(keyData); if (keyData.Handled()) rv = false; // was false } if (isAltF4) { e.consume(); } if (e.getKeyCode() == KeyEvent.VK_ALT) e.consume(); // force consume of alt-keys; occurs when alt-f4ing out of video app (though // not audio app) return rv; }
@Override public void keyPressed(KeyEvent e) { TreePath path = myTree.getLeadSelectionPath(); if (path == null) return; final Object lastComponent = path.getLastPathComponent(); if (e.getKeyCode() == KeyEvent.VK_ENTER) { if (lastComponent instanceof ParentNode) return; doOKAction(); e.consume(); } else if (e.getKeyCode() == KeyEvent.VK_INSERT) { if (lastComponent instanceof ElementNode) { final DefaultMutableTreeNode node = (DefaultMutableTreeNode) lastComponent; if (!mySelectedNodes.contains(node)) { if (node.getNextNode() != null) { myTree.setSelectionPath(new TreePath(node.getNextNode().getPath())); } } else { if (node.getNextNode() != null) { myTree.removeSelectionPath(new TreePath(node.getPath())); myTree.setSelectionPath(new TreePath(node.getNextNode().getPath())); myTree.repaint(); } } e.consume(); } } }
@Override public void keyPressed(KeyEvent evt) { switch (evt.getKeyCode()) { case KeyEvent.VK_SPACE: goToSelectedNode(M_OPEN); // f**k me dead EventQueue.invokeLater( new Runnable() { @Override public void run() { resultTree.requestFocus(); } }); evt.consume(); break; case KeyEvent.VK_ENTER: goToSelectedNode(M_OPEN); evt.consume(); break; case KeyEvent.VK_DELETE: removeSelectedNode(); evt.consume(); break; default: break; } }
/** * I made this method public in order to be able to call it from the outside. This is needed for * delegating calls. */ public void processKeyEvent(KeyEvent e) { int i = e.getKeyCode(); if (i == KeyEvent.VK_BACK_SPACE && getDocument().getLength() == 0) { e.consume(); return; } if (i == KeyEvent.VK_ENTER || i == KeyEvent.VK_ESCAPE || i == KeyEvent.VK_PAGE_UP || i == KeyEvent.VK_PAGE_DOWN || i == KeyEvent.VK_LEFT || i == KeyEvent.VK_RIGHT) { manageSearchPopup(null); if (i == KeyEvent.VK_ESCAPE) { e.consume(); } return; } if (isUpDownHomeEnd(i)) { e.consume(); return; } super.processKeyEvent(e); if (i == KeyEvent.VK_BACK_SPACE) { e.consume(); } }
public void keyPressed(KeyEvent e) { KeyStroke currentStroke = KeyStroke.getKeyStrokeForEvent(e); if (e.getKeyCode() == KeyEvent.VK_ENTER) { TreePath path = ((JTree) e.getSource()).getSelectionPath(); if (path == null) { return; } AWorkspaceTreeNode node = (AWorkspaceTreeNode) path.getLastPathComponent(); if (node instanceof IWorkspaceNodeActionListener) { ((IWorkspaceNodeActionListener) node) .handleAction( new WorkspaceActionEvent( node, WorkspaceActionEvent.WSNODE_OPEN_DOCUMENT, 0, 0, e.getComponent())); e.consume(); } } else { for (HotKeyIdentifier id : actionKeyMap.keySet()) { if (currentStroke.equals(id.getKeyStroke())) { if (id.accept(e)) { AFreeplaneAction action = WorkspaceController.getAction(actionKeyMap.get(id)); if (action != null) { action.actionPerformed(new ActionEvent(e.getSource(), 0, null)); } else { LogUtils.info("No action set for: " + id.getKeyStroke()); } } e.consume(); break; } } } }
public void keyTyped(KeyEvent e) { char c = e.getKeyChar(); // as a coding convenience, create a reference to the text component // that is typecast to JTextComponent. this is not essential, as we // could typecast every reference, but this makes the code cleaner JTextComponent _theComponent = (JTextComponent) DataTypeTime.this._textComponent; String text = _theComponent.getText(); // tabs and newlines get put into the text before this check, // so remove them // This only applies to Popup editing since these chars are // not passed to this level by the in-cell editor. if (c == KeyEvent.VK_TAB || c == KeyEvent.VK_ENTER) { // remove all instances of the offending char int index = text.indexOf(c); if (index == text.length() - 1) { text = text.substring(0, text.length() - 1); // truncate string } else { text = text.substring(0, index) + text.substring(index + 1); } ((IRestorableTextComponent) _theComponent).updateText(text); _beepHelper.beep(_theComponent); e.consume(); } // handle cases of null // The processing is different when nulls are allowed and when they are not. // if (DataTypeTime.this._isNullable) { // user enters something when field is null if (text.equals("<null>")) { if ((c == KeyEvent.VK_BACK_SPACE) || (c == KeyEvent.VK_DELETE)) { // delete when null => original value DataTypeTime.this._textComponent.restoreText(); e.consume(); } else { // non-delete when null => clear field and add text DataTypeTime.this._textComponent.updateText(""); // fall through to normal processing of this key stroke } } else { // check for user deletes last thing in field if ((c == KeyEvent.VK_BACK_SPACE) || (c == KeyEvent.VK_DELETE)) { if (text.length() <= 1) { // about to delete last thing in field, so replace with null DataTypeTime.this._textComponent.updateText("<null>"); e.consume(); } } } } else { // field is not nullable // handleNotNullableField(text, c, e, _textComponent); } }
@Override public void keyTyped(KeyEvent event) { // We handle most things we are interested in here. The InputMap filters out // most other unwanted actions (but allows copy/paste). char ch = event.getKeyChar(); if ((!isMacOs) && handleFontsizeKeys(event, ch)) { // Note: On Mac OS with Java 7+, we don't see command+= / command+- as a // key-typed event and so we handle it in keyReleased instead. return; } if ((event.getModifiers() & Event.META_MASK) != 0) { return; // return without consuming the event } if (isActive) { switch (ch) { case 4: // CTRL-D (unix/Mac EOF) case 26: // CTRL-Z (DOS/Windows EOF) buffer.signalEOF(); writeToTerminal("\n"); event.consume(); break; case '\b': // backspace if (buffer.backSpace()) { try { int length = text.getDocument().getLength(); text.replaceRange("", length - 1, length); } catch (Exception exc) { Debug.reportError("bad location " + exc); } } event.consume(); break; case '\r': // carriage return case '\n': // newline if (buffer.putChar('\n')) { writeToTerminal(String.valueOf(ch)); buffer.notifyReaders(); } event.consume(); break; default: if (ch >= 32) { if (buffer.putChar(ch)) { writeToTerminal(String.valueOf(ch)); } event.consume(); } break; } } }
public void processKeyEvent(KeyEvent evt) { evt = KeyEventWorkaround.processKeyEvent(evt); if (evt == null) return; switch (evt.getID()) { case KeyEvent.KEY_TYPED: char ch = evt.getKeyChar(); if (!nonDigit && Character.isDigit(ch)) { super.processKeyEvent(evt); repeat = true; repeatCount = Integer.parseInt(action.getText()); } else { nonDigit = true; if (repeat) { passToView(evt); } else super.processKeyEvent(evt); } break; case KeyEvent.KEY_PRESSED: int keyCode = evt.getKeyCode(); if (evt.isActionKey() || evt.isControlDown() || evt.isAltDown() || evt.isMetaDown() || keyCode == KeyEvent.VK_BACK_SPACE || keyCode == KeyEvent.VK_DELETE || keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_TAB || keyCode == KeyEvent.VK_ESCAPE) { nonDigit = true; if (repeat) { passToView(evt); break; } else if (keyCode == KeyEvent.VK_TAB) { complete(true); evt.consume(); } else if (keyCode == KeyEvent.VK_ESCAPE) { evt.consume(); if (popup != null) { popup.dispose(); popup = null; action.requestFocus(); } else { if (temp) view.removeToolBar(ActionBar.this); view.getEditPane().focusOnTextArea(); } break; } else if ((keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN) && popup != null) { popup.list.processKeyEvent(evt); break; } } super.processKeyEvent(evt); break; } }
public void keyTyped(KeyEvent e) { String numStr = "0123456789" + (char) 8; // 只允许输入数字与退格键 if (numStr.indexOf(e.getKeyChar()) < 0) { e.consume(); } if (keepmoney.getText().length() > 2 || keepmoney.getText().length() < 0) { e.consume(); } }
/** * Handle a key pressed event. This will look up the binding for the key stroke and execute it. */ @Override @SuppressWarnings("unchecked") public void keyPressed(KeyEvent evt) { int keyCode = evt.getKeyCode(); int modifiers = evt.getModifiers(); if (keyCode == KeyEvent.VK_CONTROL || keyCode == KeyEvent.VK_SHIFT || keyCode == KeyEvent.VK_ALT || keyCode == KeyEvent.VK_META) return; if ((modifiers & InputEvent.SHIFT_MASK) != 0 || (modifiers & InputEvent.CTRL_MASK) != 0 || evt.isActionKey() || keyCode == KeyEvent.VK_BACK_SPACE || keyCode == KeyEvent.VK_DELETE || keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_TAB || keyCode == KeyEvent.VK_ESCAPE) { if (grabAction != null) { handleGrabAction(evt); return; } KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers); Object o = currentBindings.get(keyStroke); if (o == null) { // Don't beep if the user presses some // key we don't know about unless a // prefix is active. Otherwise it will // beep when caps lock is pressed, etc. if (currentBindings != bindings) { Toolkit.getDefaultToolkit().beep(); // F10 should be passed on, but C+e F10 // shouldn't repeatCount = 0; repeat = false; evt.consume(); } currentBindings = bindings; return; } else if (o instanceof ActionListener) { currentBindings = bindings; executeAction(((ActionListener) o), evt.getSource(), null); evt.consume(); return; } else if (o instanceof Hashtable) { currentBindings = (Hashtable) o; evt.consume(); return; } } }
public void validarNumerosETamanho( java.awt.event.KeyEvent evt, javax.swing.JTextField campo, int maxCaracteres) { if (!numeros.contains( evt.getKeyChar() + "")) { // se o carácter que gerou o evento não estiver na lista evt.consume(); } if (campo.getText().length() >= maxCaracteres) { evt.consume(); } }
public void processKeyEvent(KeyEvent ev) { char c = ev.getKeyChar(); if ((Character.isLetter(c) && !ev.isAltDown()) || badchars.indexOf(c) > -1) { ev.consume(); return; } if (c == '-' && getDocument().getLength() > 0) ev.consume(); else { super.processKeyEvent(ev); } }
private void diafinKeyTyped(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_diafinKeyTyped int Limite = 2; char K; K = evt.getKeyChar(); if (diafin.getText().length() == Limite) { evt.consume(); } if (K < '0' || K > '9') { evt.consume(); } } // GEN-LAST:event_diafinKeyTyped
@Override public void keyTyped(KeyEvent e) { // ���ڸ� ���� char c = e.getKeyChar(); if (!Character.isDigit(c)) { e.consume(); return; } if (m_LidText.getText().length() == 3) e.consume(); }
private void camponombreKeyTyped( java.awt.event.KeyEvent evt) { // GEN-FIRST:event_camponombreKeyTyped int Limite = 50; char K; K = evt.getKeyChar(); if (camponombre.getText().length() == Limite) { evt.consume(); } if (!(K < '0' || K > '9')) { evt.consume(); } } // GEN-LAST:event_camponombreKeyTyped
@Override public void keyPressed(KeyEvent e) { if (!e.isConsumed()) { if (e.getKeyCode() == 38) { // UP parentForm.focusPreviousColumnPanel(DatasetRecordEditorColumnForm.this); e.consume(); } else if (e.getKeyCode() == 40) { // DOWN parentForm.focusNextColumnPanel(DatasetRecordEditorColumnForm.this); e.consume(); } } }
@Override public void keyPressed(KeyEvent e) { if (e.isConsumed()) return; if (ren.VisibleActorCount() == 0) return; vtkActorCollection ac; vtkActor anActor; int i; switch (e.getKeyChar()) { case 'r': // reset camera resetCamera(); repaint(); // consume event e.consume(); break; case 'w': // wireframe mode lock(); try { ac = ren.GetActors(); ac.InitTraversal(); for (i = 0; i < ac.GetNumberOfItems(); i++) { anActor = ac.GetNextActor(); anActor.GetProperty().SetRepresentationToWireframe(); } } finally { unlock(); } repaint(); // consume event e.consume(); break; case 's': lock(); try { ac = ren.GetActors(); ac.InitTraversal(); for (i = 0; i < ac.GetNumberOfItems(); i++) { anActor = ac.GetNextActor(); anActor.GetProperty().SetRepresentationToSurface(); } } finally { unlock(); } repaint(); // consume event e.consume(); break; } }
private void tf_telefKeyTyped(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_tf_telefKeyTyped // TODO add your handling code here: int limite = 10; if (tf_telef.getText().length() == limite) { getToolkit().beep(); evt.consume(); // se le ignora } ch = evt.getKeyChar(); if (!Character.isDigit(ch)) { getToolkit().beep(); evt.consume(); } } // GEN-LAST:event_tf_telefKeyTyped
// Handle the keystrokes public void keyTyped(KeyEvent e) { switch (e.getKeyChar()) { case 'h': gl.matrixMode(GL.MODELVIEW); /* manipulate modelview matrix */ gl.rotate(15.0, 0.0, 1.0, 0.0); break; case 'j': gl.matrixMode(GL.MODELVIEW); /* manipulate modelview matrix */ gl.rotate(15.0, 1.0, 0.0, 0.0); break; case 'k': gl.matrixMode(GL.MODELVIEW); /* manipulate modelview matrix */ gl.rotate(-15.0, 1.0, 0.0, 0.0); break; case 'l': gl.matrixMode(GL.MODELVIEW); /* manipulate modelview matrix */ gl.rotate(-15.0, 0.0, 1.0, 0.0); break; case '+': gl.matrixMode(GL.PROJECTION); /* manipulate Projection matrix */ gl.translate(0.0, 0.0, 0.5); e.consume(); break; case '-': gl.matrixMode(GL.PROJECTION); /* manipulate Projection matrix */ gl.translate(0.0, 0.0, -0.5); e.consume(); break; case 's': if (r_thread == null) { r_thread = new Thread(this); r_thread.start(); } break; case 'p': if (r_thread != null) { r_thread.interrupt(); r_thread = null; } break; case 27: /* Esc will quit */ System.exit(1); break; default: break; } e.consume(); display(); }
@Override protected void processKeyEvent(KeyEvent e) { // TODO: Convert into Actions and put into InputMap/ActionMap? final int hexColumns = model.getNumberOfHexColumns(); final long lastOffset = model.getSize() - 1; final boolean extend = e.isShiftDown(); if (e.getID() == KeyEvent.KEY_PRESSED) { switch (e.getKeyCode()) { case KeyEvent.VK_LEFT: long offs = leadSelectionIndex > 0 ? leadSelectionIndex - 1 : 0; changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_RIGHT: offs = Math.min(leadSelectionIndex + 1, lastOffset); changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_UP: offs = Math.max(leadSelectionIndex - hexColumns, 0); changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_DOWN: offs = Math.min(leadSelectionIndex + hexColumns, lastOffset); changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_PAGE_DOWN: int visibleRowCount = getVisibleRect().height / getRowHeight(); offs = Math.min(leadSelectionIndex + visibleRowCount * hexColumns, lastOffset); changeSelectionByOffset(offs, extend); e.consume(); break; case KeyEvent.VK_PAGE_UP: visibleRowCount = getVisibleRect().height / getRowHeight(); offs = Math.max(leadSelectionIndex - visibleRowCount * hexColumns, 0); changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_HOME: offs = (leadSelectionIndex / hexColumns) * hexColumns; changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_END: offs = (leadSelectionIndex / hexColumns) * hexColumns + hexColumns - 1; offs = Math.min(offs, lastOffset); changeSelectionByOffset(offs, extend); e.consume(); return; case KeyEvent.VK_BACK_SPACE: // System.out.println(); // Profiler.print(); // System.out.println(Profiler.getTime()); return; } } super.processKeyEvent(e); }
public boolean processKeyTyped(EditorContext editorContext, final KeyEvent keyEvent) { EditorComponent nodeEditor = editorContext.getNodeEditorComponent(); nodeEditor.hideMessageToolTip(); if (processKeyMaps(editorContext, keyEvent)) { return true; } final EditorCell selectedCell = editorContext.getSelectedCell(); if (selectedCell != null && ((jetbrains.mps.nodeEditor.cells.EditorCell) selectedCell) .processKeyTyped(keyEvent, false)) { keyEvent.consume(); return true; } jetbrains.mps.openapi.editor.cells.CellActionType actionType = editorContext.getNodeEditorComponent().getActionType(keyEvent, editorContext); if (selectedCell != null) { boolean strictMatching = jetbrains.mps.openapi.editor.cells.CellActionType.RIGHT_TRANSFORM.equals(actionType) || jetbrains.mps.openapi.editor.cells.CellActionType.LEFT_TRANSFORM.equals( actionType); if (selectedCell.isErrorState() && strictMatching) { if (APICellAdapter.validate(selectedCell, strictMatching, false)) { return true; } } if (actionType != null) { if (editorContext .getEditorComponent() .getActionHandler() .executeAction(selectedCell, actionType)) { return true; } } } if (selectedCell != null && ((jetbrains.mps.nodeEditor.cells.EditorCell) selectedCell) .processKeyTyped(keyEvent, true)) { keyEvent.consume(); return true; } return false; }
public void keyPressed(KeyEvent e) { TreePath selectionPath = mainTree.getSelectionPath(); if (selectionPath == null || mainTree.getSelectionCount() == 0) { return; } if (mainTree.getSelectionCount() == 1) { SoapUITreeNode lastPathComponent = (SoapUITreeNode) selectionPath.getLastPathComponent(); ActionList actions = lastPathComponent.getActions(); if (actions != null) { actions.dispatchKeyEvent(e); } if (!e.isConsumed()) { KeyStroke ks = KeyStroke.getKeyStrokeForEvent(e); if (ks.equals(UISupport.getKeyStroke("alt C"))) { mainTree.collapsePath(selectionPath); e.consume(); } else if (ks.equals(UISupport.getKeyStroke("alt E"))) { mainTree.collapsePath(selectionPath); int row = mainTree.getSelectionRows()[0]; TreePath nextPath = mainTree.getPathForRow(row + 1); TreePath path = mainTree.getPathForRow(row); while (path != null && !path.equals(nextPath)) { mainTree.expandRow(row); path = mainTree.getPathForRow(++row); } e.consume(); } } } else { TreePath[] selectionPaths = mainTree.getSelectionPaths(); List<ModelItem> targets = new ArrayList<ModelItem>(); for (TreePath treePath : selectionPaths) { SoapUITreeNode node = (SoapUITreeNode) treePath.getLastPathComponent(); targets.add(node.getModelItem()); } if (targets.size() > 0) { ActionList actions = ActionListBuilder.buildMultiActions(targets.toArray(new ModelItem[targets.size()])); if (actions.getActionCount() > 0) { actions.dispatchKeyEvent(e); } } } }
private void jtfRacionAsignadaKeyTyped( java.awt.event.KeyEvent evt) { // GEN-FIRST:event_jtfRacionAsignadaKeyTyped // TODO add your handling code here: if (!Character.isDigit(evt.getKeyChar()) || evt.getKeyChar() != '.') { evt.consume(); } } // GEN-LAST:event_jtfRacionAsignadaKeyTyped