package org.litesoft.GWT.client.widgets;

import java.util.*;

import com.google.gwt.user.client.*;
import com.google.gwt.user.client.ui.*;

import org.litesoft.GWT.client.widgets.nonpublic.*;

public class SizeableFocusPanel extends AbstractSizeableComposite implements HasFocus,
                                                                             SourcesClickEvents,
                                                                             SourcesMouseEvents,
                                                                             SizeableSingleWidgetContainer
{
    private InnerTablePanel mInnerTablePanel = new InnerTablePanel();
    private FocusPanel mFocusDivWidget = new FocusPanel( mInnerTablePanel );

    public SizeableFocusPanel( boolean pOverflowHidden )
    {
        initWidget( new OuterTablePanel( pOverflowHidden, mFocusDivWidget, mInnerTablePanel ) );
        style( "LayoutSizeableFocusPanel" );
    }

    public SizeableFocusPanel( boolean pOverflowHidden, Widget child )
    {
        this( pOverflowHidden );
        setWidget( child );
    }

    public SizeableFocusPanel style( String pStyleName )
    {
        addStyleName( pStyleName );
        return this;
    }
    
    public void add(Widget pWidget)
    {
    	if (getWidget() != null)
    		throw new IllegalStateException();
    	
    	setWidget(pWidget);
    }

    public void setWidget( Widget pWidget )
    {
        mInnerTablePanel.setWidget( pWidget );
    }

    public Widget getWidget()
    {
        return mInnerTablePanel.getWidget();
    }
    
    public boolean remove(Widget w)
    {
    	return mInnerTablePanel.remove(w);
    }
    
    public void clear()
    {
    	mInnerTablePanel.clear();
    }
    
    public Iterator<Widget> iterator()
    {
    	return mInnerTablePanel.iterator();
    }
    
    public void setAccessKey( char key )
    {
        mFocusDivWidget.setAccessKey( key );
    }

    public void setFocus( boolean focused )
    {
        mFocusDivWidget.setFocus( focused );
    }

    public int getTabIndex()
    {
        return mFocusDivWidget.getTabIndex();
    }

    public void setTabIndex( int index )
    {
        mFocusDivWidget.setTabIndex( index );
    }

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

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

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

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

    // proxies to FocusPanel

    private DelegatingKeyboardListenerCollection mKeyboardListeners;
    private DelegatingClickListenerCollection mClickListeners;
    private DelegatingFocusListenerCollection mFocusListeners;
    private DelegatingMouseListenerCollection mMouseListeners;

    public void addKeyboardListener( KeyboardListener listener )
    {
        if ( listener != null )
        {
            if ( mKeyboardListeners == null )
            {
                mKeyboardListeners = new DelegatingKeyboardListenerCollection( this, mFocusDivWidget );
            }
            mKeyboardListeners.add( listener );
        }
    }

    public void removeKeyboardListener( KeyboardListener listener )
    {
        if ( (listener != null) && (mKeyboardListeners != null) && //
             mKeyboardListeners.remove( listener ) && mKeyboardListeners.isEmpty() )
        {
            mFocusDivWidget.removeKeyboardListener( mKeyboardListeners );
            mKeyboardListeners = null;
        }
    }

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

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

    public void addFocusListener( FocusListener listener )
    {
        if ( listener != null )
        {
            if ( mFocusListeners == null )
            {
                mFocusListeners = new DelegatingFocusListenerCollection( this, mFocusDivWidget );
            }
            mFocusListeners.add( listener );
        }
    }

    public void removeFocusListener( FocusListener listener )
    {
        if ( (listener != null) && (mFocusListeners != null) && //
             mFocusListeners.remove( listener ) && mFocusListeners.isEmpty() )
        {
            mFocusDivWidget.removeFocusListener( mFocusListeners );
            mFocusListeners = null;
        }
    }

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

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

    private static class OuterTablePanel extends AbstractSizeablePanel
    {
        private Widget mFocusDivWidget;
        private InnerTablePanel mInnerTablePanel;

        public OuterTablePanel( boolean pOverflowHidden, FocusPanel pFocusPanel,
                                InnerTablePanel pInnerTablePanel )
        {
            setElement( AbstractSizeableHelper.createLayoutDivConstrainingTable() );
            setContainerElement( AbstractSizeableHelper.finishTableNgetTD( getElement() ) );
            setWidget( pFocusPanel );
            mInnerTablePanel = pInnerTablePanel;
            getHelper().setUpSpecialPart1( getElement(), // Outer is our Table
                                           pFocusPanel.getElement(), // Style is the Focus Div
                                           pInnerTablePanel.getElement() ); // Inner is Inner Table
            pFocusPanel.addStyleName( getHelper().setUpSpecialPart2( pOverflowHidden ) );
        }

        /**
         * Adds a widget to this panel.
         *
         * @param w the child widget to be added
         */
        public void add( Widget w )
        {
            // Can't add() more than one widget to a SimplePanel.
            if ( getWidget() != null )
            {
                throw new IllegalStateException( "SimplePanel can only contain one child widget" );
            }
            setWidget( w );
        }

        /**
         * Gets the panel's child widget.
         *
         * @return the child widget, or <code>null</code> if none is present
         */
        public Widget getWidget()
        {
            return mFocusDivWidget;
        }

        public boolean anyChildren()
        {
            return (mFocusDivWidget != null);
        }

        public Iterator<Widget> iterator()
        {
            return new SingleWidgetIterator(mFocusDivWidget)
            {
                public void remove()
                {
                	if ( mFocusDivWidget != null )
                    {
                        OuterTablePanel.this.remove( mFocusDivWidget );
                    }
                }
            };
        }

        public boolean remove( Widget w )
        {
            if ( mFocusDivWidget == w )
            {
                disown( w );
                mFocusDivWidget = null;
                return true;
            }
            return false;
        }

        /**
         * Sets this panel's widget. Any existing child widget will be removed.
         *
         * @param w the panel's new widget (<code>null</code> will clear the panel)
         */
        public void setWidget( Widget w )
        {
            // If there is already a widget attached, remove it.
            if ( mFocusDivWidget != null )
            {
                disown( mFocusDivWidget );
            }

            if ( w != null )
            {
                // Adopt the child.
                adopt( w, getContainerElement() );
            }

            mFocusDivWidget = w;
        }

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

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

        protected void distributeToChildrenChangedWidth()
        {
            mInnerTablePanel.distributeToChildrenChangedWidth();
        }

        protected void distributeToChildrenChangedHeight()
        {
            mInnerTablePanel.distributeToChildrenChangedHeight();
        }
    }

    private class InnerTablePanel extends SimplePanel
    {
        public InnerTablePanel()
        {
            super( AbstractSizeableHelper.createMinSizeConstrainingTable() );
            mContainerElement = AbstractSizeableHelper.finishTableNgetTD( getElement() );
        }

        private Element mContainerElement;

        protected Element getContainerElement()
        {
            return mContainerElement;
        }

        protected void distributeToChildrenChangedWidth()
        {
            getHelper().applyChangedDimensionToChild( getWidget(), getWidthHelper() );
        }

        protected void distributeToChildrenChangedHeight()
        {
            getHelper().applyChangedDimensionToChild( getWidget(), getHeightHelper() );
        }
    }
}