public BasicTextUI() 
{
        painted = false;
}

Creates a new UI.

 public View create(Element elem) 
{
        return null;
}

Creates a view for an element. If a subclass wishes to directly implement the factory producing the view(s), it should reimplement this method. By default it simply returns null indicating it is unable to represent the element.

 public View create(Element elem,
    int p0,
    int p1) 
{
        return null;
}

Creates a view for an element. If a subclass wishes to directly implement the factory producing the view(s), it should reimplement this method. By default it simply returns null indicating it is unable to represent the part of the element.

 ActionMap createActionMap() 
{
        ActionMap map = new ActionMapUIResource();
        Action[] actions = editor.getActions();
        //System.out.println("building map for UI: " + getPropertyPrefix());
        int n = actions.length;
        for (int i = 0; i <  n; i++) {
            Action a = actions[i];
            map.put(a.getValue(Action.NAME), a);
            //System.out.println("  " + a.getValue(Action.NAME));
        }
        map.put(TransferHandler.getCutAction().getValue(Action.NAME),
                TransferHandler.getCutAction());
        map.put(TransferHandler.getCopyAction().getValue(Action.NAME),
                TransferHandler.getCopyAction());
        map.put(TransferHandler.getPasteAction().getValue(Action.NAME),
                TransferHandler.getPasteAction());
        return map;
}

Create a default action map. This is basically the set of actions found exported by the component.

 protected Caret createCaret() 
{
        return new BasicCaret();
}

Creates the object to use for a caret. By default an instance of BasicCaret is created. This method can be redefined to provide something else that implements the InputPosition interface or a subclass of JCaret.

 protected Highlighter createHighlighter() 
{
        return new BasicHighlighter();
}

Creates the object to use for adding highlights. By default an instance of BasicHighlighter is created. This method can be redefined to provide something else that implements the Highlighter interface or a subclass of DefaultHighlighter.

 protected Keymap createKeymap() 
{
        String nm = getKeymapName();
        Keymap map = JTextComponent.getKeymap(nm);
        if (map == null) {
            Keymap parent = JTextComponent.getKeymap(JTextComponent.DEFAULT_KEYMAP);
            map = JTextComponent.addKeymap(nm, parent);
            String prefix = getPropertyPrefix();
            Object o = DefaultLookup.get(editor, this,
                prefix + ".keyBindings");
            if ((o != null) && (o instanceof JTextComponent.KeyBinding[])) {
                JTextComponent.KeyBinding[] bindings = (JTextComponent.KeyBinding[]) o;
                JTextComponent.loadKeymap(map, bindings, getComponent().getActions());
            }
        }
        return map;
}

Creates the keymap to use for the text component, and installs any necessary bindings into it. By default, the keymap is shared between all instances of this type of TextUI. The keymap has the name defined by the getKeymapName method. If the keymap is not found, then DEFAULT_KEYMAP from JTextComponent is used.

The set of bindings used to create the keymap is fetched from the UIManager using a key formed by combining the #getPropertyPrefix method and the string .keyBindings. The type is expected to be JTextComponent.KeyBinding[].

 public  void damageRange(JTextComponent tc,
    int p0,
    int p1) 
{
        damageRange(tc, p0, p1, Position.Bias.Forward, Position.Bias.Backward);
}

Causes the portion of the view responsible for the given part of the model to be repainted. Does nothing if the view is not currently painted.

 public  void damageRange(JTextComponent t,
    int p0,
    int p1,
    Bias p0Bias,
    Bias p1Bias) 
{
        if (painted) {
            Rectangle alloc = getVisibleEditorRect();
            if (alloc != null) {
                Document doc = t.getDocument();
                if (doc instanceof AbstractDocument) {
                    ((AbstractDocument)doc).readLock();
                }
                try {
                    rootView.setSize(alloc.width, alloc.height);
                    Shape toDamage = rootView.modelToView(p0, p0Bias,
                            p1, p1Bias, alloc);
                    Rectangle rect = (toDamage instanceof Rectangle) ?
                            (Rectangle)toDamage : toDamage.getBounds();
                    editor.repaint(rect.x, rect.y, rect.width, rect.height);
                } catch (BadLocationException e) {
                } finally {
                    if (doc instanceof AbstractDocument) {
                        ((AbstractDocument)doc).readUnlock();
                    }
                }
            }
        }
}

Causes the portion of the view responsible for the given part of the model to be repainted.

 ActionMap getActionMap() 
{
        String mapName = getPropertyPrefix() + ".actionMap";
        ActionMap map = (ActionMap)UIManager.get(mapName);
        if (map == null) {
            map = createActionMap();
            if (map != null) {
                UIManager.getLookAndFeelDefaults().put(mapName, map);
            }
        }
        ActionMap componentMap = new ActionMapUIResource();
        componentMap.put("requestFocus", new FocusAction());
        /*
         * fix for bug 4515750
         * JTextField & non-editable JTextArea bind return key - default btn not accessible
         *
         * Wrap the return action so that it is only enabled when the
         * component is editable. This allows the default button to be
         * processed when the text component has focus and isn't editable.
         *
         */
        if (getEditorKit(editor) instanceof DefaultEditorKit) {
            if (map != null) {
                Object obj = map.get(DefaultEditorKit.insertBreakAction);
                if (obj != null
                    && obj instanceof DefaultEditorKit.InsertBreakAction) {
                    Action action =  new TextActionWrapper((TextAction)obj);
                    componentMap.put(action.getValue(Action.NAME),action);
                }
            }
        }
        if (map != null) {
            componentMap.setParent(map);
        }
        return componentMap;
}

Fetch an action map to use.

 protected final JTextComponent getComponent() 
{
        return editor;
}

Fetches the text component associated with this UI implementation. This will be null until the ui has been installed.

 public EditorKit getEditorKit(JTextComponent tc) 
{
        return defaultKit;
}

Fetches the EditorKit for the UI.

 InputMap getInputMap() 
{
        InputMap map = new InputMapUIResource();
        InputMap shared =
            (InputMap)DefaultLookup.get(editor, this,
            getPropertyPrefix() + ".focusInputMap");
        if (shared != null) {
            map.setParent(shared);
        }
        return map;
}

Get the InputMap to use for the UI.

 protected String getKeymapName() 
{
        String nm = getClass().getName();
        int index = nm.lastIndexOf('.');
        if (index  >= 0) {
            nm = nm.substring(index+1, nm.length());
        }
        return nm;
}

Fetches the name of the keymap that will be installed/used by default for this UI. This is implemented to create a name based upon the classname. The name is the the name of the class with the package prefix removed.

 public Dimension getMaximumSize(JComponent c) 
{
        Document doc = editor.getDocument();
        Insets i = c.getInsets();
        Dimension d = new Dimension();
        if (doc instanceof AbstractDocument) {
            ((AbstractDocument)doc).readLock();
        }
        try {
            d.width = (int) Math.min((long) rootView.getMaximumSpan(View.X_AXIS) +
                                     (long) i.left + (long) i.right, Integer.MAX_VALUE);
            d.height = (int) Math.min((long) rootView.getMaximumSpan(View.Y_AXIS) +
                                      (long) i.top + (long) i.bottom, Integer.MAX_VALUE);
        } finally {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readUnlock();
            }
        }
        return d;
}

Gets the maximum size for the editor component.

 public Dimension getMinimumSize(JComponent c) 
{
        Document doc = editor.getDocument();
        Insets i = c.getInsets();
        Dimension d = new Dimension();
        if (doc instanceof AbstractDocument) {
            ((AbstractDocument)doc).readLock();
        }
        try {
            d.width = (int) rootView.getMinimumSpan(View.X_AXIS) + i.left + i.right;
            d.height = (int)  rootView.getMinimumSpan(View.Y_AXIS) + i.top + i.bottom;
        } finally {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readUnlock();
            }
        }
        return d;
}

Gets the minimum size for the editor component.

 public int getNextVisualPositionFrom(JTextComponent t,
    int pos,
    Bias b,
    int direction,
    Bias[] biasRet) throws BadLocationException 
{
        Document doc = editor.getDocument();
        if (doc instanceof AbstractDocument) {
            ((AbstractDocument)doc).readLock();
        }
        try {
            if (painted) {
                Rectangle alloc = getVisibleEditorRect();
                if (alloc != null) {
                    rootView.setSize(alloc.width, alloc.height);
                }
                return rootView.getNextVisualPositionFrom(pos, b, alloc, direction,
                                                          biasRet);
            }
        } finally {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readUnlock();
            }
        }
        return -1;
}

{@inheritDoc}

 public Dimension getPreferredSize(JComponent c) 
{
        Document doc = editor.getDocument();
        Insets i = c.getInsets();
        Dimension d = c.getSize();
        if (doc instanceof AbstractDocument) {
            ((AbstractDocument)doc).readLock();
        }
        try {
            if ((d.width  > (i.left + i.right)) && (d.height  > (i.top + i.bottom))) {
                rootView.setSize(d.width - i.left - i.right, d.height - i.top - i.bottom);
            }
            else if (d.width == 0 && d.height == 0) {
                // Probably haven't been layed out yet, force some sort of
                // initial sizing.
                rootView.setSize(Integer.MAX_VALUE, Integer.MAX_VALUE);
            }
            d.width = (int) Math.min((long) rootView.getPreferredSpan(View.X_AXIS) +
                                     (long) i.left + (long) i.right, Integer.MAX_VALUE);
            d.height = (int) Math.min((long) rootView.getPreferredSpan(View.Y_AXIS) +
                                      (long) i.top + (long) i.bottom, Integer.MAX_VALUE);
        } finally {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readUnlock();
            }
        }
        return d;
}

Gets the preferred size for the editor component. If the component has been given a size prior to receiving this request, it will set the size of the view hierarchy to reflect the size of the component before requesting the preferred size of the view hierarchy. This allows formatted views to format to the current component size before answering the request. Other views don't care about currently formatted size and give the same answer either way.

 abstract protected String getPropertyPrefix()
Gets the name used as a key to look up properties through the
UIManager.  This is used as a prefix to all the standard
text properties.

 public View getRootView(JTextComponent tc) 
{
        return rootView;
}

Fetches a View with the allocation of the associated text component (i.e. the root of the hierarchy) that can be traversed to determine how the model is being represented spatially.

NOTE:The View hierarchy can be traversed from the root view, and other things can be done as well. Things done in this way cannot be protected like simple method calls through the TextUI. Therefore, proper operation in the presence of concurrency must be arranged by any logic that calls this method!

 public String getToolTipText(JTextComponent t,
    Point pt) 
{
        if (!painted) {
            return null;
        }
        Document doc = editor.getDocument();
        String tt = null;
        Rectangle alloc = getVisibleEditorRect();
        if (alloc != null) {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readLock();
            }
            try {
                tt = rootView.getToolTipText(pt.x, pt.y, alloc);
            } finally {
                if (doc instanceof AbstractDocument) {
                    ((AbstractDocument)doc).readUnlock();
                }
            }
        }
        return tt;
}

Returns the string to be used as the tooltip at the passed in location. This forwards the method onto the root View.

 TransferHandler getTransferHandler() 
{
        return defaultTransferHandler;
}

Returns the TransferHandler that will be installed if their isn't one installed on the JTextComponent.

 protected Rectangle getVisibleEditorRect() 
{
        Rectangle alloc = editor.getBounds();
        if ((alloc.width  > 0) && (alloc.height  > 0)) {
            alloc.x = alloc.y = 0;
            Insets insets = editor.getInsets();
            alloc.x += insets.left;
            alloc.y += insets.top;
            alloc.width -= insets.left + insets.right;
            alloc.height -= insets.top + insets.bottom;
            return alloc;
        }
        return null;
}

Gets the allocation to give the root View. Due to an unfortunate set of historical events this method is inappropriately named. The Rectangle returned has nothing to do with visibility. The component must have a non-zero positive size for this translation to be computed.

 protected  void installDefaults() 
{
        String prefix = getPropertyPrefix();
        Font f = editor.getFont();
        if ((f == null) || (f instanceof UIResource)) {
            editor.setFont(UIManager.getFont(prefix + ".font"));
        }
        Color bg = editor.getBackground();
        if ((bg == null) || (bg instanceof UIResource)) {
            editor.setBackground(UIManager.getColor(prefix + ".background"));
        }
        Color fg = editor.getForeground();
        if ((fg == null) || (fg instanceof UIResource)) {
            editor.setForeground(UIManager.getColor(prefix + ".foreground"));
        }
        Color color = editor.getCaretColor();
        if ((color == null) || (color instanceof UIResource)) {
            editor.setCaretColor(UIManager.getColor(prefix + ".caretForeground"));
        }
        Color s = editor.getSelectionColor();
        if ((s == null) || (s instanceof UIResource)) {
            editor.setSelectionColor(UIManager.getColor(prefix + ".selectionBackground"));
        }
        Color sfg = editor.getSelectedTextColor();
        if ((sfg == null) || (sfg instanceof UIResource)) {
            editor.setSelectedTextColor(UIManager.getColor(prefix + ".selectionForeground"));
        }
        Color dfg = editor.getDisabledTextColor();
        if ((dfg == null) || (dfg instanceof UIResource)) {
            editor.setDisabledTextColor(UIManager.getColor(prefix + ".inactiveForeground"));
        }
        Border b = editor.getBorder();
        if ((b == null) || (b instanceof UIResource)) {
            editor.setBorder(UIManager.getBorder(prefix + ".border"));
        }
        Insets margin = editor.getMargin();
        if (margin == null || margin instanceof UIResource) {
            editor.setMargin(UIManager.getInsets(prefix + ".margin"));
        }
        updateCursor();
}

Initializes component properties, such as font, foreground, background, caret color, selection color, selected text color, disabled text color, and border color. The font, foreground, and background properties are only set if their current value is either null or a UIResource, other properties are set if the current value is null.

 protected  void installKeyboardActions() 
{
        // backward compatibility support... keymaps for the UI
        // are now installed in the more friendly input map.
        editor.setKeymap(createKeymap());
        InputMap km = getInputMap();
        if (km != null) {
            SwingUtilities.replaceUIInputMap(editor, JComponent.WHEN_FOCUSED,
                                             km);
        }
        ActionMap map = getActionMap();
        if (map != null) {
            SwingUtilities.replaceUIActionMap(editor, map);
        }
        updateFocusAcceleratorBinding(false);
}

 protected  void installListeners() 
{

}

Installs listeners for the UI.

 public  void installUI(JComponent c) 
{
        if (c instanceof JTextComponent) {
            editor = (JTextComponent) c;
            // common case is background painted... this can
            // easily be changed by subclasses or from outside
            // of the component.
            LookAndFeel.installProperty(editor, "opaque", Boolean.TRUE);
            LookAndFeel.installProperty(editor, "autoscrolls", Boolean.TRUE);
            // install defaults
            installDefaults();
            installDefaults2();
            // attach to the model and editor
            editor.addPropertyChangeListener(updateHandler);
            Document doc = editor.getDocument();
            if (doc == null) {
                // no model, create a default one.  This will
                // fire a notification to the updateHandler
                // which takes care of the rest.
                editor.setDocument(getEditorKit(editor).createDefaultDocument());
            } else {
                doc.addDocumentListener(updateHandler);
                modelChanged();
            }
            // install keymap
            installListeners();
            installKeyboardActions();
            LayoutManager oldLayout = editor.getLayout();
            if ((oldLayout == null) || (oldLayout instanceof UIResource)) {
                // by default, use default LayoutManger implementation that
                // will position the components associated with a View object.
                editor.setLayout(updateHandler);
            }
            updateBackground(editor);
        } else {
            throw new Error("TextUI needs JTextComponent");
        }
}

Installs the UI for a component. This does the following things.
1. Sets the associated component to opaque if the opaque property has not already been set by the client program. This will cause the component's background color to be painted.
2. Installs the default caret and highlighter into the associated component. These properties are only set if their current value is either {@code null} or an instance of UIResource .
3. Attaches to the editor and model. If there is no model, a default one is created.
4. Creates the view factory and the view hierarchy used to represent the model.

 protected  void modelChanged() 
{
        // create a view hierarchy
        ViewFactory f = rootView.getViewFactory();
        Document doc = editor.getDocument();
        Element elem = doc.getDefaultRootElement();
        setView(f.create(elem));
}

Flags model changes. This is called whenever the model has changed. It is implemented to rebuild the view hierarchy to represent the default root element of the associated model.

 public Rectangle modelToView(JTextComponent tc,
    int pos) throws BadLocationException 
{
        return modelToView(tc, pos, Position.Bias.Forward);
}

Converts the given location in the model to a place in the view coordinate system. The component must have a non-zero positive size for this translation to be computed.

 public Rectangle modelToView(JTextComponent tc,
    int pos,
    Bias bias) throws BadLocationException 
{
        Document doc = editor.getDocument();
        if (doc instanceof AbstractDocument) {
            ((AbstractDocument)doc).readLock();
        }
        try {
            Rectangle alloc = getVisibleEditorRect();
            if (alloc != null) {
                rootView.setSize(alloc.width, alloc.height);
                Shape s = rootView.modelToView(pos, alloc, bias);
                if (s != null) {
                  return s.getBounds();
                }
            }
        } finally {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readUnlock();
            }
        }
        return null;
}

Converts the given location in the model to a place in the view coordinate system. The component must have a non-zero positive size for this translation to be computed.

 public final  void paint(Graphics g,
    JComponent c) 
{
        if ((rootView.getViewCount()  > 0) && (rootView.getView(0) != null)) {
            Document doc = editor.getDocument();
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readLock();
            }
            try {
                paintSafely(g);
            } finally {
                if (doc instanceof AbstractDocument) {
                    ((AbstractDocument)doc).readUnlock();
                }
            }
        }
}

Paints the interface. This is routed to the paintSafely method under the guarantee that the model won't change from the view of this thread while it's rendering (if the associated model is derived from AbstractDocument). This enables the model to potentially be updated asynchronously.

 protected  void paintBackground(Graphics g) 
{
        g.setColor(editor.getBackground());
        g.fillRect(0, 0, editor.getWidth(), editor.getHeight());
}

Paints a background for the view. This will only be called if isOpaque() on the associated component is true. The default is to paint the background color of the component.

 protected  void paintSafely(Graphics g) 
{
        painted = true;
        Highlighter highlighter = editor.getHighlighter();
        Caret caret = editor.getCaret();
        // paint the background
        if (editor.isOpaque()) {
            paintBackground(g);
        }
        // paint the highlights
        if (highlighter != null) {
            highlighter.paint(g);
        }
        // paint the view hierarchy
        Rectangle alloc = getVisibleEditorRect();
        if (alloc != null) {
            rootView.paint(g, alloc);
        }
        // paint the caret
        if (caret != null) {
            caret.paint(g);
        }
        if (dropCaret != null) {
            dropCaret.paint(g);
        }
}

Paints the interface safely with a guarantee that the model won't change from the view of this thread. This does the following things, rendering from back to front.
1. If the component is marked as opaque, the background is painted in the current background color of the component.
2. The highlights (if any) are painted.
3. The view hierarchy is painted.
4. The caret is painted.

 protected  void propertyChange(PropertyChangeEvent evt) 
{
        if (evt.getPropertyName().equals("editable") ||
                evt.getPropertyName().equals("enabled")) {
            updateBackground((JTextComponent)evt.getSource());
        }
}

This method gets called when a bound property is changed on the associated JTextComponent. This is a hook which UI implementations may change to reflect how the UI displays bound properties of JTextComponent subclasses. This is implemented to do nothing (i.e. the response to properties in JTextComponent itself are handled prior to calling this method). This implementation updates the background of the text component if the editable and/or enabled state changes.

 protected final  void setView(View v) 
{
        rootView.setView(v);
        painted = false;
        editor.revalidate();
        editor.repaint();
}

Sets the current root of the view hierarchy and calls invalidate(). If there were any child components, they will be removed (i.e. there are assumed to have come from components embedded in views).

 protected  void uninstallDefaults() 
{
        editor.removeMouseListener(dragListener);
        editor.removeMouseMotionListener(dragListener);
        if (editor.getCaretColor() instanceof UIResource) {
            editor.setCaretColor(null);
        }
        if (editor.getSelectionColor() instanceof UIResource) {
            editor.setSelectionColor(null);
        }
        if (editor.getDisabledTextColor() instanceof UIResource) {
            editor.setDisabledTextColor(null);
        }
        if (editor.getSelectedTextColor() instanceof UIResource) {
            editor.setSelectedTextColor(null);
        }
        if (editor.getBorder() instanceof UIResource) {
            editor.setBorder(null);
        }
        if (editor.getMargin() instanceof UIResource) {
            editor.setMargin(null);
        }
        if (editor.getCaret() instanceof UIResource) {
            editor.setCaret(null);
        }
        if (editor.getHighlighter() instanceof UIResource) {
            editor.setHighlighter(null);
        }
        if (editor.getTransferHandler() instanceof UIResource) {
            editor.setTransferHandler(null);
        }
        if (editor.getCursor() instanceof UIResource) {
            editor.setCursor(null);
        }
}

Sets the component properties that have not been explicitly overridden to {@code null}. A property is considered overridden if its current value is not a {@code UIResource}.

 protected  void uninstallKeyboardActions() 
{
        editor.setKeymap(null);
        SwingUtilities.replaceUIInputMap(editor, JComponent.
                                         WHEN_IN_FOCUSED_WINDOW, null);
        SwingUtilities.replaceUIActionMap(editor, null);
}

 protected  void uninstallListeners() 
{

}

Uninstalls listeners for the UI.

 public  void uninstallUI(JComponent c) 
{
        // detach from the model
        editor.removePropertyChangeListener(updateHandler);
        editor.getDocument().removeDocumentListener(updateHandler);
        // view part
        painted = false;
        uninstallDefaults();
        rootView.setView(null);
        c.removeAll();
        LayoutManager lm = c.getLayout();
        if (lm instanceof UIResource) {
            c.setLayout(null);
        }
        // controller part
        uninstallKeyboardActions();
        uninstallListeners();
        editor = null;
}

Deinstalls the UI for a component. This removes the listeners, uninstalls the highlighter, removes views, and nulls out the keymap.

 public  void update(Graphics g,
    JComponent c) 
{
        paint(g, c);
}

Superclass paints background in an uncontrollable way (i.e. one might want an image tiled into the background). To prevent this from happening twice, this method is reimplemented to simply paint.

NOTE: NOTE: Superclass is also not thread-safe in its rendering of the background, although that is not an issue with the default rendering.

  void updateFocusAcceleratorBinding(boolean changed) 
{
        char accelerator = editor.getFocusAccelerator();
        if (changed || accelerator != '\0') {
            InputMap km = SwingUtilities.getUIInputMap
                        (editor, JComponent.WHEN_IN_FOCUSED_WINDOW);
            if (km == null && accelerator != '\0') {
                km = new ComponentInputMapUIResource(editor);
                SwingUtilities.replaceUIInputMap(editor, JComponent.
                                                 WHEN_IN_FOCUSED_WINDOW, km);
                ActionMap am = getActionMap();
                SwingUtilities.replaceUIActionMap(editor, am);
            }
            if (km != null) {
                km.clear();
                if (accelerator != '\0') {
                    km.put(KeyStroke.getKeyStroke(accelerator,
                                                  ActionEvent.ALT_MASK),
                           "requestFocus");
                }
            }
        }
}

Invoked when the focus accelerator changes, this will update the key bindings as necessary.

  void updateFocusTraversalKeys() 
{
        /*
         * Fix for 4514331 Non-editable JTextArea and similar
         * should allow Tab to keyboard - accessibility
         */
        EditorKit editorKit = getEditorKit(editor);
        if ( editorKit != null
             && editorKit instanceof DefaultEditorKit) {
            Set< AWTKeyStroke > storedForwardTraversalKeys = editor.
                getFocusTraversalKeys(KeyboardFocusManager.
                                      FORWARD_TRAVERSAL_KEYS);
            Set< AWTKeyStroke > storedBackwardTraversalKeys = editor.
                getFocusTraversalKeys(KeyboardFocusManager.
                                      BACKWARD_TRAVERSAL_KEYS);
            Set< AWTKeyStroke > forwardTraversalKeys =
                new HashSet< AWTKeyStroke >(storedForwardTraversalKeys);
            Set< AWTKeyStroke > backwardTraversalKeys =
                new HashSet< AWTKeyStroke >(storedBackwardTraversalKeys);
            if (editor.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));
            }
            LookAndFeel.installProperty(editor,
                                        "focusTraversalKeysForward",
                                         forwardTraversalKeys);
            LookAndFeel.installProperty(editor,
                                        "focusTraversalKeysBackward",
                                         backwardTraversalKeys);
        }
}

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

 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.

 public int viewToModel(JTextComponent tc,
    Point pt,
    Bias[] biasReturn) 
{
        int offs = -1;
        Document doc = editor.getDocument();
        if (doc instanceof AbstractDocument) {
            ((AbstractDocument)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 {
            if (doc instanceof AbstractDocument) {
                ((AbstractDocument)doc).readUnlock();
            }
        }
        return offs;
}

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.