/*

 * Copyright 2002-2007 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package javax.swing.plaf.synth;

import java.awt.Color;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Point;

import java.awt.Rectangle;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.text.DateFormat;

import java.text.Format;

import java.text.NumberFormat;

import java.util.Date;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JCheckBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JTable;

import javax.swing.LookAndFeel;

import javax.swing.border.Border;

import javax.swing.plaf.ComponentUI;

import javax.swing.plaf.UIResource;

import javax.swing.plaf.basic.BasicTableUI;

import javax.swing.table.DefaultTableCellRenderer;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumn;

import javax.swing.table.TableColumnModel;

import sun.swing.plaf.synth.SynthUI;

/**

 * SynthTableUI implementation

 *

 * @author Philip Milne

 */

class SynthTableUI extends BasicTableUI implements SynthUI,

        PropertyChangeListener {

//

// Instance Variables

//

    private SynthStyle style;

    private boolean useTableColors;

    private boolean useUIBorder;

    private Color alternateColor; //the background color to use for cells for alternate cells

    // TableCellRenderer installed on the JTable at the time we're installed,

    // cached so that we can reinstall them at uninstallUI time.

    private TableCellRenderer dateRenderer;

    private TableCellRenderer numberRenderer;

    private TableCellRenderer doubleRender;

    private TableCellRenderer floatRenderer;

    private TableCellRenderer iconRenderer;

    private TableCellRenderer imageIconRenderer;

    private TableCellRenderer booleanRenderer;

    private TableCellRenderer objectRenderer;

//

//  The installation/uninstall procedures and support

//

    public static ComponentUI createUI(JComponent c) {

        return new SynthTableUI();

    }

    /**

     * Initialize JTable properties, e.g. font, foreground, and background.

     * 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.

     *

     * @see #installUI

     */

    protected void installDefaults() {

        dateRenderer = installRendererIfPossible(Date.class, null);

        numberRenderer = installRendererIfPossible(Number.class, null);

        doubleRender = installRendererIfPossible(Double.class, null);

        floatRenderer = installRendererIfPossible(Float.class, null);

        iconRenderer = installRendererIfPossible(Icon.class, null);

        imageIconRenderer = installRendererIfPossible(ImageIcon.class, null);

        booleanRenderer = installRendererIfPossible(Boolean.class,

                                 new SynthBooleanTableCellRenderer());

        objectRenderer = installRendererIfPossible(Object.class,

                                        new SynthTableCellRenderer());

        updateStyle(table);

    }

    private TableCellRenderer installRendererIfPossible(Class objectClass,

                                     TableCellRenderer renderer) {

        TableCellRenderer currentRenderer = table.getDefaultRenderer(

                                 objectClass);

        if (currentRenderer instanceof UIResource) {

            table.setDefaultRenderer(objectClass, renderer);

        }

        return currentRenderer;

    }

    private void updateStyle(JTable c) {

        SynthContext context = getContext(c, ENABLED);

        SynthStyle oldStyle = style;

        style = SynthLookAndFeel.updateStyle(context, this);

        if (style != oldStyle) {

            context.setComponentState(ENABLED | SELECTED);

            Color sbg = table.getSelectionBackground();

            if (sbg == null || sbg instanceof UIResource) {

                table.setSelectionBackground(style.getColor(

                                        context, ColorType.TEXT_BACKGROUND));

            }

            Color sfg = table.getSelectionForeground();

            if (sfg == null || sfg instanceof UIResource) {

                table.setSelectionForeground(style.getColor(

                                  context, ColorType.TEXT_FOREGROUND));

            }

            context.setComponentState(ENABLED);

            Color gridColor = table.getGridColor();

            if (gridColor == null || gridColor instanceof UIResource) {

                gridColor = (Color)style.get(context, "Table.gridColor");

                if (gridColor == null) {

                    gridColor = style.getColor(context, ColorType.FOREGROUND);

                }

                table.setGridColor(gridColor);

            }

            useTableColors = style.getBoolean(context,

                                  "Table.rendererUseTableColors", true);

            useUIBorder = style.getBoolean(context,

                                  "Table.rendererUseUIBorder", true);

            Object rowHeight = style.get(context, "Table.rowHeight");

            if (rowHeight != null) {

                LookAndFeel.installProperty(table, "rowHeight", rowHeight);

            }

            boolean showGrid = style.getBoolean(context, "Table.showGrid", true);

            if (!showGrid) {

                table.setShowGrid(false);

            }

            Dimension d = table.getIntercellSpacing();

//            if (d == null || d instanceof UIResource) {

            if (d != null) {

                d = (Dimension)style.get(context, "Table.intercellSpacing");

            }

            alternateColor = (Color)style.get(context, "Table.alternateRowColor");

            if (d != null) {

                table.setIntercellSpacing(d);

            }

            if (oldStyle != null) {

                uninstallKeyboardActions();

                installKeyboardActions();

            }

        }

        context.dispose();

    }

    /**

     * Attaches listeners to the JTable.

     */

    protected void installListeners() {

        super.installListeners();

        table.addPropertyChangeListener(this);

    }

    protected void uninstallDefaults() {

        table.setDefaultRenderer(Date.class, dateRenderer);

        table.setDefaultRenderer(Number.class, numberRenderer);

        table.setDefaultRenderer(Double.class, doubleRender);

        table.setDefaultRenderer(Float.class, floatRenderer);

        table.setDefaultRenderer(Icon.class, iconRenderer);

        table.setDefaultRenderer(ImageIcon.class, imageIconRenderer);

        table.setDefaultRenderer(Boolean.class, booleanRenderer);

        table.setDefaultRenderer(Object.class, objectRenderer);

        if (table.getTransferHandler() instanceof UIResource) {

            table.setTransferHandler(null);

        }

        SynthContext context = getContext(table, ENABLED);

        style.uninstallDefaults(context);

        context.dispose();

        style = null;

    }

    protected void uninstallListeners() {

        table.removePropertyChangeListener(this);

        super.uninstallListeners();

    }

    //

    // SynthUI

    //

    public SynthContext getContext(JComponent c) {

        return getContext(c, getComponentState(c));

    }

    private SynthContext getContext(JComponent c, int state) {

        return SynthContext.getContext(SynthContext.class, c,

                    SynthLookAndFeel.getRegion(c), style, state);

    }

    private Region getRegion(JComponent c) {

        return SynthLookAndFeel.getRegion(c);

    }

    private int getComponentState(JComponent c) {

        return SynthLookAndFeel.getComponentState(c);

    }

//

//  Paint methods and support

//

    public void update(Graphics g, JComponent c) {

        SynthContext context = getContext(c);

        SynthLookAndFeel.update(context, g);

        context.getPainter().paintTableBackground(context,

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

        paint(context, g);

        context.dispose();

    }

    public void paintBorder(SynthContext context, Graphics g, int x,

                            int y, int w, int h) {

        context.getPainter().paintTableBorder(context, g, x, y, w, h);

    }

    public void paint(Graphics g, JComponent c) {

        SynthContext context = getContext(c);

        paint(context, g);

        context.dispose();

    }

    protected void paint(SynthContext context, Graphics g) {

        Rectangle clip = g.getClipBounds();

        Rectangle bounds = table.getBounds();

        // account for the fact that the graphics has already been translated

        // into the table's bounds

        bounds.x = bounds.y = 0;

        if (table.getRowCount() <= 0 || table.getColumnCount() <= 0 ||

                // this check prevents us from painting the entire table

                // when the clip doesn't intersect our bounds at all

                !bounds.intersects(clip)) {

            paintDropLines(context, g);

            return;

        }

        boolean ltr = table.getComponentOrientation().isLeftToRight();

        Point upperLeft = clip.getLocation();

        Point lowerRight = new Point(clip.x + clip.width - 1,

                                     clip.y + clip.height - 1);

        int rMin = table.rowAtPoint(upperLeft);

        int rMax = table.rowAtPoint(lowerRight);

        // This should never happen (as long as our bounds intersect the clip,

        // which is why we bail above if that is the case).

        if (rMin == -1) {

            rMin = 0;

        }

        // If the table does not have enough rows to fill the view we'll get -1.

        // (We could also get -1 if our bounds don't intersect the clip,

        // which is why we bail above if that is the case).

        // Replace this with the index of the last row.

        if (rMax == -1) {

            rMax = table.getRowCount()-1;

        }

        int cMin = table.columnAtPoint(ltr ? upperLeft : lowerRight);

        int cMax = table.columnAtPoint(ltr ? lowerRight : upperLeft);

        // This should never happen.

        if (cMin == -1) {

            cMin = 0;

        }

        // If the table does not have enough columns to fill the view we'll get -1.

        // Replace this with the index of the last column.

        if (cMax == -1) {

            cMax = table.getColumnCount()-1;

        }

        // Paint the grid.

        paintGrid(context, g, rMin, rMax, cMin, cMax);

        // Paint the cells.

        paintCells(context, g, rMin, rMax, cMin, cMax);

        paintDropLines(context, g);

    }

    private void paintDropLines(SynthContext context, Graphics g) {

        JTable.DropLocation loc = table.getDropLocation();

        if (loc == null) {

            return;

        }

        Color color = (Color)style.get(context, "Table.dropLineColor");

        Color shortColor = (Color)style.get(context, "Table.dropLineShortColor");

        if (color == null && shortColor == null) {

            return;

        }

        Rectangle rect;

        rect = getHDropLineRect(loc);

        if (rect != null) {

            int x = rect.x;

            int w = rect.width;

            if (color != null) {

                extendRect(rect, true);

                g.setColor(color);

                g.fillRect(rect.x, rect.y, rect.width, rect.height);

            }

            if (!loc.isInsertColumn() && shortColor != null) {

                g.setColor(shortColor);

                g.fillRect(x, rect.y, w, rect.height);

            }

        }

        rect = getVDropLineRect(loc);

        if (rect != null) {

            int y = rect.y;

            int h = rect.height;

            if (color != null) {

                extendRect(rect, false);

                g.setColor(color);

                g.fillRect(rect.x, rect.y, rect.width, rect.height);

            }

            if (!loc.isInsertRow() && shortColor != null) {

                g.setColor(shortColor);

                g.fillRect(rect.x, y, rect.width, h);

            }

        }

    }

    private Rectangle getHDropLineRect(JTable.DropLocation loc) {

        if (!loc.isInsertRow()) {

            return null;

        }

        int row = loc.getRow();

        int col = loc.getColumn();

        if (col >= table.getColumnCount()) {

            col--;

        }

        Rectangle rect = table.getCellRect(row, col, true);

        if (row >= table.getRowCount()) {

            row--;

            Rectangle prevRect = table.getCellRect(row, col, true);

            rect.y = prevRect.y + prevRect.height;

        }

        if (rect.y == 0) {

            rect.y = -1;

        } else {

            rect.y -= 2;

        }

        rect.height = 3;

        return rect;

    }

    private Rectangle getVDropLineRect(JTable.DropLocation loc) {

        if (!loc.isInsertColumn()) {

            return null;

        }

        boolean ltr = table.getComponentOrientation().isLeftToRight();

        int col = loc.getColumn();

        Rectangle rect = table.getCellRect(loc.getRow(), col, true);

        if (col >= table.getColumnCount()) {

            col--;

            rect = table.getCellRect(loc.getRow(), col, true);

            if (ltr) {

                rect.x = rect.x + rect.width;

            }

        } else if (!ltr) {

            rect.x = rect.x + rect.width;

        }

        if (rect.x == 0) {

            rect.x = -1;

        } else {

            rect.x -= 2;

        }

        rect.width = 3;

        return rect;

    }

    private Rectangle extendRect(Rectangle rect, boolean horizontal) {

        if (rect == null) {

            return rect;

        }

        if (horizontal) {

            rect.x = 0;

            rect.width = table.getWidth();

        } else {

            rect.y = 0;

            if (table.getRowCount() != 0) {

                Rectangle lastRect = table.getCellRect(table.getRowCount() - 1, 0, true);

                rect.height = lastRect.y + lastRect.height;

            } else {

                rect.height = table.getHeight();

            }

        }

        return rect;

    }

    /*

     * Paints the grid lines within <I>aRect</I>, using the grid

     * color set with <I>setGridColor</I>. Paints vertical lines

     * if <code>getShowVerticalLines()</code> returns true and paints

     * horizontal lines if <code>getShowHorizontalLines()</code>

     * returns true.

     */

    private void paintGrid(SynthContext context, Graphics g, int rMin,

                           int rMax, int cMin, int cMax) {

        g.setColor(table.getGridColor());

        Rectangle minCell = table.getCellRect(rMin, cMin, true);

        Rectangle maxCell = table.getCellRect(rMax, cMax, true);

        Rectangle damagedArea = minCell.union( maxCell );

        SynthGraphicsUtils synthG = context.getStyle().getGraphicsUtils(

                     context);

        if (table.getShowHorizontalLines()) {

            int tableWidth = damagedArea.x + damagedArea.width;

            int y = damagedArea.y;

            for (int row = rMin; row <= rMax; row++) {

                y += table.getRowHeight(row);

                synthG.drawLine(context, "Table.grid",

                                g, damagedArea.x, y - 1, tableWidth - 1,y - 1);

            }

        }

        if (table.getShowVerticalLines()) {

            TableColumnModel cm = table.getColumnModel();

            int tableHeight = damagedArea.y + damagedArea.height;

            int x;

            if (table.getComponentOrientation().isLeftToRight()) {

                x = damagedArea.x;

                for (int column = cMin; column <= cMax; column++) {

                    int w = cm.getColumn(column).getWidth();

                    x += w;

                    synthG.drawLine(context, "Table.grid", g, x - 1, 0,

                                    x - 1, tableHeight - 1);

                }

            } else {

                x = damagedArea.x;

                for (int column = cMax; column >= cMin; column--) {

                    int w = cm.getColumn(column).getWidth();

                    x += w;

                    synthG.drawLine(context, "Table.grid", g, x - 1, 0, x - 1,

                                    tableHeight - 1);

                }

            }

        }

    }

    private int viewIndexForColumn(TableColumn aColumn) {

        TableColumnModel cm = table.getColumnModel();

        for (int column = 0; column < cm.getColumnCount(); column++) {

            if (cm.getColumn(column) == aColumn) {

                return column;

            }

        }

        return -1;

    }

    private void paintCells(SynthContext context, Graphics g, int rMin,

                            int rMax, int cMin, int cMax) {

        JTableHeader header = table.getTableHeader();

        TableColumn draggedColumn = (header == null) ? null : header.getDraggedColumn();

        TableColumnModel cm = table.getColumnModel();

        int columnMargin = cm.getColumnMargin();

        Rectangle cellRect;

        TableColumn aColumn;

        int columnWidth;

        if (table.getComponentOrientation().isLeftToRight()) {

            for(int row = rMin; row <= rMax; row++) {

                cellRect = table.getCellRect(row, cMin, false);