Document doc = editor.getDocument();	    if (doc instanceof AbstractDocument) {		((AbstractDocument)doc).readLock();	    }	    try {		paintSafely(g);	    } finally {		if (doc instanceof AbstractDocument) {		    ((AbstractDocument)doc).readUnlock();		}	    }	}    }    /**     * 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.     *     * @param c the editor component     * @return the size     */    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 minimum size for the editor component.     *     * @param c the editor component     * @return the size     */    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 maximum size for the editor component.     *     * @param c the editor component     * @return the size     */    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;    }    // ---- TextUI methods -------------------------------------------    /**     * 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.     *     * @return the bounding box for the root view     */    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;    }    /**     * 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.     *     * @param tc the text component for which this UI is installed     * @param pos the local location in the model to translate >= 0     * @return the coordinates as a rectangle, null if the model is not painted     * @exception BadLocationException  if the given position does not     *   represent a valid location in the associated document     * @see TextUI#modelToView     */    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.     *     * @param tc the text component for which this UI is installed     * @param pos the local location in the model to translate >= 0     * @return the coordinates as a rectangle, null if the model is not painted     * @exception BadLocationException  if the given position does not     *   represent a valid location in the associated document     * @see TextUI#modelToView     */    public Rectangle modelToView(JTextComponent tc, int pos, Position.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 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;	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;    }    /**     * Provides a way to determine the next visually represented model      * location that one might place a caret.  Some views may not be visible,     * they might not be in the same order found in the model, or they just     * might not allow access to some of the locations in the model.     *     * @param pos the position to convert >= 0     * @param a the allocated region to render into     * @param direction the direction from the current position that can     *  be thought of as the arrow keys typically found on a keyboard.     *  This may be SwingConstants.WEST, SwingConstants.EAST,      *  SwingConstants.NORTH, or SwingConstants.SOUTH.       * @return the location within the model that best represents the next     *  location visual position.     * @exception BadLocationException     * @exception IllegalArgumentException for an invalid direction     */    public int getNextVisualPositionFrom(JTextComponent t, int pos,		    Position.Bias b, int direction, Position.Bias[] biasRet)	            throws BadLocationException{	Document doc = editor.getDocument();	if (doc instanceof AbstractDocument) {	    ((AbstractDocument)doc).readLock();	}	try {	    if (painted) {		Rectangle alloc = getVisibleEditorRect();		rootView.setSize(alloc.width, alloc.height);		return rootView.getNextVisualPositionFrom(pos, b, alloc, direction,							  biasRet);	    }	} finally {	    if (doc instanceof AbstractDocument) {		((AbstractDocument)doc).readUnlock();	    }	}	return -1;    }    /**     * 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.     *     * @param tc the text component for which this UI is installed     * @param p0 the beginning of the range >= 0     * @param p1 the end of the range >= p0     * @see TextUI#damageRange     */    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.     *     * @param p0 the beginning of the range >= 0     * @param p1 the end of the range >= p0     */    public void damageRange(JTextComponent t, int p0, int p1,			    Position.Bias p0Bias, Position.Bias p1Bias) {        if (painted) {            Rectangle alloc = getVisibleEditorRect();	    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();		}	    }        }    }    /**     * Fetches the EditorKit for the UI.     *     * @param tc the text component for which this UI is installed     * @return the editor capabilities     * @see TextUI#getEditorKit     */    public EditorKit getEditorKit(JTextComponent tc) {        return defaultKit;    }    /**     * 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.     * <p>     * <font color=red><b>NOTE:</b>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!     * </font>     *     * @param tc the text component for which this UI is installed     * @return the view     * @see TextUI#getRootView     */    public View getRootView(JTextComponent tc) {        return rootView;    }    /**     * Returns the string to be used as the tooltip at the passed in location.     * This forwards the method onto the root View.     *     * @see javax.swing.text.JTextComponent#getToolTipText     * @see javax.swing.text.View#getToolTipText     * @since 1.4     */    public String getToolTipText(JTextComponent t, Point pt) {        if (!painted) {            return null;        }        Document doc = editor.getDocument();        String tt = null;        Rectangle alloc = getVisibleEditorRect();        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;    }