package org.litesoft.GWT.client.widgets;

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.GWT.client.*;
import org.litesoft.GWT.client.widgets.nonpublic.*;
import org.litesoft.core.delayed.*;
import org.litesoft.core.simpletypes.*;
import org.litesoft.core.util.*;

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

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

/**
 * This Widget is designed to support selecting an "Injection Point" within a List of "InjectIns".
 * <p/>
 * It does this by supporting upto 3 short lists with alternating "Injection Points" and "InjectIns".
 * These 3 short lists are the: "Home", "Previous" (or Back), & "Current".
 * <p/>
 * The Widget Structure is:
 * <pre>
 *      *** InjectionPointSelector (SizeableHorizontalPanel.stretchable) ********************************
 *      * ** HeightManager ** ** LayoutCtrlPanel (SizeableVerticalPanel.stretchable) ****************** *
 *      * * (VerticalPanel) * *                ---- Vertically Centering Spacer ----                  * *
 *      * *                 * * ** UserCtrlPanel (SizeableHorizontalPanel.stretchableHorizontally) ** * *
 *      * *                 * * *                                                                   * * *
 *      * *                 * * ********************************************************************* * *
 *      * *                 * *                ---- Vertically Centering Spacer ----                  * *
 *      * ******************* ************************************************************************* *
 *      *************************************************************************************************
 * </pre>
 */
public class InjectionPointSelector<T extends Synopsisable> extends SizeableHorizontalPanel
{
    public interface Callback<U extends Synopsisable>
    {
        public void injectBetween( U pLowerBound, U pUpperBound );
    }

    private static final int EXPANSION_WIDTH = 90;
    private static final int DOT_DOT_DOT_WIDTH = 30;

    private String mVerticalSpacer;
    private HeightManager mHeightManager;
    private int mPanelHeight = -1;

    private InjectionPointSelectorController<T> mController;

    public InjectionPointSelector( int pSynopsisLines, List<T> pInjectIns, final Callback<T> pCallback )
    {
        stretchable();
        addStyleName( "InjectionPointSelector" );

        mVerticalSpacer = HTMLize.escapeNoWrap( Strings.makeNonBlankLines( null, pSynopsisLines ) );

        final LayoutPanel zLayoutCtrlPanel = new LayoutPanel( new UserCtrlPanel().with( new Spacer().width( 280 ), new Label( "Loading..." ), new Spacer().width( 280 ) ) );

        HeightManager.Callback zHeightManagerCallback = new HeightManager.Callback()
        {
            @Override
            public void panelsVisible( int pCount, int pPanelHeight )
            {
                System.out.println( "InjectionPointSelector.panelsVisible: " + pCount + " w/ height " + pPanelHeight );
                mPanelHeight = pPanelHeight;
                mController.updateForEntriesVisible( pCount );
            }
        };

        add( mHeightManager = new HeightManager( mVerticalSpacer, zHeightManagerCallback ) );
        add( new Spacer().style( "LeftSpacer" ) );
        add( zLayoutCtrlPanel );
        add( new Spacer().style( "RightSpacer" ) );
        add( new HeightManager( mVerticalSpacer, null ) );

        mController = new InjectionPointSelectorController<T>( pSynopsisLines, pInjectIns, new View<T>()
        {
            @Override public void injectBetween( T pLowerBound, T pUpperBound )
            {
                pCallback.injectBetween( pLowerBound, pUpperBound );
            }

            @Override
            public void notEnoughVisibleEntries()
            {
                zLayoutCtrlPanel.message( "Insufficient Space to Show Selectors" );
            }

            @Override
            public void show( DrillDownSet pDrillDownSet )
            {
                if ( 15 > mPanelHeight )
                {
                    zLayoutCtrlPanel.message( "Panel Height? 15 > " + mPanelHeight );
                }
                else
                {
                    zLayoutCtrlPanel.userCtrlPanel( createUserCtrlPanel( pDrillDownSet ) );
                }
                zLayoutCtrlPanel.relayoutFromHereDown();
            }
        } );
    }

    @Override
    public void setHeight( String height )
    {
        super.setHeight( height );
        mHeightManager.possibleHeightAdjustment();
    }

    private static class HeightManager extends BorderedVerticalPanel
    {
        public interface Callback
        {
            public void panelsVisible( int pCount, int pPanelHeight );
        }

        private Callback mCallback;

        public HeightManager( String pVerticalSpacer, Callback pCallback )
        {
            super( pVerticalSpacer, "HeightManager" );
            mCallback = pCallback;

            CommonElementHelper.hide( getElement() );

            addHiddenFirstEmptyPanel();
            addHiddenEmptyPanel();
            addHiddenEmptyPanel();
            addHiddenEmptyPanel();
            addHiddenEmptyPanel();
            addHiddenEmptyPanel();
        }

        public void possibleHeightAdjustment()
        {
            mTask.trigger();
        }

        private Task mTask = new Task( TimedRunnableManager.INSTANCE, 20 )
        {
            private Integer mPanelHeight = null;

            @Override
            protected boolean reRunWhenTriggeredAndCurrentlyRunning()
            {
                return true;
            }

            @Override
            protected boolean preconditionsSatisfied()
            {
                if ( isAttached() )
                {
                    Element zElement = getElement();
                    int zOurHeight = zElement.getOffsetHeight();
                    int zAvailableHeight = getParent().getOffsetHeight();
                    if ( (zOurHeight > 10) && (zAvailableHeight > 10) )
                    {
                        if ( mPanelHeight == null )
                        {
                            WidgetCollection zChildren = getChildren();
                            int z2ndAt = zChildren.get( 1 ).getAbsoluteTop();
                            int z3rdAt = zChildren.get( 2 ).getAbsoluteTop();
                            int zPanelHeight = z3rdAt - z2ndAt;
                            if ( zPanelHeight <= 10 )
                            {
                                return false;
                            }
                            mPanelHeight = zPanelHeight;
                        }
                        int zOurMinimumHeight = zAvailableHeight + mPanelHeight;
                        if ( zOurMinimumHeight <= zOurHeight )
                        {
                            return true;
                        }
                        do
                        {
                            addHiddenEmptyPanel();
                            zOurHeight += mPanelHeight;
                        }
                        while ( zOurHeight < zOurMinimumHeight );
                    }
                }
                return false;
            }

            @Override
            protected boolean execute()
            {
                int zAvailableHeight = getParent().getOffsetHeight();
                int zOurTop = getAbsoluteTop();
                WidgetCollection zChildren = getChildren();
                int zChildCount = zChildren.size();
                int i = 1;
                for (; i < zChildCount; i++ )
                {
                    int zNthAt = zChildren.get( i ).getAbsoluteTop() - zOurTop;
                    if ( zAvailableHeight <= zNthAt )
                    {
                        break;
                    }
                }
                mCallback.panelsVisible( i - 1, mPanelHeight );
                return true;
            }
        };
    }

    private static class BorderedVerticalPanel extends SizeableVerticalPanel
    {
        protected final String mVerticalSpacer;
        private boolean mFirstAdded = false;

        public BorderedVerticalPanel( String pVerticalSpacer, String pClassName )
        {
            mVerticalSpacer = pVerticalSpacer;
            addStyleName( pClassName );
            setVerticalAlignment( HasVerticalAlignment.ALIGN_TOP );
        }

        public void addHiddenFirstEmptyPanel()
        {
            add( new HTML( mVerticalSpacer ), true, true );
        }

        public void addHiddenEmptyPanel()
        {
            add( new HTML( mVerticalSpacer ), true, false );
        }

        private void add( Widget w, boolean pHidden, boolean pTriggerFirst )
        {
            super.add( w );
            Element zElement = w.getElement();
            if ( pHidden )
            {
                CommonElementHelper.hide( zElement );
            }
            Element zTD = zElement.getParentElement();
            zTD.addClassName( "Row" );
            if ( pTriggerFirst && !mFirstAdded )
            {
                mFirstAdded = true;
                Element zTR = zTD.getParentElement();
                zTR.addClassName( "First" );
            }
        }

        @Override
        public void add( Widget w )
        {
            add( w, false, true );
        }
    }

//    private static String html = "<html>\n" + //
//                                 "    <head>\n" + //
//                                 "        <title>\n" + //
//                                 "            Test styling!\n" + //
//                                 "        </title>\n" + //
//                                 "        <style>\n" + //
//                                 "         <!--\n" + //
//                                 "            .First .Row { border-top:1px solid black; }\n" + //
//                                 "            .Row { border-bottom:1px solid black; border-left:1px solid black; border-right:1px solid black; }\n" + //
//                                 "            .Not .Row { visibility:hidden; }\n" + //
//                                 "         -->\n" + //
//                                 "        </style>\n" + //
//                                 "    </head>\n" + //
//                                 "    <body>\n" + //
//                                 "        <table border=0 cellpadding=0 cellspacing=0>\n" + //
//                                 "            <tr class='First'><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "            <tr              ><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "            <tr              ><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "            <tr   class='Not'><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "            <tr   class='Not'><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "            <tr              ><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "            <tr              ><td class='Row'><table border=0><tr><td><br><br><br><br></td><td valign='middle'>Hello</td><td><br><br><br><br></td></tr></table></td></tr>\n" + //
//                                 "        </table>\n" + //
//                                 "    </body>\n" + //
//                                 "</html>";

    private static class SetCtrl
    {
        private List<Widget> mViewEntryPanels = new ArrayList<Widget>();

        public List<Widget> getViewEntryPanels()
        {
            return mViewEntryPanels;
        }

        public void add( Widget pViewEntryPanel )
        {
            mViewEntryPanels.add( pViewEntryPanel );
        }

        public int size()
        {
            return mViewEntryPanels.size();
        }

        public int getTopOffset()
        {
            return 0;
        }

        public int getBottomOffset()
        {
            return size() - 1;
        }
    }

    private static class NavigateSetCtrl extends SetCtrl
    {
        private int mSelectedPanel = -1;

        public int getSelectedPanel()
        {
            return mSelectedPanel;
        }

        public void setSelectedPanel( int pSelectedPanel )
        {
            mSelectedPanel = pSelectedPanel;
        }
    }

    private static class CurrentSetCtrl extends SetCtrl
    {
        private int mLeadingEmpties = 0;
        private int mTrailingEmpties = 0;

        public boolean anyEmpties()
        {
            return (mLeadingEmpties != 0) || (mTrailingEmpties != 0);
        }

        public int getLeadingEmpties()
        {
            return mLeadingEmpties;
        }

        public int getTrailingEmpties()
        {
            return mTrailingEmpties;
        }

        @Override
        public int getTopOffset()
        {
            return mLeadingEmpties;
        }

        @Override
        public int getBottomOffset()
        {
            return mLeadingEmpties + super.getBottomOffset();
        }

        public void adjustHeightTo( int pPreviousSetsSelectedPanel, int pNewHeightInPanels )
        {
            if ( pNewHeightInPanels != size() )
            {
                for ( int zToAdd = pNewHeightInPanels - size(); zToAdd > 1; zToAdd -= 2 )
                {
                    mLeadingEmpties++;
                    mTrailingEmpties++;
                }
                for ( int zSelectedTopOffset = pPreviousSetsSelectedPanel - 1; zSelectedTopOffset < getTopOffset(); mTrailingEmpties++ )
                {
                    mLeadingEmpties--; // Move Up
                }
                for ( int zSelectedBottom = pPreviousSetsSelectedPanel + 1; zSelectedBottom > getBottomOffset(); mTrailingEmpties-- )
                {
                    mLeadingEmpties++; // Move Down
                }
            }
        }
    }

    private Widget createUserCtrlPanel( DrillDownSet pDrillDownSet )
    {
        UserCtrlPanel zPanel = new UserCtrlPanel();

        NavigateSetCtrl zHomeSetCtrl = createNavigateSet( pDrillDownSet.getHomeSet() );
        NavigateSetCtrl zBackSetCtrl = createNavigateSet( pDrillDownSet.getPreviousSet() );
        CurrentSetCtrl zCurrentSetCtrl = createCurrentSet( pDrillDownSet.getCurrentSet() );

        zPanel.add( new Spacer( 10 ) );
        if ( zHomeSetCtrl != null )
        {
            int zMaxPanels = Math.max( zCurrentSetCtrl.size(), zHomeSetCtrl.size() );
            NavigateSetCtrl zLastSetCtrl = zHomeSetCtrl;
            zPanel.add( createNavigatePanel( zLastSetCtrl, new ClickHandler()
            {
                @Override
                public void onClick( ClickEvent event )
                {
                    mController.homeSelected();
                }
            } ) );
            if ( zBackSetCtrl != null )
            {
                zMaxPanels = Math.max( zMaxPanels, zBackSetCtrl.size() );
                zPanel.add( createExpansionPanel( zMaxPanels, zLastSetCtrl.getSelectedPanel(), zBackSetCtrl, pDrillDownSet.isSomethingBetweenHomeAndPreviousSets() ) );
                zPanel.add( createNavigatePanel( zLastSetCtrl = zBackSetCtrl, new ClickHandler()
                {
                    @Override
                    public void onClick( ClickEvent event )
                    {
                        mController.previousSelected();
                    }
                } ) );
            }
            zCurrentSetCtrl.adjustHeightTo( zLastSetCtrl.getSelectedPanel(), zMaxPanels );
            zPanel.add( createExpansionPanel( zMaxPanels, zLastSetCtrl.getSelectedPanel(), zCurrentSetCtrl, false ) );
        }
        zPanel.add( createCurrentPanel( zCurrentSetCtrl ) );
        zPanel.add( new Spacer( 10 ) );
        return zPanel;
    }

    private NavigateSetCtrl createNavigateSet( ViewSet pViewSet )
    {
        if ( pViewSet == null )
        {
            return null;
        }
        NavigateSetCtrl zCtrl = new NavigateSetCtrl();
        ViewEntry[] zEntries = pViewSet.getEntries();
        for ( int i = 0; i < zEntries.length; i++ )
        {
            ViewEntry zEntry = zEntries[i];
            if ( zEntry.isSelected() )
            {
                zCtrl.setSelectedPanel( i );
            }
            zCtrl.add( createNavigateSetWidget( zEntry ) );
        }
        return zCtrl;
    }

    private CurrentSetCtrl createCurrentSet( ViewSet pCurrentSet )
    {
        CurrentSetCtrl zCtrl = new CurrentSetCtrl();
        ViewEntry[] zEntries = pCurrentSet.getEntries();
        for ( ViewEntry zEntry : zEntries )
        {
            zCtrl.add( createCurrentSetWidget( zEntry ) );
        }
        return zCtrl;
    }

    private Widget createCurrentSetWidget( final ViewEntry pEntry )
    {
        SizeableHorizontalPanel zPanel = new SizeableHorizontalPanel().stretchableHorizontally();
        zPanel.setVerticalAlignment( HasVerticalAlignment.ALIGN_MIDDLE );
        zPanel.addStyleName( "Cell" );
        zPanel.addStyleName( pEntry.isSelectable() ? "Selectable" : "NonSelectable" );

        SizeableSpacer zLeftSpacer = new SizeableSpacer().width( 5 ).height( mPanelHeight - 1 );
        SizeableLabel zLabel = new SizeableLabel( HTMLize.escapeNoWrap( pEntry.getText() ), true ).style( DataTableStyle.DATA_TABLE_TEXT );

        zPanel.add( zLeftSpacer );
        zPanel.add( zLabel );
        zPanel.add( new SizeableSpacer().width( 5 ).height( mPanelHeight - 1 ).stretchableHorizontally() );
        if ( !pEntry.isSelectable() )
        {
            return zPanel;
        }
        zLeftSpacer.stretchableHorizontally();
        SizeableFocusPanel zFocusPanel = new SizeableFocusPanel( zPanel ).stretchableHorizontally();
        zFocusPanel.addClickHandler( new ClickHandler()
        {
            @Override
            public void onClick( ClickEvent event )
            {
                mController.viewSelected( pEntry );
            }
        } );
        return zFocusPanel;
    }

    private Widget createNavigateSetWidget( ViewEntry pEntry )
    {
        SizeableHorizontalPanel zPanel = new SizeableHorizontalPanel();
        zPanel.setVerticalAlignment( HasVerticalAlignment.ALIGN_MIDDLE );
        zPanel.addStyleName( "Cell" );
        zPanel.addStyleName( pEntry.isSelectable() ? "Selectable" : "NonSelectable" );

        SizeableLabel zLabel = new SizeableLabel( HTMLize.escapeNoWrap( pEntry.getText() ), true ).style( DataTableStyle.DATA_TABLE_TEXT );
        zLabel.setWidth( "" + FontSizer.get( DataTableStyle.DATA_TABLE_TEXT ).EMs( 10 ) );
        if ( pEntry.isSelectable() )
        {
            zPanel.setHorizontalAlignment( HasHorizontalAlignment.ALIGN_CENTER );
        }

        zPanel.add( new Spacer().width( 5 ).height( mPanelHeight - 1 ) );
        zPanel.add( zLabel );
        zPanel.add( new Spacer().width( 5 ).height( mPanelHeight - 1 ) );
        return zPanel;
    }

    private Widget createHiddenPanels( int pEmpties )
    {
        BorderedVerticalPanel zPanel = new BorderedVerticalPanel( mVerticalSpacer, "Filler" );
        while ( pEmpties-- > 0 )
        {
            zPanel.addHiddenEmptyPanel();
        }
        return zPanel;
    }

    private Widget createNavigatePanel( NavigateSetCtrl pSetCtrl, ClickHandler pClickHandler )
    {
        BorderedVerticalPanel zPanel = new BorderedVerticalPanel( mVerticalSpacer, "NavigateSet" );
        for ( Widget zWidget : pSetCtrl.getViewEntryPanels() )
        {
            zPanel.add( zWidget );
        }
        SizeableFocusPanel zFocusPanel = new SizeableFocusPanel( zPanel );
        zFocusPanel.addClickHandler( pClickHandler );
        return zFocusPanel;
    }

    private Widget createExpansionPanel( int pMaxPanels, int pPreviousSelectedPanel, SetCtrl pSetCtrl, boolean pAddDotDotDot )
    {
        int zFromTopOffset = pPreviousSelectedPanel - 1;
        int zFromBottomOffset = pPreviousSelectedPanel + 1;
        int zToTopOffset = pSetCtrl.getTopOffset();
        int zToBottomOffset = pSetCtrl.getBottomOffset();

        if ( !pAddDotDotDot )
        {
            return createExpansionPanel( EXPANSION_WIDTH, pMaxPanels, zFromTopOffset, zFromBottomOffset, zToTopOffset, zToBottomOffset );
        }
        int zMidTopOffset = (zFromTopOffset == zToTopOffset) ? zFromTopOffset : (zFromTopOffset + zToTopOffset) / 2;
        int zMidBottomOffset = (zFromBottomOffset == zToBottomOffset) ? zFromBottomOffset : (zFromBottomOffset + zToBottomOffset + 1) / 2;

        int z1stExpansionWidth = (EXPANSION_WIDTH - DOT_DOT_DOT_WIDTH) / 2;
        int z2ndExpansionWidth = EXPANSION_WIDTH - (z1stExpansionWidth + DOT_DOT_DOT_WIDTH);

        HorizontalPanel zPanel = new HorizontalPanel();
        zPanel.add( createExpansionPanel( z1stExpansionWidth, pMaxPanels, zFromTopOffset, zFromBottomOffset, zMidTopOffset, zMidBottomOffset ) );
        zPanel.add( createDotDotDotExpansionPanel( DOT_DOT_DOT_WIDTH, pMaxPanels, zMidTopOffset, zMidBottomOffset ) );
        zPanel.add( createExpansionPanel( z2ndExpansionWidth, pMaxPanels, zMidTopOffset, zMidBottomOffset, zToTopOffset, zToBottomOffset ) );

        return zPanel;
    }

    private Widget createDotDotDotExpansionPanel( int pWidth, int pMaxPanels, int pTopOffset, int pBottomOffset )
    {
        VerticalPanel zPanel = new VerticalPanel();

        int zTopFiller = 1;
        if ( pTopOffset != 0 )
        {
            zTopFiller += pTopOffset * mPanelHeight;
            pMaxPanels -= pTopOffset;
        }
        zPanel.add( new Spacer().width( pWidth ).height( zTopFiller ) );

        int zUpperPanels = ((pBottomOffset + 1) - pTopOffset) / 2;
        if ( zUpperPanels != 0 )
        {
            zPanel.add( image( "GreenPixel" ).size( pWidth, zUpperPanels * mPanelHeight ) );
            pMaxPanels -= zUpperPanels;
        }

        // Straight Across - Always 1 Panels!
        zPanel.add( image( "GreenDotDotDot" ).size( pWidth, mPanelHeight ) );
        pMaxPanels -= 1;

        int zLowerPanels = pBottomOffset - (pTopOffset + zUpperPanels);
        if ( zLowerPanels != 0 )
        {
            zPanel.add( image( "GreenPixel" ).size( pWidth, zLowerPanels * mPanelHeight ) );
            pMaxPanels -= zLowerPanels;
        }

        if ( pMaxPanels != 0 ) // Filler Panels
        {
            zPanel.add( new Spacer().width( pWidth ).height( pMaxPanels * mPanelHeight ) );
        }
        return zPanel;
    }

    /**
     * Notes: pToTopOffset <= pFromTopOffset && pFromBottomOffset <= pToBottomOffset
     */
    private Widget createExpansionPanel( int pWidth, int pMaxPanels, int pFromTopOffset, int pFromBottomOffset, int pToTopOffset, int pToBottomOffset )
    {
        VerticalPanel zPanel = new VerticalPanel();

        int zTopFiller = 1;
        if ( pToTopOffset != 0 )
        {
            zTopFiller += pToTopOffset * mPanelHeight;
            pMaxPanels -= pToTopOffset;
        }
        zPanel.add( new Spacer().width( pWidth ).height( zTopFiller ) );

        int zRisingPanels = pFromTopOffset - pToTopOffset;
        if ( zRisingPanels != 0 )
        {
            zPanel.add( image( "RisingGreen" ).size( pWidth, zRisingPanels * mPanelHeight ) );
            pMaxPanels -= zRisingPanels;
        }

        int zStraightAcrossPanels = Math.min( pFromBottomOffset, pToBottomOffset ) - Math.max( pFromTopOffset, pToTopOffset ) + 1; // Should Always be >= 3 Panels!
        zPanel.add( image( "GreenPixel" ).size( pWidth, zStraightAcrossPanels * mPanelHeight ) );
        pMaxPanels -= zStraightAcrossPanels;

        int zDecendingPanels = pToBottomOffset - pFromBottomOffset;
        if ( zDecendingPanels != 0 )
        {
            zPanel.add( image( "DecendingGreen" ).size( pWidth, zDecendingPanels * mPanelHeight ) );
            pMaxPanels -= zDecendingPanels;
        }

        if ( pMaxPanels != 0 ) // Bottom Filler
        {
            zPanel.add( new Spacer().width( pWidth ).height( pMaxPanels * mPanelHeight ) );
        }
        return zPanel;
    }

    private Widget createCurrentPanel( CurrentSetCtrl pSetCtrl )
    {
        if ( !pSetCtrl.anyEmpties() )
        {
            return new CurrentPanel( pSetCtrl );
        }
        SizeableVerticalPanel zPanel = new SizeableVerticalPanel().stretchableHorizontally();
        if ( pSetCtrl.getLeadingEmpties() != 0 )
        {
            zPanel.add( createHiddenPanels( pSetCtrl.getLeadingEmpties() ) );
        }
        zPanel.add( new CurrentPanel( pSetCtrl ) );
        if ( pSetCtrl.getTrailingEmpties() != 0 )
        {
            zPanel.add( createHiddenPanels( pSetCtrl.getTrailingEmpties() ) );
        }
        return zPanel;
    }

    private static class CurrentPanel extends SizeableVerticalPanel
    {
        private boolean mFirstAdded = false;

        public CurrentPanel( SetCtrl pSetCtrl )
        {
            stretchableHorizontally();
            addStyleName( "CurrentSet" );
            setVerticalAlignment( HasVerticalAlignment.ALIGN_TOP );
            for ( Widget zWidget : pSetCtrl.getViewEntryPanels() )
            {
                add( zWidget );
            }
        }

        @Override
        public void add( Widget w )
        {
            super.add( w );
            Element zElement = w.getElement();
            Element zTD = zElement.getParentElement();
            zTD.addClassName( "Row" );
            if ( !mFirstAdded )
            {
                mFirstAdded = true;
                Element zTR = zTD.getParentElement();
                zTR.addClassName( "First" );
            }
        }
    }

    private static class UserCtrlPanel extends SizeableHorizontalPanel
    {
        private UserCtrlPanel()
        {
            stretchableHorizontally();
            style( "UserCtrlPanel" );
        }

        public UserCtrlPanel with( Widget... pWidgets )
        {
            for ( Widget zWidget : pWidgets )
            {
                add( zWidget );
            }
            return this;
        }
    }

    private static class LayoutPanel extends SizeableVerticalPanel
    {

        public LayoutPanel( Widget pUserCtrlPanel )
        {
            stretchable();
            style( "LayoutCtrlPanel" );
            userCtrlPanel( pUserCtrlPanel );
        }

        public void message( String pMessage )
        {
            userCtrlPanel( new UserCtrlPanel().with( new SizeableSpacer( 1 ).stretchableHorizontally(), //
                                                     new Label( pMessage ), //
                                                     new SizeableSpacer( 1 ).stretchableHorizontally() ) );
        }

        public void userCtrlPanel( Widget pUserCtrlPanel )
        {
            clear();
            add( new SizeableSpacer( 1 ).stretchableVertically() );
            add( pUserCtrlPanel );
            add( new SizeableSpacer( 1 ).stretchableVertically() );
            relayoutFromHereDown();
        }
    }

    private OurImage image( String pNamed )
    {
        return new OurImage( "common/images/misc/" + pNamed + ".png" );
    }
}