/*

 * Copyright 2002-2008 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.event.*;

import java.awt.Graphics;

import java.awt.Dimension;

import java.awt.FontMetrics;

import java.awt.Rectangle;

import java.awt.Point;

import java.awt.Insets;

import java.beans.*;

import java.util.Dictionary;

import java.util.Enumeration;

import javax.swing.*;

import javax.swing.plaf.*;

import javax.swing.plaf.basic.BasicSliderUI;

import sun.swing.SwingUtilities2;

/**

 *

 * @author Joshua Outwater

 */

    /**

     * When a JSlider is used as a renderer in a JTable, its layout is not

     * being recomputed even though the size is changing. Even though there

     * is a ComponentListener installed, it is not being notified. As such,

     * at times when being asked to paint the layout should first be redone.

     * At the end of the layout method we set this lastSize variable, which

     * represents the size of the slider the last time it was layed out.

     *

     * In the paint method we then check to see that this is accurate, that

     * the slider has not changed sizes since being last layed out. If necessary

     * we recompute the layout.

     */

    private Dimension lastSize = null;

    private int trackHeight;

    private int trackBorder;

    private int thumbWidth;

    private int thumbHeight;

    private SynthStyle style;

    private SynthStyle sliderTrackStyle;

    private SynthStyle sliderThumbStyle;

    /** Used to determine the color to paint the thumb. */

    private transient boolean thumbActive; //happens on rollover, and when pressed

    private transient boolean thumbPressed; //happens when mouse was depressed while over thumb

    ///////////////////////////////////////////////////

    // ComponentUI Interface Implementation methods

    ///////////////////////////////////////////////////

    public static ComponentUI createUI(JComponent c) {

        return new SynthSliderUI((JSlider)c);

    }

        super(c);

    }

    protected void installDefaults(JSlider slider) {

        updateStyle(slider);

    }

    protected void uninstallDefaults() {

        SynthContext context = getContext(slider, ENABLED);

        style.uninstallDefaults(context);

        context.dispose();

        style = null;

        context = getContext(slider, Region.SLIDER_TRACK, ENABLED);

        sliderTrackStyle.uninstallDefaults(context);

        context.dispose();

        sliderTrackStyle = null;

        context = getContext(slider, Region.SLIDER_THUMB, ENABLED);

        sliderThumbStyle.uninstallDefaults(context);

        context.dispose();

        sliderThumbStyle = null;

    }

    protected void installListeners(JSlider slider) {

        super.installListeners(slider);

        slider.addPropertyChangeListener(this);

    }

    protected void uninstallListeners(JSlider slider) {

        slider.removePropertyChangeListener(this);

        super.uninstallListeners(slider);

    }

    private void updateStyle(JSlider c) {

        SynthContext context = getContext(c, ENABLED);

        SynthStyle oldStyle = style;

        style = SynthLookAndFeel.updateStyle(context, this);

        if (style != oldStyle) {

            thumbWidth =

                style.getInt(context, "Slider.thumbWidth", 30);

            thumbHeight =

                style.getInt(context, "Slider.thumbHeight", 14);

            // handle scaling for sizeVarients for special case components. The

            // key "JComponent.sizeVariant" scales for large/small/mini

            // components are based on Apples LAF

            String scaleKey = (String)slider.getClientProperty(

                    "JComponent.sizeVariant");

            if (scaleKey != null){

                if ("large".equals(scaleKey)){

                    thumbWidth *= 1.15;

                    thumbHeight *= 1.15;

                } else if ("small".equals(scaleKey)){

                    thumbWidth *= 0.857;

                    thumbHeight *= 0.857;

                } else if ("mini".equals(scaleKey)){

                    thumbWidth *= 0.784;

                    thumbHeight *= 0.784;

                }

            }

            trackBorder =

                style.getInt(context, "Slider.trackBorder", 1);

            trackHeight = thumbHeight + trackBorder * 2;

            paintValue = style.getBoolean(context,

                    "Slider.paintValue", true);

            if (oldStyle != null) {

                uninstallKeyboardActions(c);

                installKeyboardActions(c);

            }

        }

        context.dispose();

        context = getContext(c, Region.SLIDER_TRACK, ENABLED);

        sliderTrackStyle =

            SynthLookAndFeel.updateStyle(context, this);

        context.dispose();

        context = getContext(c, Region.SLIDER_THUMB, ENABLED);

        sliderThumbStyle =

            SynthLookAndFeel.updateStyle(context, this);

        context.dispose();

    }

    protected TrackListener createTrackListener(JSlider s) {

        return new SynthTrackListener();

    }

    private void updateThumbState(int x, int y) {

        setThumbActive(thumbRect.contains(x, y));

    }

    private void updateThumbState(int x, int y, boolean pressed) {

        updateThumbState(x, y);

        setThumbPressed(pressed);

    }

    private void setThumbActive(boolean active) {

        if (thumbActive != active) {

            thumbActive = active;

            slider.repaint(thumbRect);

        }

    }

    private void setThumbPressed(boolean pressed) {

        if (thumbPressed != pressed) {

            thumbPressed = pressed;

            slider.repaint(thumbRect);

        }

    }

    public int getBaseline(JComponent c, int width, int height) {

        if (c == null) {

            throw new NullPointerException("Component must be non-null");

        }

        if (width < 0 || height < 0) {

            throw new IllegalArgumentException(

                    "Width and height must be >= 0");

        }

        if (slider.getPaintLabels() && labelsHaveSameBaselines()) {

            // Get the insets for the track.

            Insets trackInsets = new Insets(0, 0, 0, 0);

            SynthContext trackContext = getContext(slider,

                                                   Region.SLIDER_TRACK);

            style.getInsets(trackContext, trackInsets);

            trackContext.dispose();

            if (slider.getOrientation() == JSlider.HORIZONTAL) {

                int valueHeight = 0;

                if (paintValue) {

                    SynthContext context = getContext(slider);

                    valueHeight = context.getStyle().getGraphicsUtils(context).

                            getMaximumCharHeight(context);

                    context.dispose();

                }

                int tickHeight = 0;

                if (slider.getPaintTicks()) {

                    tickHeight = getTickLength();

                }

                int labelHeight = getHeightOfTallestLabel();

                int contentHeight = valueHeight + trackHeight +

                        trackInsets.top + trackInsets.bottom +

                        tickHeight + labelHeight + 4;

                int centerY = height / 2 - contentHeight / 2;

                centerY += valueHeight + 2;

                centerY += trackHeight + trackInsets.top + trackInsets.bottom;

                centerY += tickHeight + 2;

                JComponent label = (JComponent) slider.getLabelTable().elements().nextElement();

                Dimension pref = label.getPreferredSize();

                return centerY + label.getBaseline(pref.width, pref.height);

            }

            else { // VERTICAL

                Integer value = slider.getInverted() ? getLowestValue() :

                                                       getHighestValue();

                if (value != null) {

                    int valueY = insetCache.top;

                    int valueHeight = 0;

                    if (paintValue) {

                        SynthContext context = getContext(slider);

                        valueHeight = context.getStyle().getGraphicsUtils(

                                context).getMaximumCharHeight(context);

                        context.dispose();

                    }

                    int contentHeight = height - insetCache.top -

                            insetCache.bottom;

                    int trackY = valueY + valueHeight;

                    int trackHeight = contentHeight - valueHeight;

                    int yPosition = yPositionForValue(value.intValue(), trackY,

                                                      trackHeight);

                    JComponent label = (JComponent) slider.getLabelTable().get(value);

                    Dimension pref = label.getPreferredSize();

                    return yPosition - pref.height / 2 +

                            label.getBaseline(pref.width, pref.height);

                }

            }

        }

        return -1;

    }

    public Dimension getPreferredSize(JComponent c)  {

        recalculateIfInsetsChanged();

        if (slider.getOrientation() == JSlider.VERTICAL) {

            d.height = 200;

        } else {

            d.width = 200;

        }

        Insets i = slider.getInsets();

        d.width += i.left + i.right;

        d.height += i.top + i.bottom;

        return d;

    }

    public Dimension getMinimumSize(JComponent c) {

        recalculateIfInsetsChanged();

        if (slider.getOrientation() == JSlider.VERTICAL) {

            d.height = thumbRect.height + insetCache.top + insetCache.bottom;

        } else {

            d.width = thumbRect.width + insetCache.left + insetCache.right;

        }

        return d;

    }

    protected void calculateGeometry() {

        layout();

        calculateThumbLocation();

    }

    protected void layout() {

        SynthContext context = getContext(slider);

        SynthGraphicsUtils synthGraphics = style.getGraphicsUtils(context);

        // Set the thumb size.

        Dimension size = getThumbSize();

        thumbRect.setSize(size.width, size.height);

        // Get the insets for the track.

        Insets trackInsets = new Insets(0, 0, 0, 0);

        SynthContext trackContext = getContext(slider, Region.SLIDER_TRACK);

        style.getInsets(trackContext, trackInsets);

        trackContext.dispose();

        if (slider.getOrientation() == JSlider.HORIZONTAL) {

            // Calculate the height of all the subcomponents so we can center

            // them.

            valueRect.height = 0;

            if (paintValue) {

                valueRect.height =

                    synthGraphics.getMaximumCharHeight(context);

            }

            trackRect.height = trackHeight;

            tickRect.height = 0;

            if (slider.getPaintTicks()) {

                tickRect.height = getTickLength();

            }

            labelRect.height = 0;

            if (slider.getPaintLabels()) {

                labelRect.height = getHeightOfTallestLabel();

            }

                + trackInsets.top + trackInsets.bottom

                + tickRect.height + labelRect.height + 4;

                - insetCache.right;

            // Check if any of the labels will paint out of bounds.

            int pad = 0;

            if (slider.getPaintLabels()) {

                // Calculate the track rectangle.  It is necessary for

                // xPositionForValue to return correct values.

                trackRect.x = insetCache.left;

                Dictionary dictionary = slider.getLabelTable();

                if (dictionary != null) {

                    int minValue = slider.getMinimum();

                    int maxValue = slider.getMaximum();

                    // Iterate through the keys in the dictionary and find the

                    // first and last labels indices that fall within the

                    // slider range.

                    int firstLblIdx = Integer.MAX_VALUE;

                    int lastLblIdx = Integer.MIN_VALUE;

                    for (Enumeration keys = dictionary.keys();

                            keys.hasMoreElements(); ) {

                        int keyInt = ((Integer)keys.nextElement()).intValue();

                        if (keyInt >= minValue && keyInt < firstLblIdx) {

                            firstLblIdx = keyInt;

                        }

                        if (keyInt <= maxValue && keyInt > lastLblIdx) {

                            lastLblIdx = keyInt;

                        }

                    }

                    // Calculate the pad necessary for the labels at the first

                    // and last visible indices.

                    pad = getPadForLabel(firstLblIdx);

                    pad = Math.max(pad, getPadForLabel(lastLblIdx));

                }

            }

            // Calculate the painting rectangles for each of the different

            // slider areas.

            valueRect.x = trackRect.x = tickRect.x = labelRect.x =

                (insetCache.left + pad);

            valueRect.width = trackRect.width = tickRect.width =

            valueRect.y = centerY;

            centerY += valueRect.height + 2;

            trackRect.y = centerY + trackInsets.top;

            centerY += trackRect.height + trackInsets.top + trackInsets.bottom;

            tickRect.y = centerY;

            centerY += tickRect.height + 2;

            labelRect.y = centerY;

            centerY += labelRect.height;

        } else {

            // Calculate the width of all the subcomponents so we can center

            // them.

            trackRect.width = trackHeight;

            tickRect.width = 0;

            if (slider.getPaintTicks()) {

                tickRect.width = getTickLength();

            }

            labelRect.width = 0;

            if (slider.getPaintLabels()) {

                labelRect.width = getWidthOfWidestLabel();

            }

            valueRect.y = insetCache.top;

            valueRect.height = 0;

            if (paintValue) {

                valueRect.height =

                    synthGraphics.getMaximumCharHeight(context);

            }

            // Get the max width of the min or max value of the slider.

            FontMetrics fm = slider.getFontMetrics(slider.getFont());

            valueRect.width = Math.max(

                synthGraphics.computeStringWidth(context, slider.getFont(),

                    fm, "" + slider.getMaximum()),

                synthGraphics.computeStringWidth(context, slider.getFont(),

                    fm, "" + slider.getMinimum()));

            int l = valueRect.width / 2;

            int w1 = trackInsets.left + trackRect.width / 2;

            int w2 = trackRect.width / 2 + trackInsets.right +

                              tickRect.width + labelRect.width;

                    2 + insetCache.left + insetCache.right;

                                    insetCache.top - insetCache.bottom;

            // Layout the components.

            trackRect.y = tickRect.y = labelRect.y =

                valueRect.y + valueRect.height;

            trackRect.height = tickRect.height = labelRect.height =

            if (SynthLookAndFeel.isLeftToRight(slider)) {

                if (l > w1) {

                    startX += (l - w1);

                }

                trackRect.x = startX + trackInsets.left;

                startX += trackInsets.left + trackRect.width + trackInsets.right;

                tickRect.x = startX;

                labelRect.x = startX + tickRect.width + 2;

            } else {

                if (l > w2) {

                    startX += (l - w2);

                }

                labelRect.x = startX;

                startX += labelRect.width + 2;

                tickRect.x = startX;

                trackRect.x = startX + tickRect.width + trackInsets.left;

            }

        }

        context.dispose();

        lastSize = slider.getSize();

    }

    /**

     * Calculates the pad for the label at the specified index.

     *