package org.litesoft.GWT.client.widgets;

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

public class SizeableDeckPanel extends AbstractSizeableComplexPanel implements IndexedPanel
{
    private Widget mVisibleWidget;

    public SizeableDeckPanel()
    {
        initializeElements( getHelper().create_OeTable_SeDiv_IeDiv( true ), "LayoutSizeableDeckPanel" );
    }

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

    /**
     * Adds the specified widget to the deck.
     *
     * @param w the widget to be added
     */
    public void add( Widget w )
    {
        insert( w, getWidgetCount() );
    }

    /**
     * Gets the index of the currently-visible widget.
     *
     * @return the visible widget's index
     */
    public int getVisibleWidget()
    {
        return getWidgetIndex( mVisibleWidget );
    }

    public Widget getWidget( int index )
    {
        return getChildren().get( index );
    }

    public int getWidgetCount()
    {
        return getChildren().size();
    }

    public int getWidgetIndex( Widget child )
    {
        return getChildren().indexOf( child );
    }

    /**
     * Inserts a widget before the specified index.
     *
     * @param w           the widget to be inserted
     * @param beforeIndex the index before which it will be inserted
     *
     * @throws IndexOutOfBoundsException if <code>beforeIndex</code> is out of
     *                                   range
     */
    public void insert( Widget w, int beforeIndex )
    {
        if ( (beforeIndex < 0) || (beforeIndex > getWidgetCount()) )
        {
            throw new IndexOutOfBoundsException( String.valueOf( beforeIndex ) );
        }

        super.insert( w, getContainerElement(), beforeIndex );

        if ( mVisibleWidget == null )
        {
            showAwidget( 0 );
        }
        else
        {
            w.setVisible( false );
        }
    }

    public boolean remove( int index )
    {
        return remove( getWidget( index ) );
    }

    public boolean remove( Widget w )
    {
        if ( !super.remove( w ) )
        {
            return false;
        }

        if ( mVisibleWidget == w )
        {
            mVisibleWidget = null;
            if ( getWidgetCount() != 0 )
            {
                showAwidget( 0 );
            }
        }

        return true;
    }

    /**
     * Shows the widget at the specified index. This causes the currently- visible
     * widget to be hidden.
     *
     * @param index the index of the widget to be shown
     */
    public void showWidget( int index )
    {
        checkIndex( index );

        if ( mVisibleWidget != null )
        {
            mVisibleWidget.setVisible( false );
        }
        showAwidget( index );
    }

    private void checkIndex( int index )
    {
        if ( (index < 0) || (index >= getWidgetCount()) )
        {
            throw new IndexOutOfBoundsException( String.valueOf( index ) );
        }
    }

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

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

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

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

    public void setWidth( String width )
    {
        super.setWidth( width ); // for stacktrace Debugging
    }

    public void setHeight( String height )
    {
        super.setHeight( height ); // for stacktrace Debugging
    }

    private void showAwidget( int index )
    {
        mVisibleWidget = getWidget( index );
        mVisibleWidget.setVisible( true );

        distributeToChildrenChangedWidth();
        distributeToChildrenChangedHeight();
    }

    protected void distributeToChildrenChangedWidth()
    {
        if ( anyChildren() )
        {
            adjustSizeOnShownWidget( getWidthHelper() );
        }
    }

    protected void distributeToChildrenChangedHeight()
    {
        if ( anyChildren() )
        {
            adjustSizeOnShownWidget( getHeightHelper() );
        }
    }

    private void adjustSizeOnShownWidget( ISizeableDimensionHelper pDimensionHelper )
    {
        getHelper().applyChangedDimensionToChild( mVisibleWidget, pDimensionHelper );
    }
}