package org.litesoft.GWT.client.widgets;

import com.google.gwt.user.client.ui.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.core.util.*;

public class SizeableImage extends AbstractSizeableComposite implements SourcesClickEvents,
                                                                        SourcesMouseEvents,
                                                                        SourcesLoadEvents,
                                                                        LoadListener
{
    protected Image mImage = new OurImage();

    protected SizeableImage( String pStyle, String pUrl )
    {
        initWidget( new ConstrainingSizeableOuterLayers( mImage, pStyle ) );

        mImage.addLoadListener( this );

        setUrl( pUrl );
    }

    /**
     * Creates an image with a specified URL.
     *
     * @param pUrl the URL of the image to be displayed
     */
    public SizeableImage( String pUrl )
    {
        this( "LayoutSizeableImage", pUrl );
    }

    public SizeableImage()
    {
        this( null );
    }

    public SizeableImage style( String pStyleName )
    {
        addStyleName( pStyleName );
        return this;
    }

    /**
     * Gets the URL of the image.
     *
     * @return the image URL
     */
    public String getUrl()
    {
        return mImage.getUrl();
    }

    /**
     * Sets the URL of the image to be displayed.
     *
     * @param url the image URL
     */
    public void setUrl( String url )
    {
        if ( null != (url = UtilsCommon.noEmpty( url )) )
        {
            setLoading();
            mImage.setUrl( url );
        }
    }

    // proxies to FocusPanel

    private DelegatingClickListenerCollection mClickListeners;
    private DelegatingMouseListenerCollection mMouseListeners;
    private DelegatingLoadListenerCollection mLoadListeners;

    public void addClickListener( ClickListener listener )
    {
        if ( listener != null )
        {
            if ( mClickListeners == null )
            {
                mClickListeners = new DelegatingClickListenerCollection( this, mImage );
            }
            mClickListeners.add( listener );
        }
    }

    public void removeClickListener( ClickListener listener )
    {
        if ( (listener != null) && (mClickListeners != null) && //
             mClickListeners.remove( listener ) && mClickListeners.isEmpty() )
        {
            mImage.removeClickListener( mClickListeners );
            mClickListeners = null;
        }
    }

    public void addMouseListener( MouseListener listener )
    {
        if ( listener != null )
        {
            if ( mMouseListeners == null )
            {
                mMouseListeners = new DelegatingMouseListenerCollection( this, mImage );
            }
            mMouseListeners.add( listener );
        }
    }

    public void removeMouseListener( MouseListener listener )
    {
        if ( (listener != null) && (mMouseListeners != null) && //
             mMouseListeners.remove( listener ) && mMouseListeners.isEmpty() )
        {
            mImage.removeMouseListener( mMouseListeners );
            mMouseListeners = null;
        }
    }

    public void addLoadListener( LoadListener listener )
    {
        if ( listener != null )
        {
            if ( mLoadListeners == null )
            {
                mLoadListeners = new DelegatingLoadListenerCollection( this, mImage );
            }
            mLoadListeners.add( listener );
        }
    }

    public void removeLoadListener( LoadListener listener )
    {
        if ( (listener != null) && (mLoadListeners != null) && //
             mLoadListeners.remove( listener ) && mLoadListeners.isEmpty() )
        {
            mImage.removeLoadListener( mLoadListeners );
            mLoadListeners = null;
        }
    }

    //****** Implementation Code Block to support delegation to AbsoluteSizeHelper

    public SizeableImage stretchable()
    {
        LLstretchable();
        return this;
    }

    public SizeableImage stretchableVertically()
    {
        LLstretchableVertically();
        return this;
    }

    public SizeableImage stretchableHorizontally()
    {
        LLstretchableHorizontally();
        return this;
    }

    // private implementation

    public void setWidth( String width )
    {
        mExternalWidth = width;
        super.setWidth( width );
    }

    public void setHeight( String height )
    {
        mExternalHeight = height;
        super.setHeight( height );
    }

    private String mExternalWidth = null;
    private String mExternalHeight = null;
    private boolean mLoaded = false;

    private void setLoading()
    {
        mLoaded = false;
    }

    private void setLoaded()
    {
        if ( !mLoaded )
        {
            mLoaded = true;
            if ( mExternalWidth == null )
            {
                super.setWidth( "" + getOffsetWidth() );
            }
            if ( mExternalHeight == null )
            {
                super.setHeight( "" + getOffsetHeight() );
            }
        }
    }

    public void onError( Widget sender )
    {
        setLoaded();
    }

    public void onLoad( Widget sender )
    {
        setLoaded();
    }

    public static class DelegatingLoadListenerCollection extends LoadListenerCollection
            implements LoadListener
    {
        private final Widget owner;

        /**
         * Constructor for {@link DelegatingLoadListenerCollection}.
         *
         * @param owner       owner of listeners
         * @param delegatedTo source of events
         */
        public DelegatingLoadListenerCollection( Widget owner, SourcesLoadEvents delegatedTo )
        {
            this.owner = owner;
            delegatedTo.addLoadListener( this );
        }

        public void onError( Widget sender )
        {
            fireError( owner );
        }

        public void onLoad( Widget sender )
        {
            fireLoad( owner );
        }
    }
}