rtextareaui.java

具有不同语法高亮的编辑器实例

    textArea.removeMouseMotionListener(defaultDragRecognizer);

    if (textArea.getHighlighter()instanceof UIResource) {
      textArea.setHighlighter(null);
    }

    if (textArea.getTransferHandler()instanceof UIResource) {
      textArea.setTransferHandler(null);
    }

    DropTarget dropTarget = textArea.getDropTarget();
    if (dropTarget instanceof UIResource) {
      dropTarget.removeDropTargetListener(dropTargetListener);
    }

  }

      /*****************************************************************************/

  /**
   * Uninstalls the UI for a component.  This removes the listeners,
   * uninstalls the highlighter, removes views, and nulls out the keymap.
   *
   * @param c the editor component
   * @see ComponentUI#uninstallUI
   */
  public void uninstallUI(JComponent c) {

    // detach from the model
    textArea.removePropertyChangeListener(updateHandler);
    textArea.getDocument().removeDocumentListener(updateHandler);

    // view part
    painted = false;
    uninstallDefaults();
    uninstallPrivateDefaults();
    rootView.setView(null);
    c.removeAll();
    LayoutManager lm = c.getLayout();
    if (lm instanceof UIResource) {
      c.setLayout(null);
    }

    // controller part
    uninstallKeyboardActions();
    uninstallListeners();

  }

      /*****************************************************************************/

  /**
   * The superclass </code>ComponentUI</code>'s <code>update</code> method
   * always checks the <code>isOpaque</code> property and fills the
   * background with its appropriate color accordingly.  We don't want this
   * behavior, as the background may be an image, so we simply call
   * <code>paint</code>.
   * @param g The graphics context with which to paint.
   * @param c The component to paint.
   */
  public void update(Graphics g, JComponent c) {
    paint(g, c);
  }

      /*****************************************************************************/

  /**
   * Invoked when the focus accelerator changes, this will update the
   * key bindings as necessary.
   */
  void updateFocusAcceleratorBinding(boolean changed) {

    char accelerator = textArea.getFocusAccelerator();

    if (changed || accelerator != '\0') {
      InputMap km = SwingUtilities.getUIInputMap
          (textArea, JComponent.WHEN_IN_FOCUSED_WINDOW);

      if (km == null && accelerator != '\0') {
        km = new ComponentInputMapUIResource(textArea);
        SwingUtilities.replaceUIInputMap(textArea, JComponent.
                                         WHEN_IN_FOCUSED_WINDOW, km);
        ActionMap am = getActionMap();
        SwingUtilities.replaceUIActionMap(textArea, am);
      }
      if (km != null) {
        km.clear();
        if (accelerator != '\0') {
          km.put(KeyStroke.getKeyStroke(accelerator,
                                        ActionEvent.ALT_MASK),
                 "requestFocus");
        }
      }
    }

  }

      /*****************************************************************************/

  /**
   * Invoked when editable property is changed.
   *
   * removing 'TAB' and 'SHIFT-TAB' from traversalKeysSet in case
   * editor is editable
   * adding 'TAB' and 'SHIFT-TAB' to traversalKeysSet in case
   * editor is non editable
   */
  void updateFocusTraversalKeys() {
    /*
     * Fix for 4514331 Non-editable JTextArea and similar
     * should allow Tab to keyboard - accessibility
     */
    EditorKit editorKit = getEditorKit(textArea);
    if (editorKit != null && editorKit instanceof DefaultEditorKit) {
      Set storedForwardTraversalKeys = textArea.getFocusTraversalKeys(
          KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
      Set storedBackwardTraversalKeys = textArea.getFocusTraversalKeys(
          KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS);
      Set forwardTraversalKeys = new HashSet(storedForwardTraversalKeys);
      Set backwardTraversalKeys = new HashSet(storedBackwardTraversalKeys);
      if (textArea.isEditable()) {
        forwardTraversalKeys.remove(
            KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
        backwardTraversalKeys.remove(
            KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));
      }
      else {
        forwardTraversalKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
        backwardTraversalKeys.add(KeyStroke.getKeyStroke(
            KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));
      }
      textArea.setFocusTraversalKeys(KeyboardFocusManager.
                                     FORWARD_TRAVERSAL_KEYS,
                                     forwardTraversalKeys);
      textArea.setFocusTraversalKeys(KeyboardFocusManager.
                                     BACKWARD_TRAVERSAL_KEYS,
                                     backwardTraversalKeys);
    }

  }

      /*****************************************************************************/

  /**
   * Converts the given place in the view coordinate system
   * to the nearest representative location in the model.
   * The component must have a non-zero positive size for
   * this translation to be computed.
   *
   * @param tc the text component for which this UI is installed
   * @param pt the location in the view to translate.  This
   *  should be in the same coordinate system as the mouse events.
   * @return the offset from the start of the document >= 0,
   *   -1 if not painted
   * @see TextUI#viewToModel
   */
  public int viewToModel(JTextComponent tc, Point pt) {
    return viewToModel(tc, pt, discardBias);
  }

      /*****************************************************************************/

  /**
   * Converts the given place in the view coordinate system
   * to the nearest representative location in the model.
   * The component must have a non-zero positive size for
   * this translation to be computed.
   *
   * @param tc the text component for which this UI is installed
   * @param pt the location in the view to translate.  This
   *  should be in the same coordinate system as the mouse events.
   * @return the offset from the start of the document >= 0,
   *   -1 if the component doesn't yet have a positive size.
   * @see TextUI#viewToModel
   */
  public int viewToModel(JTextComponent tc, Point pt,
                         Position.Bias[] biasReturn) {

    int offs = -1;
    RTextAreaDocument doc = (RTextAreaDocument) textArea.getDocument();
    doc.readLock();
    try {
      Rectangle alloc = getVisibleEditorRect();
      if (alloc != null) {
        rootView.setSize(alloc.width, alloc.height);
        offs = rootView.viewToModel(pt.x, pt.y, alloc, biasReturn);
      }
    }
    finally {
      doc.readUnlock();
    }

    return offs;

  }

      /*****************************************************************************/
      /********************* PRIVATE INNER CLASSES *********************************/
      /*****************************************************************************/

  /**
   * Registered in the ActionMap.
   */
  class FocusAction
      extends AbstractAction {

    /**
     *
     */
    private static final long serialVersionUID = 7487114651885307840L;

    public void actionPerformed(ActionEvent e) {
      textArea.requestFocus();
    }

    public boolean isEnabled() {
      return textArea.isEditable();
    }

  }

      /*****************************************************************************/

  /**
   * Listens to mouse events, and decides when the user is dragging some
   * text.
   */
  static class TextDragGestureRecognizer
      implements MouseListener,
      MouseMotionListener {

    private MouseEvent dndArmedEvent = null;

    protected JComponent getComponent(MouseEvent e) {
      Object src = e.getSource();
      if (src instanceof JComponent) {
        return (JComponent) src;
      }
      return null;
    }

    private static int getMotionThreshold() {
      return 3; //DragSource.getDragThreshold();
    }

    protected int mapDragOperationFromModifiers(MouseEvent e) {
      int mods = e.getModifiersEx();
      if ( (mods & InputEvent.BUTTON1_DOWN_MASK) !=
          InputEvent.BUTTON1_DOWN_MASK) {
        return TransferHandler.NONE;
      }
      JComponent c = getComponent(e);
      TransferHandler th = c.getTransferHandler();
      int sourceActions = th.getSourceActions(c);
      switch (sourceActions) {
        case TransferHandler.NONE:
        case TransferHandler.COPY:
        case TransferHandler.MOVE:
          return sourceActions;
        case TransferHandler.COPY_OR_MOVE:
          return ( (mods & InputEvent.CTRL_MASK) == InputEvent.CTRL_MASK) ?
              TransferHandler.COPY : TransferHandler.MOVE;
      }
      return TransferHandler.NONE; // Should never happen.
    }

    public void mouseClicked(MouseEvent e) {
    }

    public void mousePressed(MouseEvent e) {
      dndArmedEvent = null;
      if (isDragPossible(e) &&
          mapDragOperationFromModifiers(e) != TransferHandler.NONE) {
        dndArmedEvent = e;
        e.consume();
      }
    }

    public void mouseReleased(MouseEvent e) {
      dndArmedEvent = null;
    }

    public void mouseEntered(MouseEvent e) {
      //dndArmedEvent = null;
    }

    public void mouseExited(MouseEvent e) {
      //if (dndArmedEvent != null && mapDragOperationFromModifiers(e) == TransferHandler.NONE) {
      //    dndArmedEvent = null;
      //}
    }

    public void mouseDragged(MouseEvent e) {
      if (dndArmedEvent != null) {
        e.consume();
        int action = mapDragOperationFromModifiers(e);
        if (action == TransferHandler.NONE) {
          return;
        }
        int dx = Math.abs(e.getX() - dndArmedEvent.getX());
        int dy = Math.abs(e.getY() - dndArmedEvent.getY());
        if ( (dx > getMotionThreshold()) || (dy > getMotionThreshold())) {
          // start transfer... shouldn't be a click at this point
          JComponent c = getComponent(e);
          TransferHandler th = c.getTransferHandler();
          th.exportAsDrag(c, dndArmedEvent, action);
          dndArmedEvent = null;
        }
      }
    }

    public void mouseMoved(MouseEvent e) {
    }

    private TransferHandler getTransferHandler(MouseEvent e) {
      JComponent c = getComponent(e);
      return c == null ? null : c.getTransferHandler();
    }

    /**
     * Determines if the following are true:
     * <ul>
     * <li>the press event is located over a selection
     * <li>the dragEnabled property is true
     * <li>A TranferHandler is installed
     * </ul>
     * <p>
     */
    protected boolean isDragPossible(MouseEvent e) {
      JTextComponent c = (JTextComponent)this.getComponent(e);
      if (c.getTransferHandler() != null) {
        if (c.getDragEnabled()) {
          Caret caret = c.getCaret();
          int dot = caret.getDot();
          int mark = caret.getMark();
          if (dot != mark) {
            Point p = new Point(e.getX(), e.getY());
            int pos = c.viewToModel(p);
            int p0 = Math.min(dot, mark);
            int p1 = Math.max(dot, mark);
            if ( (pos >= p0) && (pos < p1)) {
              return true;
            }
          }
        } // End of if (c.getDragEnabled()).
      } // End of if (c.getTransferHandler()!=null).
      return false;
    }

  }

      /*****************************************************************************/

}