package org.litesoft.GWT.client.widgets.nonpublic;

import java.util.*;

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

/**
 * To be used in conjunction with AbstractSizeableWidget
 */
public class AbstractSizeableHelper extends CommonElementHelper
{
    private static OuterSandwichHelper sOSH = (OuterSandwichHelper) GWT.create( OuterSandwichHelper.class );

    private AbstractSizeableWidget mOurUIObject;
    private boolean mHidden;
    private Element mOuterElement;
    private Element mStyleElement;
    private Element mInnerElement;
    private Element mFieldSetLegend = null;
    private Size_1DHelper mWidthHelper = new WidthHelper();
    private Size_1DHelper mHeightHelper = new HeightHelper();
    private static final String INNER_CONSTRAINER = "LayoutMinSizeConstrainer";
    private static final String OUTER_CONSTRAINER = "LayoutDivConstrainer";

    public AbstractSizeableHelper( AbstractSizeableWidget pOurUIObject )
    {
        // ***** may NOT do anything with the UiObject here, as it is not fully initialized yet!!!!!
        mOurUIObject = pOurUIObject;
    }

    public boolean isOverflowHidden()
    {
        return mHidden;
    }

    public Element getOuterElement()
    {
        return mOuterElement;
    }

    public Element getStyleElement()
    {
        return mStyleElement;
    }

    public Element getInnerElement()
    {
        return mInnerElement;
    }

    public void setInnerElement( Element pInnerElement )
    {
        mInnerElement = pInnerElement;
    }

    public Element getFieldSetLegend()
    {
        return mFieldSetLegend;
    }

    public void setUpSpecialPart1( Element pDivSizeTable, Element pDiv, Element pInnerElement )
    {
        mOuterElement = pDivSizeTable;
        mStyleElement = pDiv;
        mInnerElement = pInnerElement;
    }

    /**
     * @param pHidden true == Hidden / false == auto
     */
    public String setUpSpecialPart2( boolean pHidden )
    {
        return determineOverflowClass( mHidden = pHidden );
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return pInnerElement
     */
    public Element create_OeTable_SeDiv_IeGraph( boolean pHidden, Element pGraphRoot, Element pInnerElement )
    {
        mStyleElement = appendChild( createDiv( pHidden ), pGraphRoot );
        mOuterElement = createTableDivConstrainer( mStyleElement );
        return mInnerElement = pInnerElement;
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return Div
     */
    public Element create_OeTable_SeDiv( boolean pHidden )
    {
        mStyleElement = createDiv( pHidden );
        mOuterElement = createTableDivConstrainer( mStyleElement );
        return mStyleElement;
    }

    /**
     * @return Div
     */
    public Element create_OeSeIeOverflowHiddenSingleDivSandwich()
    {
        return mOuterElement = mStyleElement = mInnerElement = createDiv( true );
    }

    /**
     * @return TBody
     */
    public Element create_OeSeIeOverflowHiddenCommonDiv_TableToTBody()
    {
        Element rv = DOM.createTBody();
        appendChild( create_OeSeIeOverflowHiddenSingleDivSandwich(), //
                     createMinSizeConstrainingTableToTBody( rv ) );
        return rv;
    }

    /**
     * @return TBody
     */
    public Element create_OeTable_SeIeTBody()
    {
        mHidden = true;
        Element rv = mStyleElement = mInnerElement = DOM.createTBody();
        mOuterElement = createMinSizeConstrainingTableToTBody( rv );
        return rv;
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return Div
     */
    public Element create_OeTable_SeDiv_IeDiv( boolean pHidden )
    {
        return create_OeTable_SeStyle_IeDiv( createDiv( pHidden ) );
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return Div
     */
    public Element create_OeTable_SeFieldSet_IeDiv( boolean pHidden, String pTitle )
    {
        return create_OeTable_SeStyle_IeDiv( createFieldSet( pHidden, pTitle ) );
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return TR
     */
    public Element create_OeWidget_SeDiv_IeTableToTR( boolean pHidden )
    {
        return create_OeWidget_SeStyle_IeTableToTR( createDiv( pHidden ) );
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return TR
     */
    public Element create_OeWidget_SeFieldSet_IeTableToTR( boolean pHidden, String pTitle )
    {
        return create_OeWidget_SeStyle_IeTableToTR( createFieldSet( pHidden, pTitle ) );
    }

    /**
     * @return TR
     */
    private Element create_OeWidget_SeStyle_IeTableToTR( Element pStyleElement )
    {
        Element rv = DOM.createTR();
        create_OeWidget_SeStyle_IeInner( pStyleElement, createMinSizeConstrainingTableToTR( rv ) );
        return rv;
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return TBody
     */
    public Element create_OeWidget_SeDiv_IeTableToTBody( boolean pHidden )
    {
        return create_OeWidget_SeStyle_IeTableToTBody( createDiv( pHidden ) );
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return TBody
     */
    public Element create_OeWidget_SeFieldSet_IeTableToTBody( boolean pHidden, String pTitle )
    {
        return create_OeWidget_SeStyle_IeTableToTBody( createFieldSet( pHidden, pTitle ) );
    }

    /**
     * @return TBody
     */
    private Element create_OeWidget_SeStyle_IeTableToTBody( Element pStyleElement )
    {
        Element rv = DOM.createTBody();
        create_OeWidget_SeStyle_IeInner( pStyleElement, createMinSizeConstrainingTableToTBody( rv ) );
        return rv;
    }

    private void create_OeWidget_SeStyle_IeInner( Element pStyleElement, Element pInnerElement )
    {
        mInnerElement = pInnerElement;
        mStyleElement = appendChild( pStyleElement, mInnerElement );
        mOuterElement = createOuterConstrainer( mStyleElement );
    }

    /**
     * @return Outer Widget
     */
    private Element createOuterConstrainer( Element pStyleElement )
    {
        Element[] zElements = sOSH.create( OUTER_CONSTRAINER );
        appendChild( zElements[1], pStyleElement );
        return zElements[0];
    }

    /**
     * @return Div
     */
    private Element create_OeTable_SeStyle_IeDiv( Element pStyleElement )
    {
        mInnerElement = DOM.createDiv();
        mStyleElement = pStyleElement;
        mOuterElement = createTableDivConstrainer( appendChild( mStyleElement, mInnerElement ) );
        return mInnerElement;
    }

    /**
     * @return Table
     */
    private Element createMinSizeConstrainingTableToTR( Element pTR )
    {
        return createMinSizeConstrainingTableToTBody( appendChild( DOM.createTBody(), pTR ) );
    }

    /**
     * @return Table
     */
    private Element createMinSizeConstrainingTableToTBody( Element pTBody )
    {
        return appendChild( createMinSizeConstrainingTable(), pTBody );
    }

    /**
     * @return Table
     */
    public static Element createMinSizeConstrainingTable()
    {
        return createTable( INNER_CONSTRAINER );
    }

    /**
     * @return Table
     */
    public static Element createLayoutDivConstrainingTable()
    {
        return createTable( OUTER_CONSTRAINER );
    }

    /**
     * @return Div
     */
    public static Element createLayoutDivConstrainingDiv()
    {
        return createDiv( OUTER_CONSTRAINER );
    }

    /**
     * @return Table
     */
    private Element createTableDivConstrainer( Element pDiv )
    {
        Element zTable = createLayoutDivConstrainingTable();
        appendChild( finishTableNgetTD( zTable ), pDiv );
        return zTable;
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return Div
     */
    private Element createDiv( boolean pHidden )
    {
        return setOverflowClass( DOM.createDiv(), mHidden = pHidden );
    }

    /**
     * @param pHidden true == Hidden / false == auto
     *
     * @return FieldSet
     */
    private Element createFieldSet( boolean pHidden, String pLegend )
    {
        Element zFieldSet = setOverflowClass( DOM.createFieldSet(), mHidden = pHidden );
        if ( null != (pLegend = UtilsGwt.noEmpty( pLegend )) )
        {
            mFieldSetLegend = DOM.createLegend();
            DOM.appendChild( zFieldSet, mFieldSetLegend );
            DOM.setInnerText( mFieldSetLegend, pLegend );
        }
        return zFieldSet;
    }

    public ISizeableDimensionHelper getWidthHelper()
    {
        return mWidthHelper;
    }

    public ISizeableDimensionHelper getHeightHelper()
    {
        return mHeightHelper;
    }

    public int distributeDimensionOnChildren( IndexedPanel pIndexedPanel,
                                              ISizeableDimensionHelper pDimensionHelper )
    {
        ChildCollector collector = new ChildCollector();
        boolean anyToProcess = collector.process( pIndexedPanel, pDimensionHelper );
        int newSize = collector.getNewSize();
        if ( anyToProcess )
        {
            List<ISizeableDimensionHelper> adjustables = new ArrayList<ISizeableDimensionHelper>();
            List<ChildStructure> zChildStructures = collector.getChildStructures();
            for ( ChildStructure zChildStructure : zChildStructures )
            {
                ISizeableDimensionHelper zChildHelper = zChildStructure.getHelper();
                int zChildCurSize = zChildStructure.getCurSize();
                if ( zChildHelper.isStretchable() )
                {
                    //noinspection unchecked
                    adjustables.add( zChildHelper );
                }
                else
                {
                    zChildHelper.setDimension( zChildCurSize ); // Propagate Sizing...
                }
            }
            while ( !adjustables.isEmpty() )
            {
                int delta = deltaPerAdjustable( adjustables.size(), newSize );
                ISizeableDimensionHelper zChildHelper = adjustables.remove( 0 );
                int curSize = zChildHelper.getDimension();
                zChildHelper.setDimension( curSize + delta );
                int adjustedNewSize = zChildHelper.getDimension();
                newSize -= adjustedNewSize - curSize;
            }
        }
        return newSize;
    }

    public int distributeDimensionToChild( IndexedPanel pIndexedPanel,
                                           ISizeableDimensionHelper pDimensionHelper, Widget pWidgetToAdjust )
    {
        ChildCollector collector = new ChildCollector();
        boolean anyToProcess = collector.process( pIndexedPanel, pDimensionHelper );
        int newSize = collector.getNewSize();
        if ( anyToProcess )
        {
            ISizeableDimensionHelper zChildHelperToBeAdjusted = null;
            List<ChildStructure> zChildStructures = collector.getChildStructures();
            for ( ChildStructure zChildStructure : zChildStructures )
            {
                ISizeableDimensionHelper zChildHelper = zChildStructure.getHelper();
                int zChildCurSize = zChildStructure.getCurSize();
                if ( zChildStructure.getWidget() == pWidgetToAdjust )
                {
                    zChildHelperToBeAdjusted = zChildHelper;
                }
                else
                {
                    zChildHelper.setDimension( zChildCurSize ); // Propagate Sizing...
                }
            }
            if ( zChildHelperToBeAdjusted != null )
            {
                int delta = deltaPerAdjustable( 1, newSize );
                int curSize = zChildHelperToBeAdjusted.getDimension();
                zChildHelperToBeAdjusted.setDimension( curSize + delta );
                int adjustedNewSize = zChildHelperToBeAdjusted.getDimension();
                newSize -= adjustedNewSize - curSize;
            }
            if ( newSize != 0 )
            {
                newSize = distributeDimensionOnChildren( pIndexedPanel, pDimensionHelper );
            }
        }
        return newSize;
    }

    public int applyChangedDimensionToChild( Widget pChildWidget, ISizeableDimensionHelper pDimensionHelper )
    {
        Size_1DHelper zDimHelper = (Size_1DHelper) pDimensionHelper;
        int newSize = zDimHelper.getOurInnerSizeWithAllowanceForScrollBars();
        if ( zDimHelper.isAdjustmentsDetermined() )
        {
            ISizeableWidget zSizeableWidget = getVisableSizeableWidget( pChildWidget );
            if ( zSizeableWidget != null )
            {
                ISizeableDimensionHelper zChildHelper = zDimHelper.getAppropriateManager( zSizeableWidget );
                if ( zChildHelper.isStretchable() )
                {
                    zChildHelper.setDimension( pChildWidget, newSize );
                }
            }
        }
        return newSize;
    }

    public void applyChangedDimensionToChildren( IndexedPanel pIndexedPanel,
                                                 ISizeableDimensionHelper pDimensionHelper )
    {
        Size_1DHelper zDimHelper = (Size_1DHelper) pDimensionHelper;
        int newSize = zDimHelper.getOurInnerSizeWithAllowanceForScrollBars();
        setDimensionOnChildren( pIndexedPanel, zDimHelper, newSize );
    }

    public void forceAdjustDimensionOnChild( Widget pWidget, ISizeableDimensionHelper pDimensionHelper )
    {
        Size_1DHelper zDimHelper = (Size_1DHelper) pDimensionHelper;
        int newSize = zDimHelper.getOurInnerSizeWithAllowanceForScrollBars();
        zDimHelper.setDimension( pWidget, newSize );
    }

    public void forceAdjustDimensionOnChild( Element pElement, ISizeableDimensionHelper pDimensionHelper )
    {
        Size_1DHelper zDimHelper = (Size_1DHelper) pDimensionHelper;
        int newSize = zDimHelper.getOurInnerSizeWithAllowanceForScrollBars();
        zDimHelper.setStyleDimension( pElement, newSize );
    }

    public void setDimensionOnChildren( IndexedPanel pIndexedPanel, ISizeableDimensionHelper pDimensionHelper,
                                        int pNewSize )
    {
        Size_1DHelper zDimHelper = (Size_1DHelper) pDimensionHelper;
        setDimensionOnChildren( pIndexedPanel, zDimHelper, pNewSize );
    }

    private void setDimensionOnChildren( IndexedPanel pIndexedPanel, Size_1DHelper pDimHelper, int pNewSize )
    {
        int wc = pIndexedPanel.getWidgetCount();
        if ( (pNewSize > 0) && (wc != 0) )
        {
            for ( int i = 0; i < wc; i++ )
            {
                Widget zChildWidget = pIndexedPanel.getWidget( i );
                ISizeableWidget zSizeableWidget = getVisableSizeableWidget( zChildWidget );
                if ( zSizeableWidget != null )
                {
                    ISizeableDimensionHelper zChildHelper =
                            pDimHelper.getAppropriateManager( zSizeableWidget );
                    if ( zChildHelper.isStretchable() )
                    {
                        zChildHelper.setDimension( zChildWidget, pNewSize );
                    }
                }
            }
        }
    }

    private static ISizeableWidget getVisableSizeableWidget( Widget pWidget )
    {
        return (pWidget instanceof ISizeableWidget) && pWidget.isVisible() ? // Order does Null Check
               (ISizeableWidget) pWidget : null;
    }

    private static int deltaPerAdjustable( int pAdjustables, int pDelta )
    {
        if ( (pAdjustables == 0) || (pDelta == 0) )
        {
            return 0;
        }
        if ( pAdjustables == 1 )
        {
            return pDelta;
        }
        return ((pDelta < 0) ? pDelta - (pAdjustables - 1) : pDelta + (pAdjustables - 1)) / pAdjustables;
    }

    private class WidthHelper extends Size_1DHelper
    {
        public WidthHelper()
        {
            super( WidthDimensionHelper.INSTANCE );
        }

        protected ISizeableDimensionHelper getAppropriateManager( ISizeableWidget pSizeableWidget )
        {
            return pSizeableWidget.getWidthHelper();
        }

        public boolean setPrefferredDimension()
        {
            return mOurUIObject.setPrefferredWidth();
        }

        public boolean adjustSizeBy( int pDelta )
        {
            return mOurUIObject.adjustWidthBy( pDelta );
        }

        public void distributeToChildrenChangedDimension()
        {
            mOurUIObject.distributeToChildrenChangedWidth();
        }
    }

    private class HeightHelper extends Size_1DHelper
    {
        public HeightHelper()
        {
            super( HeightDimensionHelper.INSTANCE );
        }

        protected ISizeableDimensionHelper getAppropriateManager( ISizeableWidget pSizeableWidget )
        {
            return pSizeableWidget.getHeightHelper();
        }

        public boolean setPrefferredDimension()
        {
            return mOurUIObject.setPrefferredHeight();
        }

        public boolean adjustSizeBy( int pDelta )
        {
            return mOurUIObject.adjustHeightBy( pDelta );
        }

        public void distributeToChildrenChangedDimension()
        {
            mOurUIObject.distributeToChildrenChangedHeight();
        }
    }

    private abstract class Size_1DHelper implements ISizeableDimensionHelper
    {
        protected boolean mStretchable = false;
        private IDimensionHelper mDimensionHelper;

        protected Size_1DHelper( IDimensionHelper pDimensionHelper )
        {
            mDimensionHelper = pDimensionHelper;
        }

        public boolean isStretchable()
        {
            return mStretchable;
        }

        public void setStretchable( boolean pNewValue )
        {
            mStretchable = pNewValue;
        }

        public int getDimension()
        {
            return getDimension( mOurUIObject );
        }

        public int getDimensionMaxShrinkability()
        {
            return getOurInnerSize();
        }

        public int getDecorationSize()
        {
            return mDecorationSize;
        }

        public void deligateSetDimensionFromWidget( int pDimension )
        {
            if ( setSizeableOuterIntDimension( pDimension ) )
            {
                mOurUIObject.resized();
                distributeToChildrenChangedDimension();
            }
        }

        public void contentChangedResizeToParent()
        {
            if ( isStretchable() )
            {
                ISizeableWidget zParentWidget = getVisableSizeableWidget( mOurUIObject.getParent() );
                if ( zParentWidget != null )
                {
                    ISizeableDimensionHelper zParentHelper = getAppropriateManager( zParentWidget );
                    int newSize = zParentHelper.getDimension() - zParentHelper.getDecorationSize();
                    setDimension( newSize );
                }
            }
        }

        public String getWhat()
        {
            return mDimensionHelper.getWhat();
        }

        public boolean isAdjustable()
        {
            return mDimensionHelper.isAdjustable();
        }

        public int getPosition( Widget pWidget )
        {
            return mDimensionHelper.getPosition( pWidget );
        }

        public int getPosition( Element pElement )
        {
            return mDimensionHelper.getPosition( pElement );
        }

        public void setStyleDimension( Element pElement, int pDimension )
        {
            mDimensionHelper.setStyleDimension( pElement, pDimension );
        }

        public int getDimension( Element pElement )
        {
            return mDimensionHelper.getDimension( pElement );
        }

        public void setDimension( Widget pWidget, int pDimension )
        {
            mDimensionHelper.setDimension( pWidget, pDimension );
        }

        public int getDimension( Widget pWidget )
        {
            return mDimensionHelper.getDimension( pWidget );
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////

        abstract public void distributeToChildrenChangedDimension();

        abstract protected ISizeableDimensionHelper getAppropriateManager( ISizeableWidget pSizeableWidget );

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////

        public boolean isAdjustmentsDetermined()
        {
            return mAdjustmentsDetermined;
        }

        private int getOurInnerSize()
        {
            int size = getDimension( mOuterElement );
            size -= mDecorationSize;
            return size;
        }

        private boolean setSizeableOuterIntDimension( int pDimension )
        {
            //System.out.println( GWT.getTypeName( mOurUIObject ) + "{" + mOurUIObject.hashCode() + "} " +
            //                    getWhat() + " to " + pDimension );
            if ( (pDimension > 0) && determineAdjustments() )
            {
                int size = pDimension + mAdjustDimensionBy;
                if ( 0 <= size )
                {
                    setStyleDimension( mStyleElement, size );
                    return true;
                }
            }
            return false;
        }

        private int getOurInnerSizeWithAllowanceForScrollBars()
        {
            int size = getOurInnerSize();
            return mHidden ? size : size - 20;
        }

        public void setDimension( int pDimension )
        {
            setDimension( mOurUIObject, pDimension );
        }

        private boolean mAdjustmentsDetermined = false;
        private int mAdjustDimensionBy = 0;
        private int mDecorationSize = 0;

        private boolean determineAdjustments()
        {
            if ( mAdjustmentsDetermined )
            {
                return true;
            }
            if ( !mOurUIObject.isVisible() )
            {
                return false;
            }
            int dimOuter = getDimension( mOuterElement );
            int dimInner = getDimension( mInnerElement );
            mDecorationSize = dimOuter - dimInner;
            if ( mDecorationSize != 0 )
            {
                // Now determine if the Decoration is inside or outside of the set"Dimension" on the Style Element
                Element element = mStyleElement;
                setStyleDimension( element, dimOuter );
                int postSet_dimension = getDimension( mOuterElement );
                if ( dimOuter == postSet_dimension ) // IE - growth (margins/borders/padding) is inside
                { // . . . . . . . . . . . . . . . . . . . . . . . . . . or there is NO Growth
                    mAdjustDimensionBy = 0;
                }
                else // Firefox - growth (margins/borders/padding) is outside
                {
                    mAdjustDimensionBy = dimOuter - postSet_dimension;
                    setStyleDimension( element, dimOuter + mAdjustDimensionBy ); // put it back
                    if ( dimOuter != getDimension( mOuterElement ) )
                    {
                        System.err.println(
                                "Adjustment by " + mAdjustDimensionBy + " did NOT restore the " + getWhat() );
                    }
                }
//            String msg = "Set" + getWhat() + "( " + pDimension + " ) adjustments on:" + //
//                         "   " + GWT.getTypeName( mOurUIObject ) + ":" + //
//                         "      " + mInnerAdjustDimension + " <inner | outer> " + mOuterAdjustDimension;
//            System.out.println( msg );
            }
            return mAdjustmentsDetermined = true;
        }
    }

    /**
     * @noinspection UnusedDeclaration
     */
    private void sout( String pPrefix, Element pElement )
    {
        String s = pElement.toString();
        String toFind = "class=";
        int at = s.indexOf( toFind );
        if ( at != -1 )
        {
            String t = s.substring( at + toFind.length() );
            if ( t.startsWith( toFind = "\"" ) )
            {
                t = t.substring( 1 );
            }
            else
            {
                toFind = " ";
            }
            if ( -1 != (at = t.indexOf( toFind )) )
            {
                s = t.substring( 0, at );
            }
        }
        System.out.println( pPrefix + ": " + s );
    }

    /**
     * @noinspection UnusedDeclaration
     */
    private void sout( String pPrefix, Widget pWidget )
    {
        String s = pWidget.toString();
        String toFind = "\n";
        int at = s.indexOf( toFind );
        if ( at != -1 )
        {
            s = s.substring( 0, at ).trim();
        }
        System.out.println( pPrefix + ": " + s );
    }

    private static class ChildCollector
    {
        private int mNewSize = 0;
        private List<ChildStructure> mChildStructures = Collections.emptyList();

        public boolean process( IndexedPanel pIndexedPanel, ISizeableDimensionHelper pDimensionHelper )
        {
            Size_1DHelper zDimHelper = (Size_1DHelper) pDimensionHelper;
            mNewSize = zDimHelper.getOurInnerSizeWithAllowanceForScrollBars();
            int wc = pIndexedPanel.getWidgetCount();
            if ( (mNewSize == 0) || (wc == 0) )
            {
                return false;
            }
            for ( int i = 0; i < wc; i++ )
            {
                Widget zChildWidget = pIndexedPanel.getWidget( i );
                int zChildCurSize = zDimHelper.getDimension( zChildWidget );
                //noinspection UnnecessaryLocalVariable
                int zChildStyledSize = zDimHelper.getDimension( DOM.getParent( zChildWidget.getElement() ) );
                mNewSize -= zChildStyledSize;
                ISizeableWidget zSizeableWidget = getVisableSizeableWidget( zChildWidget );
                if ( zSizeableWidget != null )
                {
                    if ( mChildStructures.isEmpty() )
                    {
                        mChildStructures = new ArrayList<ChildStructure>();
                    }
                    ISizeableDimensionHelper zChildHelper =
                            zDimHelper.getAppropriateManager( zSizeableWidget );
                    mChildStructures.add( new ChildStructure( zChildWidget, zChildCurSize, zChildHelper ) );
                }
            }
            return !mChildStructures.isEmpty();
        }

        public int getNewSize()
        {
            return mNewSize;
        }

        public List<ChildStructure> getChildStructures()
        {
            return mChildStructures;
        }
    }

    private static class ChildStructure
    {
        private Widget mWidget;
        private int mCurSize;
        private ISizeableDimensionHelper mHelper;

        public ChildStructure( Widget pWidget, int pCurSize, ISizeableDimensionHelper pHelper )
        {
            mWidget = pWidget;
            mCurSize = pCurSize;
            mHelper = pHelper;
        }

        public Widget getWidget()
        {
            return mWidget;
        }

        public int getCurSize()
        {
            return mCurSize;
        }

        public ISizeableDimensionHelper getHelper()
        {
            return mHelper;
        }
    }
}