import org.openide.awt.HtmlRenderer;

import org.openide.awt.HtmlRenderer;

import org.openide.awt.HtmlRenderer;

import org.openide.awt.HtmlRenderer;

import org.openide.awt.HtmlRenderer;

import org.openide.awt.HtmlRenderer;

import javax.swing.border.Border;

    /** Reference to the focus owner when addNotify was called.  This is the

     * component that received the mouse event, so it's what we need to listen

     * on to update the selected cell as the user drags the mouse */

    private Component invokingComponent = null;

    /** Cached preferred size value */

    private Dimension prefSize = null;

    /** Flag indicating that the fixed row height has not yet been calculated - 

     * this is for fontsize support */

    boolean needCalcRowHeight = true;

        //The table may not really have focus, but it should always use the focus

        //color for the selection, not controlShadow

        ((HtmlRenderer.Renderer) result).setParentFocused(true);

        result.setBorder (rendererBorder);

        ((JComponent)result).setOpaque(true);

        if (!isSelTab) {

            result.setBackground (getSelectionBackground());

        } 

    private static final boolean NAME_HACK = true;

import org.openide.filesystems.FileSystem.HtmlStatus;

     /** Get a display name formatted using the limited HTML subset supported

      * by <code>HtmlRenderer</code>.  If the underlying 

      * <code>FileSystem.Status</code> is an instance of HmlStatus,

      * this method will return non-null if status information is added.

      *

      * @return a string containing compliant HTML markup or null

      * @see org.openide.awt.HtmlRenderer

      * @see org.openide.nodes.Node.getHtmlDisplayName */

     public String getHtmlDisplayName() {

         try {

             FileSystem.Status stat = 

                 obj.getPrimaryFile().getFileSystem().getStatus();

             if (stat instanceof HtmlStatus) {

                 HtmlStatus hstat = (HtmlStatus) stat;

                 String result = hstat.annotateNameHtml (

                     super.getDisplayName(), new LazyFilesSet());

                 //Make sure the super string was really modified

                 if (!super.getDisplayName().equals(result)) {

                     return result;

                 }

             }

         } catch (FileStateInvalidException e) {

             //do nothing and fall through

         }

         return super.getHtmlDisplayName();

     }    

        }

        public String annotateNameHtml(String name, Set files) {

            Set transformedSet = new HashSet();

            MasterFileObject hfo = Utils.transformSet(files, transformedSet);

            if (hfo != null) {

                FileSystem fs = hfo.getDelegateFileSystem();

                if (fs != null && fs.getStatus() instanceof FileSystem.HtmlStatus) {

                    return ((FileSystem.HtmlStatus) fs.getStatus()).annotateNameHtml(name, transformedSet);

                }

            }

            return null;

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.awt;

import org.openide.ErrorManager;

import org.openide.awt.HtmlRenderer;

import javax.swing.*;

import javax.swing.plaf.LabelUI;

import javax.swing.plaf.ComponentUI;

import java.awt.*;

import java.util.Map;

import java.util.HashMap;

/**

 * A LabelUI which uses the lightweight HTML renderer.  Stateless - only one instance should ever exist.

 */

public class HtmlLabelUI extends LabelUI {

    /** System property to automatically turn on antialiasing for html strings */

    private static final boolean antialias = Boolean.getBoolean(

        "nb.cellrenderer.antialiasing"); //NOI18N

    private static HtmlLabelUI uiInstance = null;

    public static ComponentUI createUI (JComponent c) {

        assert c instanceof HtmlRendererImpl;

        if (uiInstance == null) {

            uiInstance = new HtmlLabelUI();

        }

        return uiInstance;

    }

    public Dimension getPreferredSize(JComponent c) {

        return calcPreferredSize ((HtmlRendererImpl) c);

    }

    /** Get the width of the text */

    private static int textWidth(String text, Graphics g, Font f, boolean html) {

        if (text != null) {

            if (html) {

                return Math.round(Math.round(HtmlRenderer.renderHTML(text, g, 0, 0,

                    Integer.MAX_VALUE, Integer.MAX_VALUE, f,

                    Color.BLACK, HtmlRenderer.STYLE_TRUNCATE, false)));

            } else {

                return Math.round(Math.round(HtmlRenderer.renderPlainString(text, g, 0, 0,

                    Integer.MAX_VALUE, Integer.MAX_VALUE, f,

                    Color.BLACK, HtmlRenderer.STYLE_TRUNCATE, false)));

            }

        } else {

            return 0;

        }

    }

    private Dimension calcPreferredSize(HtmlRendererImpl r) {

        Insets ins = r.getInsets();

        Dimension prefSize = new java.awt.Dimension(ins.left + ins.right, ins.top + ins.bottom);

        String text = r.getText();

        Graphics g = r.getGraphics();

        Icon icon = r.getIcon();

        if (text != null) {

            FontMetrics fm = g.getFontMetrics (r.getFont());

                prefSize.height += fm.getMaxAscent() + fm.getMaxDescent();

        }

        if (icon != null) {

            if (r.isCentered()) {

                prefSize.height += icon.getIconHeight() + r.getIconTextGap();

                prefSize.width += icon.getIconWidth();

            } else {

                prefSize.height = Math.max (icon.getIconHeight(), prefSize.height);

                prefSize.width += icon.getIconWidth() + r.getIconTextGap();

            }

        }

        //Antialiasing affects the text metrics, so use it if needed when

        //calculating preferred size or the result here will be narrower

        //than the space actually needed

        if (antialias) {

            //For L&Fs such as Aqua and SmoothMetal, we will need to manually apply

            //rendering hints to get antialiasing, since we're doing our

            //own painting logic - they don't do this for things they don't

            //know about

            ((Graphics2D)g).addRenderingHints(getHints());

        }

        int textwidth = textWidth(text, g, r.getFont(), r.isHtml()) + 2;

        if (r.isCentered()) {

            prefSize.width = Math.max (prefSize.width, textwidth + ins.right + ins.left);

        } else {

            prefSize.width += textwidth + r.getIndent();

        }

        return prefSize;

    }

    private static Map hintsMap = null;

    static final Map getHints() {

        if (hintsMap == null) {

            hintsMap = new HashMap();

            hintsMap.put(RenderingHints.KEY_FRACTIONALMETRICS,

                RenderingHints.VALUE_FRACTIONALMETRICS_ON);

            hintsMap.put(RenderingHints.KEY_TEXT_ANTIALIASING,

                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

            hintsMap.put(RenderingHints.KEY_ANTIALIASING,

                RenderingHints.VALUE_ANTIALIAS_ON);

        }

        return hintsMap;

    }

    public void update(Graphics g, JComponent c) {

        Color bg = getBackgroundFor ((HtmlRendererImpl) c);

        if (bg != null) {

            g.setColor(bg);

            g.fillRect(0, 0, c.getWidth(),c.getHeight());

            if (((HtmlRendererImpl) c).isLeadSelection()) {

                Color focus = UIManager.getColor("textHighlight");

                if (focus == null) {

                    focus = Color.BLUE;

                }

                g.setColor(focus);

                g.drawRect (0, 0, c.getWidth()-1, c.getHeight()-1);

            }

        }

        paint(g, c);

    }

    public void paint(Graphics g, JComponent c) {

        if (antialias) {

            //For L&Fs such as Aqua and SmoothMetal, we will need to manually apply

            //rendering hints to get antialiasing, since we're doing our

            //own painting logic - they don't do this for things they don't

            //know about

            ((Graphics2D)g).addRenderingHints(getHints());

        }

        HtmlRendererImpl r = (HtmlRendererImpl) c;

        if (r.isCentered()) {

            paintIconAndTextCentered (g, r);

        } else {

            paintIconAndText (g, r);

        }

    }

    /** Actually paint the icon and text using our own html rendering engine. */

    private void paintIconAndText(Graphics g, HtmlRendererImpl r) {

        assert SwingUtilities.isEventDispatchThread();

        Font f = r.getFont();

        g.setFont(f);

        FontMetrics fm = g.getFontMetrics();

        //Find out what height we need

        int txtH = fm.getHeight();

        Insets ins = r.getInsets();

        //find out the available height less the insets

        int availH = r.getHeight() - (ins.top + ins.bottom);

        int txtY;

        if (availH >= txtH) {

            //Center the text if we have space

            txtY = txtH + ins.top + ((availH / 2) - (txtH / 2)) - 4;

        } else {

            //Okay, it's not going to fit, punt.

            txtY = 0;//txtH + ins.top - 1;

        }

        int txtX = r.getIndent();

        Icon icon = r.getIcon();

        //Check the icon non-null and height (see TabData.NO_ICON for why)

        if (icon != null && icon.getIconWidth() > 0 && icon.getIconHeight() > 0) {

            int iconY;

            if (availH > icon.getIconHeight()) {

                //add 2 to make sure icon top pixels are not cut off by outline

                iconY = ins.top + ((availH / 2) - (icon.getIconHeight() / 2));// + 2;

            } else if (availH == icon.getIconHeight()){

                //They're an exact match, make it 0

                iconY = 0;

            } else {

                //Won't fit; make the top visible and cut the rest off (option:

                //center it and clip it on top and bottom - probably even harder

                //to recognize that way, though)

                iconY = ins.top;

            }

            //add in the insets

            int iconX = ins.left + r.getIndent();

            try {

                //Diagnostic - the CPP module currently is constructing

                //some ImageIcon from a null image in Options.  So, catch it and at

                //least give a meaningful message that indicates what node

                //is the culprit

                icon.paintIcon(r, g, iconX, iconY);

            } catch (NullPointerException npe) {

                ErrorManager.getDefault().annotate(npe, ErrorManager.EXCEPTION,

                    "Probably an ImageIcon with a null source image: " +

                    r.getText(), null, null, null); //NOI18N

                ErrorManager.getDefault().notify(npe);

            }

            txtX = iconX + icon.getIconWidth() + r.getIconTextGap();

        } else {

            //If there's no icon, paint the text where the icon would start

            txtX += ins.left;

        }

        String text = r.getText();

        if (text == null) {

            //No text, we're done

            return;

        }

        //Get the available horizontal pixels for text

        int txtW = icon != null ? r.getWidth() - (ins.left + ins.right +

            icon.getIconWidth() + r.getIconTextGap() + r.getIndent()) : r.getWidth() -

            (ins.left + ins.right + r.getIndent());

        Color foreground = getForegroundFor (r);

        if (r.isHtml()) {

            HtmlRenderer.renderHTML(text, g, txtX, txtY, txtW, txtH, f,

                foreground, r.getRenderStyle(), true);

        } else {

            HtmlRenderer.renderString(text, g, txtX, txtY, txtW, txtH, f,

                foreground, r.getRenderStyle(), true);

        }

    }

    private void paintIconAndTextCentered (Graphics g, HtmlRendererImpl r) {

        Insets ins = r.getInsets();

        Icon ic = r.getIcon();

        int w = r.getWidth() - (ins.left + ins.right);

        int txtX = ins.left;

        int txtY = 0;

        if (ic != null && ic.getIconWidth() > 0 && ic.getIconHeight() > 0) {

            int iconx = w > ic.getIconWidth() ? (w / 2) - (ic.getIconWidth() / 2) : txtX;

            int icony = 0;

            ic.paintIcon(r, g, iconx, icony);

            txtY += ic.getIconHeight() + r.getIconTextGap();

        }

        int txtW = r.getPreferredSize().width;

        txtX = txtW < r.getWidth() ? (r.getWidth() / 2) - (txtW / 2) : 0;

        int txtH = r.getHeight() - txtY;

        Font f = r.getFont();

        g.setFont(f);

        FontMetrics fm = g.getFontMetrics(f);

        txtY += fm.getMaxAscent();

        Color foreground = getForegroundFor (r);

        if (r.isHtml()) {

            HtmlRenderer.renderHTML(r.getText(), g, txtX, txtY, txtW, txtH,f,

                foreground, r.getRenderStyle(), true);

        } else {

            HtmlRenderer.renderString(r.getText(), g, txtX, txtY, txtW, txtH, r.getFont(),

                foreground, r.getRenderStyle(), true);

        }

    }

    static Color getBackgroundFor (HtmlRendererImpl r) {

        if (r.isOpaque()) {

            return r.getBackground();

        }

        if (r.isSelected() && !r.isParentFocused() && !isGTK()) {

            return getUnfocusedSelectionBackground();

        }

        if (isGTK()) {

            //GTK does its own thing, we'll only screw it up by painting the background ourselves

            return null;

        }

        Color result = null;

        if (r.isSelected()) {

            switch (r.getType()) {

                case HtmlRendererImpl.TYPE_LIST :

                    result = UIManager.getColor ("List.selectionBackground"); //NOI18N

                    break;

                case HtmlRendererImpl.TYPE_TABLE :

                    result = UIManager.getColor ("Table.selectionBackground"); //NOI18N

                    break;

                case HtmlRendererImpl.TYPE_TREE :

                    return UIManager.getColor ("Tree.selectionBackground"); //NOI18N

            }

            return result == null ? r.getBackground() : result;

        }

        return null;

    }

    static Color getForegroundFor (HtmlRendererImpl r) {

        if (r.isSelected() && !r.isParentFocused()) {

            return getUnfocusedSelectionForeground();

        }

        if (!r.isEnabled()) {

            return UIManager.getColor ("textInactiveText"); //NOI18N

        }

        Color result = null;

        if (r.isSelected()) {

            switch (r.getType()) {

                case HtmlRendererImpl.TYPE_LIST :

                    result = UIManager.getColor ("List.selectionForeground"); //NOI18N

                case HtmlRendererImpl.TYPE_TABLE :

                    result = UIManager.getColor ("Table.selectionForeground"); //NOI18N

                case HtmlRendererImpl.TYPE_TREE :

                    result = UIManager.getColor ("Tree.selectionForeground"); //NOI18N

            }

        }

        return result == null ? r.getForeground() : result;

    }

    private static boolean isGTK() {

        return "GTK".equals (UIManager.getLookAndFeel().getID());

    }

    private static Color unfocusedSelBg = null;

    private static Color unfocusedSelFg = null;

    /** Get the system-wide unfocused selection background color */

    private static Color getUnfocusedSelectionBackground() {

        if (unfocusedSelBg == null) {

            //allow theme/ui custom definition

            unfocusedSelBg =

            UIManager.getColor("nb.explorer.unfocusedSelBg"); //NOI18N

            if (unfocusedSelBg == null) {

                //try to get standard shadow color

                unfocusedSelBg = UIManager.getColor("controlShadow"); //NOI18N

                if (unfocusedSelBg == null) {

                    //Okay, the look and feel doesn't suport it, punt

                    unfocusedSelBg = Color.lightGray;

                }

                //Lighten it a bit because disabled text will use controlShadow/

                //gray

                unfocusedSelBg = unfocusedSelBg.brighter();

            }

        }

        return unfocusedSelBg;

    }

    /** Get the system-wide unfocused selection foreground color */

    private static Color getUnfocusedSelectionForeground() {

        if (unfocusedSelFg == null) {

            //allow theme/ui custom definition

            unfocusedSelFg =

            UIManager.getColor("nb.explorer.unfocusedSelFg"); //NOI18N

            if (unfocusedSelFg == null) {

                //try to get standard shadow color

                unfocusedSelFg = UIManager.getColor("textText"); //NOI18N

                if (unfocusedSelFg == null) {

                    //Okay, the look and feel doesn't suport it, punt

                    unfocusedSelFg = Color.BLACK;

                }

            }

        }

        return unfocusedSelFg;

    }

}

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2003 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

/*

 * HtmlRenderer.java

 *

 * Created on January 2, 2004, 12:49 AM

 */

package org.openide.awt;

import org.openide.ErrorManager;

import javax.swing.*;

import javax.swing.table.TableCellRenderer;

import javax.swing.tree.TreeCellRenderer;

import java.awt.*;

import java.awt.font.LineMetrics;

import java.awt.geom.Area;

import java.awt.geom.Rectangle2D;

import java.util.*;

/** A generic cell renderer class which implements

 * a lightweight html renderer supporting a minimal subset of HTML used for

 * markup purposes only - basic font styles, colors, etc.  Also supports

 * named logical colors specified by a preceding ! character for specifying

 * colors that should be looked up in the current look and feel's UIDefaults

 * (e.g. <code>&lt;font color=&amp;!textText&amp&gt;</code>).

 * <p>

 * If you only need to paint some HTML quickly, use the static methods for

 * painting - <code>renderString</code>, <code>renderPlainString</code> or

 * <code>renderHtml</code>.  These methods differ as follows:

 * <ul>

 * <li><b>renderString</b> will check the string for opening HTML tags

 * (upper or lower but not mixed case) and call either <code>renderPlainString</code>

 * or <code>renderHtml</code> as appropriate.  Note this method does not tolerate

 * whitespace in opening html tags - it expects exactly 6 characters to make up

 * the opening tag if present.</li>

 * <li><b>renderPlainString</b> simply renders a string to the graphics context,

 * takes the same agruments as <code>renderHtml</code>, but will also honor

 * <code>STYLE_TRUNCATE</code>, so strings can be rendered with trailing

 * elipsis if there is not enough space</li>

 * <li><b>renderHtml</b> renders whatever is passed to it as HTML, regardless

 * of whether it has opening HTML tags or not.  It can be used to render plain

 * strings, but <code>renderPlainString</code> is faster for that. It is useful

 * if you want to render a string you <strong>know</strong> to be compliant

 * HTML markup, but which does not have opening and closing HTML tags (though

 * they are harmless if present). </li>

 * <p>

 * This parser is designed entirely for performance; there are no separate parsing

 * and rendering loops.  In order to acheive its performance, some trade offs

 * are required.

 * <strong>To reiterate: This is not a forgiving HTML parser - the HTML supplied

 * must follow the guidelines documented here!</strong>

 * <p>

 * The following tags are supported, in upper or lower (but not mixed) case:

 *

 * <table>

 * <tr>

 *  <td>&lt;B&gt;</td>

 *  <td>Boldface text</td>

 * </tr>

 * <tr>

 *  <td>&lt;S&gt;</td>

 *  <td>Strikethrough text</td>

 * </tr>

 * <tr>

 *  <td>&lt;U&gt;</td>

 *  <td>Underline text</td>

 * </tr>

 * <tr>

 *  <td>&lt;I&gt;</td>

 *  <td>Italic text</td>

 * </tr>

 * <tr>

 *  <td>&lt;EM&gt;</td>

 *  <td>Emphasized text (same as italic)</td>

 * </tr>

 * <tr>

 *  <td>&lt;STRONG&gt;</td>

 *  <td>Strong text (same as bold)</td>

 * </tr>

 * <tr>

 *  <td>&lt;font&gt;</td>

 *  <td>Font color - font attributes other than color are not supported.  Colors

 *  may be specified as hexidecimal strings, such as #FF0000 or as logical colors

 *  defined in the current look and feel by specifying a ! character as the first

 *  character of the color name.  Logical colors are colors available from the

 *  current look and feel's UIManager.  For example, <code>&lt;font

 *  color=&quot;!Tree.background&quot;&gt;</code> will set the font color to the

 *  result of <code>UIManager.getColor(&quot;Tree.background&quot;)</code>.

 * <strong>Font size tags are not supported.</strong>

 * </td>

 * </tr>

 * </table>

 * The lightweight html renderer supports the following named sgml character

 * entities: <code>quot, lt, amp, lsquo, rsquo, ldquo, rdquo, ndash, mdash, ne,

 * le, ge, copy, reg, trade.  </code>.  It also supports numeric entities

 * (e.g. <code>&amp;8822;</code>).

 * <p><b>Why not use the JDK's HTML support?</b> The JDK's HTML support works

 * well for stable components, but suffers from performance problems in the

 * case of cell renderers - each call to set the text (which happens once per

 * cell, per paint) causes a document tree to be created in memory.  For small,

 * markup only strings, this is overkill.   For rendering short strings

 * (for example, in a tree or table cell renderer)

 * with limited HTML, this method is approximately 10x faster than standard

 * Swing HTML rendering.

 *

 * <P><B><U>Specifying logical colors</U></B><BR>

 * Hardcoded text colors are undesirable, as they can be incompatible (even

 * invisible) on some look and feels or themes, depending on the background

 * color.

 * The lightweight HTML renderer supports a non-standard syntax for specifying

 * font colors via a key for a color in the UI defaults for the current look

 * and feel.  This is accomplished by prefixing the key name with a <code>!</code>

 * character.  For example: <code>&lt;font color='!controlShadow'&gt;</code>.

 *

 * <P><B><U>Modes of operation</U></B><BR>

 * This method supports two modes of operation:

 * <OL>

 * <LI><CODE>STYLE_CLIP</CODE> - as much text as will fit in the pixel width passed

 * to the method should be painted, and the text should be cut off at the maximum

 * width or clip rectangle maximum X boundary for the graphics object, whichever is

 * smaller.</LI>

 * <LI><CODE>STYLE_TRUNCATE</CODE> - paint as much text as will fit in the pixel

 * width passed to the method, but paint the last three characters as .'s, in the

 * same manner as a JLabel truncates its text when the available space is too

 * small.</LI>

 * </OL>

 * <P>

 * The paint methods can also be used in non-painting mode to establish the space

 * necessary to paint a string.  This is accomplished by passing the value of the

 * <code>paint</code> argument as false.  The return value will be the required

 * width in pixels

 * to display the text.  Note that in order to retrieve an

 * accurate value, the argument for available width should be passed

 * as <code>Integer.MAX_VALUE</code> or an appropriate maximum size - otherwise

 * the return value will either be the passed maximum width or the required

 * width, whichever is smaller.  Also, the clip shape for the passed graphics

 * object should be null or a value larger than the maximum possible render size,

 * or text size measurement will stop at the clip bounds.  <code>HtmlRenderer.getGraphics()</code>

 * will always return non-null and non-clipped, and is suitable to pass in such a

 * situation.

 * <P>

 *

 * @author  Tim Boudreau

 */

public final class HtmlRenderer {

    private static final HtmlRendererImpl INSTANCE = new HtmlRendererImpl();

    private HtmlRenderer() {

    }

    /**

     * Returns an instance of Renderer which may be used as a table/tree/list cell renderer.

     * This method must be called on the AWT event thread.  If you <strong>know</strong> you will

     * be passing it legal HTML (legal as documented here), call <code>setHtml(true)</code> on the

     * result of this call <strong>after calling getNNNCellRenderer</code> to provide this hint.

     *

     * @return A cell renderer that can render HTML.

     */

    public static final Renderer sharedRenderer () {

        assert SwingUtilities.isEventDispatchThread();

        return INSTANCE;

    }

    /**

     * For HTML rendering jobs outside of trees/lists/tables, returns a JLabel which will paint its text using

     * the lightweight HTML renderer.  The result of this call will implement the <code>Renderer</code> interface.

     * <p>

     * Do <strong>not</strong> add the result of this call to the AWT hierarchy - it is designed for offscreen

     * painting, and may be reconfigured to paint something else at any time.

     * <p>

     * This method must be called from the AWT event thread.

     *

     * @return A JLabel

     */

    public static final JLabel sharedLabel () {

        assert SwingUtilities.isEventDispatchThread();

        INSTANCE.reset();

        return INSTANCE;

    }

    /** Interface aggregating TableCellRenderer, TreeCellRenderer and ListCellRenderer.

     * Return type of <code>sharedInstance()</code>.

     */

    public interface Renderer extends TableCellRenderer, TreeCellRenderer, ListCellRenderer {

        /** Indicate that the component being rendered has keyboard focus.  NetBeans requires that a different

         * selection color be used depending on whether the view has focus.

         *

         * @param parentFocused Whether or not the focused selection color should be used

         */

        void setParentFocused (boolean parentFocused);

        /**

         * Indicate that the text should be painted centered below the icon.  This is primarily used

         * by org.openide.explorer.view.IconView

         *

         * @param centered Whether or not centered painting should be used.

         */

        void setCentered (boolean centered);

        /**

         * Set a number of pixels the icon and text should be indented.  Used by ChoiceView and ListView to

         * fake tree-style nesting.  This value has no effect if <code>setCentered(true)</code> has been called.

         *

         * @param pixels The number of pixels to indent

         */

        void setIndent (int pixels);

        /**

         * Explicitly tell the renderer it is going to receive HTML markup, or it is not.  If the renderer should

         * check the string for opening HTML tags to determine this, don't call this method.  If you <strong>know</strong>

         * the string will be compliant HTML, it is preferable to call this method with true; if you want to intentionally

         * render HTML markup literally, call this method with false.

         *

         * @param val

         */

        void setHtml (boolean val);

        /**

         * Set the rendering style - this can be JLabel-style truncated-with-elipsis (...) text, or clipped text.

         * The default is STYLE_CLIP.

         *

         * @param style The text style

         */

        void setRenderStyle (int style);

        /** Set the icon to be used for painting

         *

         * @param icon An icon or null

         */

        void setIcon (Icon icon);

        /** Clear any stale data from previous use by other components,

         * clearing the icon, text, disabled state and other customizations, returning the component

         * to its initialized state.  This is done automatically when get*CellRenderer() is called.

         */

        void reset();

        /** Set the text to be displayed.  Use this if the object being rendered's toString() does not

         * return a real user-displayable string, after calling get**CellRenderer().  Typically after calling

         * this one calls setHtml() if the text is known to either be or not be HTML markup.

         *

         * @param txt The text that should be displayed

         */

        void setText (String txt);

        /**

         * Convenience method to set the gap between the icon and text.

         *

         * @param gap an integer number of pixels

         */

        void setIconTextGap (int gap);

    }

    /** Stack object used during HTML rendering to hold previous colors in

     * the case of nested color entries. */

    private static Stack colorStack = new Stack();

    /** Constant used by <code>renderString</code>, <code>renderPlainString</code>

     * <code>renderHTML</code>, and <code>HtmlRenderer.setRenderStyle</code>

     * if painting should simply be cut off at the boundary of the cooordinates passed.     */

    public static final int STYLE_CLIP=0;

    /** Constant used by <code>renderString</code>, <code>renderPlainString</code>

     * <code>renderHTML</code>  and <code>HtmlRenderer.setRenderStyle</code> if

     * painting should produce an ellipsis (...)

     * if the text would overlap the boundary of the coordinates passed */

    public static final int STYLE_TRUNCATE=1;

    /** Constant used by <code>renderString</code>, <code>renderPlainString</code>

     * <code>renderHTML</code> and <code>HtmlRenderer.setRenderStyle</code>

     * if painting should word wrap the text.  In

     * this case, the return value of any of the above methods will be the

     * height, rather than width painted. */

    private static final int STYLE_WORDWRAP=2;

    /** System property to cause exceptions to be thrown when unparsable

     * html is encountered */

    private static final boolean strictHTML = Boolean.getBoolean(

        "netbeans.lwhtml.strict"); //NOI18N

    /** Cache for strings which have produced errors, so we don't post an

     * error message more than once */

    private static Set badStrings=null;

    /** Definitions for a limited subset of sgml character entities */

    private static final Object[] entities = new Object[] {

        new char[] {'g','t'}, new char[] {'l','t'},

        new char[] {'q','u','o','t'}, new char[] {'a','m','p'},

        new char[] {'l','s','q','u','o'},

        new char[] {'r','s','q','u','o'},

        new char[] {'l','d','q','u','o'},

        new char[] {'r','d','q','u','o'},

        new char[] {'n','d','a','s','h'},

        new char[] {'m','d','a','s','h'},

        new char[] {'n','e'},

        new char[] {'l','e'},

        new char[] {'g','e'},

        new char[] {'c','o','p','y'},

        new char[] {'r','e','g'},

        new char[] {'t','r','a','d','e'}

        //The rest of the SGML entities are left as an excercise for the reader

    }; //NOI18N

    /** Mappings for the array of sgml character entities to characters */

    private static final char[] entitySubstitutions = new char[] {

        '>','<','"','&',8216, 8217, 8220, 8221, 8211, 8212, 8800, 8804, 8805,

        169, 174, 8482

    };

    /**Render a string to a graphics instance, using the same API as renderHTML().

     * Can render a string using JLabel-style ellipsis (...) in the case that

     * it will not fit in the passed rectangle, if the style parameter is

     * STYLE_CLIP. Returns the width in pixels successfully painted.

     * <strong>This method is not thread-safe and should not be called off

     * the AWT thread.</strong>

     *

     * @see #renderHTML */

    public static double renderPlainString(String s, Graphics g, int x, int y, int w, int h, Font f, Color defaultColor, int style, boolean paint) {

        assert SwingUtilities.isEventDispatchThread();

        //per Jarda's request, keep the word wrapping code but don't expose it.

        if (style < 0 || style > 1) {

            throw new IllegalArgumentException(

            "Unknown rendering mode: " + style); //NOI18N

        }

        return _renderPlainString(s, g, x, y, w, h, f, defaultColor, style,

        paint);

    }

    private static double _renderPlainString(String s, Graphics g, int x, int y, int w, int h, Font f, Color foreground, int style, boolean paint) {

        g.setColor(foreground);

        g.setFont(f);

        FontMetrics fm = g.getFontMetrics(f);

        Rectangle2D r = fm.getStringBounds(s, g);

        if ((r.getWidth() <= w) || (style == STYLE_CLIP)) {

            if (paint) {

                g.drawString(s, x, y);

            }

        } else {

            char[] chars = new char[s.length()];

            s.getChars(0, s.length()-1, chars, 0);

            if (chars.length == 0) {

                return 0;

            }

            double chWidth = r.getWidth() / chars.length;

            int estCharsOver = new Double((r.getWidth() - w) / chWidth).intValue();

            if (style == STYLE_TRUNCATE) {

                int length = chars.length - estCharsOver;

                if (length <=0) {

                    return 0;

                }

                if (paint) {

                    if (length > 3) {

                        Arrays.fill(chars, length-3, length, '.');

                        g.drawChars(chars, 0, length, x, y);

                    } else {

                        Shape shape = g.getClip();

                        if (s != null) {

                            Area area = new Area(shape);

                            area.intersect (new Area(new Rectangle(x,y,w,h)));

                            g.setClip(area);

                        } else {

                            g.setClip(new Rectangle(x,y,w,h));

                        }

                        g.drawString("...", x,y);

                        g.setClip(shape);

                    }

                }

            } else {

                //TODO implement plaintext word wrap if we want to support it at some point

            }

        }

        return r.getWidth();

    }

    /** Render a string to a graphics context, using HTML markup if the string

     * begins with html tags.  Delegates to <code>renderPlainString()</code>

     * or <code>renderHTML()</code> as appropriate.  See the documentation for

     * <code>renderHTML()</code> for details of the subset of HTML that is

     * supported.

     * <P><strong>This method is not thread-safe and should not be called off

     * the AWT thread.</strong>

     * @param s The string to render

     * @param g A graphics object into which the string should be drawn, or which should be

     * used for calculating the appropriate size

     * @param x The x coordinate to paint at.

     * @param y The y position at which to paint.  Note that this method does not calculate font

     * height/descent - this value should be the baseline for the line of text, not

     * the upper corner of the rectangle to paint in.

     * @param w The maximum width within which to paint.

     * @param h The maximum height within which to paint.

     * @param f The base font to be used for painting or calculating string width/height.

     * @param defaultColor The base color to use if no font color is specified as html tags

     * @param style The wrapping style to use, either <code>STYLE_CLIP</CODE>,

     * or <CODE>STYLE_TRUNCATE</CODE>

     * @param paint True if actual painting should occur.  If false, this method will not actually

     * paint anything, only return a value representing the width/height needed to

     * paint the passed string.

     * @return The width in pixels required

     * to paint the complete string, or the passed parameter <code>w</code> if it is

     * smaller than the required width.

     */

    public static double renderString(String s, Graphics g, int x, int y, int w, int h, Font f, Color defaultColor, int style, boolean paint) {

        if (s.startsWith("<html") || s.startsWith("<HTML")) { //NOI18N

            if (style < 0 || style > 1) {

                throw new IllegalArgumentException(

                "Unknown rendering mode: " + style); //NOI18N

            }

            return _renderHTML(6, s, g, x, y, w, h, f, defaultColor, style, paint);

        } else {

            return renderPlainString(s, g, x, y, w, h, f, defaultColor, style, paint);

        }

    }

    /** Render a string as HTML using a fast, lightweight renderer supporting a limited

     * subset of HTML.  The following tags are supported, in upper or lower case:

     *

     * <table>

     * <tr>

     *  <td>&lt;B&gt;</td>

     *  <td>Boldface text</td>

     * </tr>

     * <tr>

     *  <td>&lt;S&gt;</td>

     *  <td>Strikethrough text</td>

     * </tr>

     * <tr>

     *  <td>&lt;U&gt;</td>

     *  <td>Underline text</td>

     * </tr>

     * <tr>

     *  <td>&lt;I&gt;</td>

     *  <td>Italic text</td>

     * </tr>

     * <tr>

     *  <td>&lt;EM&gt;</td>

     *  <td>Emphasized text (same as italic)</td>

     * </tr>

     * <tr>

     *  <td>&lt;STRONG&gt;</td>

     *  <td>Strong text (same as bold)</td>

     * </tr>

     * <tr>

     *  <td>&lt;font&gt;</td>

     *  <td>Font color - font attributes other than color are not supported.  Colors

     *  may be specified as hexidecimal strings, such as #FF0000 or as logical colors

     *  defined in the current look and feel by specifying a ! character as the first

     *  character of the color name.  Logical colors are colors available from the

     *  current look and feel's UIManager.  For example, <code>&lt;font

     *  color=&quot;!Tree.background&quot;&gt;</code> will set the font color to the

     *  result of <code>UIManager.getColor(&quot;Tree.background&quot)</code>.

     * <strong>Font size tags are not supported.</strong>

     * </td>

     * </tr>

     * </table>

     * The lightweight html renderer supports the following named sgml character

     * entities: <code>quot, lt, amp, lsquo, rsquo, ldquo, rdquo, ndash, mdash, ne,

     * le, ge, copy, reg, trade.  </code>.  It also supports numeric entities

     * (e.g. <code>&amp;8822;</code>).

     * <p><b>When to use this method instead of the JDK's HTML support: </b> when

     * rendering short strings (for example, in a tree or table cell renderer)

     * with limited HTML, this method is approximately 10x faster than JDK HTML

     * rendering (it does not build and parse a document tree).

     *

     * <P><B><U>Specifying logical colors</U></B><BR>

     * Hardcoded text colors are undesirable, as they can be incompatible (even

     * invisible) on some look and feels or themes.

     * The lightweight HTML renderer supports a non-standard syntax for specifying

     * font colors via a key for a color in the UI defaults for the current look

     * and feel.  This is accomplished by prefixing the key name with a <code>!</code>

     * character.  For example: <code>&lt;font color='!controlShadow'&gt;</code>.

     *

     * <P><B><U>Modes of operation</U></B><BR>

     * This method supports two modes of operation:

     * <OL>

     * <LI><CODE>STYLE_CLIP</CODE> - as much text as will fit in the pixel width passed

     * to the method should be painted, and the text should be cut off at the maximum

     * width or clip rectangle maximum X boundary for the graphics object, whichever is

     * smaller.</LI>

     * <LI><CODE>STYLE_TRUNCATE</CODE> - paint as much text as will fit in the pixel

     * width passed to the method, but paint the last three characters as .'s, in the

     * same manner as a JLabel truncates its text when the available space is too

     * small.</LI>

     * </OL>

     * <P>

     * This method can also be used in non-painting mode to establish the space

     * necessary to paint a string.  This is accomplished by passing the value of the

     * <code>paint</code> argument as false.  The return value will be the required

     * width in pixels

     * to display the text.  Note that in order to retrieve an

     * accurate value, the argument for available width should be passed

     * as <code>Integer.MAX_VALUE</code> or an appropriate maximum size - otherwise

     * the return value will either be the passed maximum width or the required

     * width, whichever is smaller.  Also, the clip shape for the passed graphics

     * object should be null or a value larger than the maximum possible render size.

     * <P>

     * This method will log a warning if it encounters HTML markup it cannot

     * render.  To aid diagnostics, if NetBeans is run with the argument

     * <code>-J-Dnetbeans.lwhtml.strict=true</code> an exception will be thrown

     * when an attempt is made to render unsupported HTML.</code><p>

     * <strong>This method is not thread-safe and should not be called off

     * the AWT thread!</strong>

     * <p>

     * @param s The string to render

     * @param g A graphics object into which the string should be drawn, or which should be

     * used for calculating the appropriate size

     * @param x The x coordinate to paint at.

     * @param y The y position at which to paint.  Note that this method does not calculate font

     * height/descent - this value should be the baseline for the line of text, not

     * the upper corner of the rectangle to paint in.

     * @param w The maximum width within which to paint.

     * @param h The maximum height within which to paint.

     * @param f The base font to be used for painting or calculating string width/height.

     * @param defaultColor The base color to use if no font color is specified as html tags

     * @param style The wrapping style to use, either <code>STYLE_CLIP</CODE>,

     * or <CODE>STYLE_TRUNCATE</CODE>

     * @param paint True if actual painting should occur.  If false, this method will not actually

     * paint anything, only return a value representing the width/height needed to

     * paint the passed string.

     * @return The width in pixels required

     * to paint the complete string, or the passed parameter <code>w</code> if it is

     * smaller than the required width.

     */

    public static double renderHTML(String s, Graphics g, int x, int y,

        int w, int h, Font f,

        Color defaultColor, int style,

        boolean paint) {

        assert SwingUtilities.isEventDispatchThread();

        //per Jarda's request, keep the word wrapping code but don't expose it.

        if (style < 0 || style > 1) {

            throw new IllegalArgumentException(

            "Unknown rendering mode: " + style); //NOI18N

        }

        return _renderHTML(0, s, g, x, y, w, h, f, defaultColor, style,

            paint);

    }

    /** Implementation of HTML rendering */

    private static double _renderHTML(int pos, String s, Graphics g, int x,

        int y, int w, int h, Font f, Color defaultColor, int style,

        boolean paint) {

        g.setColor(defaultColor);

        g.setFont(f);

        char[] chars = s.toCharArray();

        int origX = x;

        boolean done = false;  //flag if rendering completed, either by finishing the string or running out of space

        boolean inTag = false; //flag if the current position is inside a tag, and the tag should be processed rather than rendering

        boolean inClosingTag = false; //flag if the current position is inside a closing tag

        boolean strikethrough = false; //flag if a strikethrough line should be painted

        boolean underline = false; //flag if an underline should be painted

        boolean bold = false; //flag if text is currently bold

        boolean italic = false; //flag if text is currently italic

        boolean truncated = false; //flag if the last possible character has been painted, and the next loop should paint "..." and return

        double widthPainted = 0; //the total width painted, for calculating needed space

        double heightPainted = 0; //the total height painted, for calculating needed space

        boolean lastWasWhitespace = false; //flag to skip additional whitespace if one whitespace char already painted

        double lastHeight=0; //the last line height, for calculating total required height

        double dotWidth = 0;

        //Calculate the width of a . character if we may need to truncate

        if (style == STYLE_TRUNCATE) {

            dotWidth = g.getFontMetrics().charWidth('.'); //NOI18N

        }

        /* How this all works, for anyone maintaining this code (hopefully it will

          never need it):

          1. The string is converted to a char array

          2. Loop over the characters.  Variable pos is the current point.

            2a. See if we're in a tag by or'ing inTag with currChar == '<'

              If WE ARE IN A TAG:

               2a1: is it an opening tag?

                 If YES:

                   - Identify the tag, Configure the Graphics object with

                     the appropriate font, color, etc.  Set pos = the first

                     character after the tag

                 If NO (it's a closing tag)

                   - Identify the tag.  Reconfigure the Graphics object

                     with the state it should be in outside the tag

                     (reset the font if italic, pop a color off the stack, etc.)

            2b. If WE ARE NOT IN A TAG

               - Locate the next < or & character or the end of the string

               - Paint the characters using the Graphics object

               - Check underline and strikethrough tags, and paint line if

                 needed

            See if we're out of space, and do the right thing for the style

            (paint ..., give up or skip to the next line)

         */

        //Clear any junk left behind from a previous rendering loop

        colorStack.clear();

        //Enter the painting loop

        while (!done) {

            if (pos == s.length()) {

                return widthPainted;

            }

            //see if we're in a tag

            try {

                inTag |= chars[pos] == '<';

            } catch (ArrayIndexOutOfBoundsException e) {

                //Should there be any problem, give a meaningful enough

                //message to reproduce the problem

                ArrayIndexOutOfBoundsException aib =

                new ArrayIndexOutOfBoundsException(

                "HTML rendering failed at position " + pos + " in String \""

                + s + "\".  Please report this at http://www.netbeans.org"); //NOI18N

                throw aib;

            }

            inClosingTag = inTag && (pos+1 < chars.length) && chars[pos+1]

             == '/'; //NOI18N

            if (truncated) {

                //Then we've almost run out of space, time to print ... and quit

                g.setColor(defaultColor);

                g.setFont(f);

                if (paint) {

                    g.drawString("...", x, y); //NOI18N

                }

                done = true;

            } else if (inTag) {

                //If we're in a tag, don't paint, process it

                pos++;

                int tagEnd = pos;

                while (!done && (chars[tagEnd] != '>')) {

                    done = tagEnd == chars.length -1;

                    tagEnd++;

                }

                if (inClosingTag) {

                    //Handle closing tags by resetting the Graphics object (font, etc.)

                    pos++;

                    switch (chars[pos]) {

                        case 'P' :

                        case 'p' :

                        case 'H' :

                        case 'h' : break; //ignore html opening/closing tags

                        case 'B' :

                        case 'b' :

                            if (chars[pos+1] == 'r' || chars[pos+1] == 'R') {

                                break;

                            }

                            if (!bold) {

                                throwBadHTML("Closing bold tag w/o " + //NOI18N

                                "opening bold tag", pos, chars); //NOI18N

                            }

                            if (italic) {

                                g.setFont(f.deriveFont(Font.ITALIC));

                            } else {

                                g.setFont(f.deriveFont(Font.PLAIN));

                            }

                            bold = false;

                            break;

                        case 'E' :

                        case 'e' : //em tag

                        case 'I' :

                        case 'i' :

                            if (bold) {

                                g.setFont(f.deriveFont(Font.BOLD));

                            } else {

                                g.setFont(f.deriveFont(Font.PLAIN));

                            }

                            if (!italic) {

                                throwBadHTML("Closing italics tag w/o" //NOI18N

                                + "opening italics tag", pos, chars); //NOI18N

                            }

                            italic = false;

                            break;

                        case 'S' :

                        case 's' :

                            switch (chars[pos+1]) {

                                case 'T' :

                                case 't' : if (italic) {

                                    g.setFont(f.deriveFont(

                                    Font.ITALIC));

                                } else {

                                    g.setFont(f.deriveFont(

                                    Font.PLAIN));

                                }

                                bold = false;

                                break;

                                case '>' :

                                    strikethrough = false;

                                    break;

                            }

                            break;

                        case 'U' :

                        case 'u' : underline = false;

                        break;

                        case 'F' :

                        case 'f' :