/*******************************************************************************
 * Copyright (c) 2004 Stefan Zeiger and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.novocode.com/legal/epl-v10.html
 * 
 * Contributors:
 *     Stefan Zeiger (szeiger@novocode.com) - initial API and implementation
 *     IBM Corporation - original SWT CLabel implementation on which this class is based
 *******************************************************************************/

module dwtx.novocode.ScaledImage;

import dwt.DWT;
import dwt.graphics.Color;
import dwt.graphics.GC;
import dwt.graphics.Image;
import dwt.graphics.Point;
import dwt.graphics.Rectangle;
import dwt.widgets.Canvas;
import dwt.widgets.Composite;
import dwt.widgets.Event;
import dwt.widgets.Listener;


/**
 * An image / gradient component. Under development.
 *
 * @author Stefan Zeiger (szeiger@novocode.com)
 * @since Mar 21, 2005
 * @version $Id: ScaledImage.java 346 2005-07-11 20:15:57 +0000 (Mon, 11 Jul 2005) szeiger $
 */

class ScaledImage : Canvas
{
    private const Rectangle DEFAULT_BOUNDS;

    public static const int IMAGE_PLACEMENT_STRETCH = 0;
    public static const int IMAGE_PLACEMENT_TILE    = 1;

    private Image image;

    private Color[] gradientColors;

    private int[] gradientPercents;

    private bool gradientVertical;

    private int imagePlacement = IMAGE_PLACEMENT_STRETCH;


    this(Composite parent, int style)
    {
        super(parent, style | DWT.NO_BACKGROUND);
        this.DEFAULT_BOUNDS = new Rectangle(0, 0, 32, 32);

        addListener(DWT.Paint, dgListener(&onPaint));
    }


    private void onPaint(Event event)
    {
        Rectangle rect = getClientArea();
        GC gc = event.gc;
        if(image is null
                || image.getImageData().getTransparencyType() !is DWT.TRANSPARENCY_NONE)
        {

            if(gradientColors !is null)
            {
                // draw a gradient behind the text
                Color oldBackground = gc.getBackground();
                if(gradientColors.length is 1)
                {
                    if(gradientColors[0] !is null) gc.setBackground(gradientColors[0]);
                    gc.fillRectangle(0, 0, rect.width, rect.height);
                }
                else
                {
                    Color oldForeground = gc.getForeground();
                    Color lastColor = gradientColors[0];
                    if(lastColor is null) lastColor = oldBackground;
                    int pos = 0;
                    for(int i = 0; i < gradientPercents.length; ++i)
                    {
                        gc.setForeground(lastColor);
                        lastColor = gradientColors[i + 1];
                        if(lastColor is null) lastColor = oldBackground;
                        gc.setBackground(lastColor);
                        if(gradientVertical)
                        {
                            int gradientHeight = (gradientPercents[i] * rect.height / 100)
                                - pos;
                            gc.fillGradientRectangle(0, pos, rect.width, gradientHeight,
                                    true);
                            pos += gradientHeight;
                        }
                        else
                        {
                            int gradientWidth = (gradientPercents[i] * rect.width / 100)
                                - pos;
                            gc.fillGradientRectangle(pos, 0, gradientWidth, rect.height,
                                    false);
                            pos += gradientWidth;
                        }
                    }
                    if(gradientVertical && pos < rect.height)
                    {
                        gc.setBackground(getBackground());
                        gc.fillRectangle(0, pos, rect.width, rect.height - pos);
                    }
                    if(!gradientVertical && pos < rect.width)
                    {
                        gc.setBackground(getBackground());
                        gc.fillRectangle(pos, 0, rect.width - pos, rect.height);
                    }
                    gc.setForeground(oldForeground);
                }
                gc.setBackground(oldBackground);
            }
            else
            {
                if((getStyle() & DWT.NO_BACKGROUND) !is 0)
                {
                    gc.setBackground(getBackground());
                    gc.fillRectangle(rect);
                }
            }

        }
        if(image !is null)
        {
            Rectangle ib = image.getBounds();
            if(imagePlacement is IMAGE_PLACEMENT_TILE)
            {
                int maxStartX = rect.x + rect.width;
                int maxStartY = rect.y + rect.height;
                for(int x = rect.x; x < maxStartX; x += ib.width)
                    for(int y = rect.y; y < maxStartY; y += ib.height)
                        event.gc.drawImage(image, x, y);
            }
            else // IMAGE_PLACEMENT_STRETCH
            {
                event.gc.drawImage(image, ib.x, ib.y, ib.width, ib.height, rect.x,
                        rect.y, rect.width, rect.height);
            }
        }
    }


    public void setImage(Image image)
    {
        this.image = image;
        redraw();
    }


    public void setImagePlacement(int imagePlacement)
    {
        this.imagePlacement = imagePlacement;
        redraw();
    }


    public Point computeSize(int wHint, int hHint, bool changed)
    {
        checkWidget();
        Rectangle ib = image !is null ? image.getBounds() : DEFAULT_BOUNDS;
        if(wHint == DWT.DEFAULT) wHint = ib.width;
        if(hHint == DWT.DEFAULT) hHint = ib.height;
        return new Point(wHint, hHint);
    }


    public void setBackground(Color color)
    {
        super.setBackground(color);
        // Are these settings the same as before?
        if(color !is null && gradientColors is null && gradientPercents is null)
        {
            Color background = getBackground();
            if(color is background)
            {
                return;
            }
        }
        gradientColors = null;
        gradientPercents = null;
        redraw();
    }


    public void setBackground(Color[] colors, int[] percents)
    {
        setBackground(colors, percents, false);
    }


    public void setBackground(Color[] colors, int[] percents, bool vertical)
    {
        checkWidget();
        if(colors !is null)
        {
            if(percents is null || percents.length !is colors.length - 1)
            {
                DWT.error(DWT.ERROR_INVALID_ARGUMENT);
            }
            if(getDisplay().getDepth() < 15)
            {
                // Don't use gradients on low color displays
                colors = [ colors[colors.length - 1] ];
                percents = [];
            }
            for(int i = 0; i < percents.length; i++)
            {
                if(percents[i] < 0 || percents[i] > 100)
                {
                    DWT.error(DWT.ERROR_INVALID_ARGUMENT);
                }
                if(i > 0 && percents[i] < percents[i - 1])
                {
                    DWT.error(DWT.ERROR_INVALID_ARGUMENT);
                }
            }
        }

        // Are these settings the same as before?
        Color background = getBackground();
        if((gradientColors !is null) && (colors !is null)
                && (gradientColors.length is colors.length))
        {
            bool same = false;
            for(int i = 0; i < gradientColors.length; i++)
            {
                same = (gradientColors[i] is colors[i])
                    || ((gradientColors[i] is null) && (colors[i] is background))
                    || ((gradientColors[i] is background) && (colors[i] is null));
                if(!same) break;
            }
            if(same)
            {
                for(int i = 0; i < gradientPercents.length; i++)
                {
                    same = gradientPercents[i] is percents[i];
                    if(!same) break;
                }
            }
            if(same && this.gradientVertical is vertical) return;
        }
        // Store the new settings
        if(colors is null)
        {
            gradientColors = null;
            gradientPercents = null;
            gradientVertical = false;
        }
        else
        {
            gradientColors = new Color[colors.length];
            for(int i = 0; i < colors.length; ++i)
                gradientColors[i] = (colors[i] !is null) ? colors[i] : background;
            gradientPercents = new int[percents.length];
            for(int i = 0; i < percents.length; ++i)
                gradientPercents[i] = percents[i];
            gradientVertical = vertical;
        }
        // Refresh with the new settings
        redraw();
    }
}