package cnp.ew.list;

import java.awt.*;
import cnp.ew.displayer.*;
import cnp.ew.image.*;
import cnp.ew.util.*;
import cnp.ew.lightweight.*;

class CpTreeDisplayer implements CpModelSelectableDisplayable, CpFocusDisplayable
{
	static final int INDENT_SPACING = 19;

	// USE KEN's new Image Requester...
	public static Image plusIcon, minusIcon;

    boolean isSelected;
    boolean showFocus;
    CpModelSelectableDisplayable wrappedDisplayer;
    Object model;

    int indentLevel;
    boolean expanded;
    boolean hasChildren;
    boolean lastAtIndentLevel;
    public boolean firstItem = false;

    static int plusIconId;
    static int minusIconId;

    static {
        plusIconId = CpToolkit.registerImageName("plus.gif");
        minusIconId = CpToolkit.registerImageName("minus.gif");
    }

    public CpTreeDisplayer()
    {
        super();
    }

    public CpTreeDisplayer(CpModelSelectableDisplayable newWrappedDisplayer)
    {
        wrappedDisplayer = newWrappedDisplayer;
    }

    public boolean getIsSelected()
    {
        return isSelected;
    }

    public void setIsSelected(boolean newIsSelected)
    {
        isSelected = newIsSelected;
    }

    public boolean getShowFocus()
    {
        return showFocus;
    }

    public void setShowFocus(boolean showFocus)
    {
        this.showFocus = showFocus;
    }

    public Object getModel()
    {
        return model;
    }

    public void setModel(Object newModel)
    {
        model = newModel;
    }

    public void setParameters(CpModelSelectableDisplayable defaultDisplayer, int newIndentLevel,
        boolean newExpanded, boolean newHasChildren, boolean newLastAtIndentLevel)
    {
        if (wrappedDisplayer == null) {
            wrappedDisplayer = defaultDisplayer;
        }
        indentLevel = newIndentLevel;
        expanded = newExpanded;
        hasChildren = newHasChildren;
        lastAtIndentLevel = newLastAtIndentLevel;

    }

    public Dimension preferredSize(CpLightweightComponent c)
    {
        // What should THIS be?
        return new Dimension(100, 20);
    }

    public void paintIn(CpLightweightComponent c, Graphics g, Rectangle rect)
    {
        paintIn(c, g, rect.x, rect.y, rect.width, rect.height);
    }

    public void paintIn(CpLightweightComponent c, Graphics g, int x, int y, int w, int h)
	{
		int	startX;

        // TBD Dont' just fill in white! How is Ken handling this?
		g.setColor(Color.white);
		g.fillRect(x, y, w, h);

		startX = (indentLevel * INDENT_SPACING);

		// Should be vertically centering the plus/minus icons.  Right now, it's 16 pixels and that's assumed.  yuck.
		if (hasChildren) {
			if (expanded) {
				g.drawImage(CpToolkit.getImage(minusIconId), startX, y, CpToolkit.defaultComponent());
			} else {
				g.drawImage(CpToolkit.getImage(plusIconId), startX, y, CpToolkit.defaultComponent());
			}
		}

		startX += INDENT_SPACING;
		wrappedDisplayer.setModel(model);
		wrappedDisplayer.setIsSelected(getIsSelected());

		if (wrappedDisplayer instanceof CpFocusDisplayable) {
		    ((CpFocusDisplayable)wrappedDisplayer).setShowFocus(showFocus);
		}

		wrappedDisplayer.paintIn(c, g, startX, y, w - (startX - x), h);

        // Draw lines
        g.setColor(Color.lightGray);  // Should not be hard coded.  Any way to get dotted lines?
        for (int lev = 0; lev <= indentLevel; lev++) {
            int lineX = x + lev * INDENT_SPACING + 8;   // 8 is half of the plus/minus icon.  Should be put in static vars

            // Again, dust all these magic numbers...
            if (lev < indentLevel) {
                g.drawLine(lineX, y, lineX, y + h - 1);
            } else {
                if (hasChildren) {
                    if (!firstItem) {
                        g.drawLine(lineX, y, lineX, y + 3);
                    }
                    if (!lastAtIndentLevel) {
                        g.drawLine(lineX, y + h - 3, lineX, y + h - 1);
                    }
                    g.drawLine(lineX + 5, y + 8, lineX + 10, y + 8);
                } else {
                    if (lastAtIndentLevel) {
                        g.drawLine(lineX, y, lineX, y + 8);
                    } else {
                        g.drawLine(lineX, y, lineX, y + h - 1);
                    }
                    g.drawLine(lineX, y + 8, lineX + 11, y + 8);
                }
            }
        }
	}
}