// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.client.widgets.nonpublic;

import org.litesoft.GWT.client.widgets.*;
import org.litesoft.render.*;
import org.litesoft.uispecification.*;

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

public abstract class AbstractSizableSimplePanel extends SimplePanel implements RenderableContainer,
                                                                                GwtRenderableRect,
                                                                                SingleWidgetContainer {
    private Element mStyleElement;
    private Element mContainerElement;

    private AbstractSizableSimplePanel( DIVconstrainer pDIVconstrainer, StyleSet pStyleSet, RenderContainmentApproach pContainmentApproachX,
                                        RenderContainmentApproach pContainmentApproachY ) {
        super( pDIVconstrainer.getOuterElement() );
        StyleContainerElements zSCEs = ContainerSupport.createSCEs( pDIVconstrainer.getInnerElement(), pStyleSet );
        mStyleElement = zSCEs.getStyleElement();
        Element zContainerParentElement = zSCEs.getContainerParentElement();

        pContainmentApproachX = RenderContainmentApproach.deNull( pContainmentApproachX );
        pContainmentApproachY = RenderContainmentApproach.deNull( pContainmentApproachY );

        Overflow zCombinedOverflow = ContainerSupport.getAppropriateCombinedOverflow( pContainmentApproachX, pContainmentApproachY );
        if ( zCombinedOverflow.isScrolledOrClipped() ) {
            mContainerElement = CommonElementHelper.appendToParent( DOM.createDiv(), zContainerParentElement );
            String zOverflowClass = CommonElementHelper.determineOverflowClass( zCombinedOverflow.isClipped() );
            CommonElementHelper.setStyleClass( mContainerElement, zOverflowClass );
        } else if ( zSCEs.hasStyleElement() ) {
            mContainerElement = CommonElementHelper.appendToParent( DOM.createDiv(), zContainerParentElement );
        } else {
            mContainerElement = zContainerParentElement; // Not Stylable & Overflow == _None
        }

        mRenderHelperX = new Gwt1dContainerRenderHelperX( this, pContainmentApproachX, RenderContainerChildrenPolicy.Propogate ) {
            @Override
            protected Object[] getChildObjects() {
                return getChildren();
            }
        };
        mRenderHelperY = new Gwt1dContainerRenderHelperY( this, pContainmentApproachY, RenderContainerChildrenPolicy.Propogate ) {
            @Override
            protected Object[] getChildObjects() {
                return getChildren();
            }
        };
    }

    protected AbstractSizableSimplePanel( StyleSet pStyleSet, RenderContainmentApproach pContainmentApproachX, RenderContainmentApproach pContainmentApproachY ) {
        this( CommonElementHelper.createDIVconstrainer(), pStyleSet, pContainmentApproachX, pContainmentApproachY );
    }

    protected AbstractSizableSimplePanel( StyleSet pStyleSet, RCApair pRCApair ) {
        this( pStyleSet, RCApair.deNull( pRCApair ).getRCA_X(), RCApair.deNull( pRCApair ).getRCA_Y() );
    }

    protected AbstractSizableSimplePanel( StyleSet pStyleSet, RenderContainmentApproach pContainmentApproach ) {
        this( pStyleSet, pContainmentApproach, pContainmentApproach );
    }

    protected final RenderContainerHelper mRenderHelperX;
    protected final RenderContainerHelper mRenderHelperY;

    private Widget[] getChildren() {
        Widget zWidget = getWidget();
        return (zWidget == null) ? NO_WIDGETS : new Widget[]{zWidget};
    }

    @Override
    protected Element getStyleElement() {
        return mStyleElement;
    }

    @Override
    protected Element getContainerElement() {
        return mContainerElement;
    }

    /**
     * This method is called to attach a widget browser's document (if there are any child widgets they are
     * also attached AFTER the attached flag is set).
     * <p/>
     * This method is normally overiden, and after a call to super, "renderingParticipationChanged()" is notified.
     *
     * @see Widget#onAttach()
     */
    @Override
    public void onAttach() {
        super.onAttach();
        renderingParticipationChanged();
    }

    /**
     * This method is called to detach the widget from the browser's document (if there are any child widgets
     * they are deattached BEFORE the attached flag is set).
     * <p/>
     * This method is normally overiden, and after a call to super, "renderingParticipationChanged()" is notified.
     *
     * @see Widget#onDetach()
     */
    @Override
    public void onDetach() {
        super.onDetach();
        renderingParticipationChanged();
    }

    /**
     * Sets whether this object is visible - normally overiden from "UIObject" so that "renderingParticipationChanged()" can be notified.
     *
     * @param pVisible <code>true</code> to show the object, <code>false</code>
     *                 to hide it
     */
    @Override
    public void setVisible( boolean pVisible ) {
        if ( isVisible() != pVisible ) {
            super.setVisible( pVisible );
            renderingParticipationChanged();
        }
    }

    /**
     * Sets the widget's width, overiding the method in "UIObject". Unlike the standard GWT "UIObject" method, the
     * pWidth is "assumed" to include ALL decorations (such as border, margin, and padding).  This means that a
     * subsequent call to "getOffsetWidth()" will "eventually" return the value "set"!
     * <p/>
     * This method is normally delegated to the 'X' RenderHelper
     *
     * @param pWidth the Widget's new width, in CSS px (e.g. "10")
     */
    @Override
    public void setWidth( String pWidth ) {
        Parse.andSetSize( getRenderHelperX(), pWidth );
    }

    /**
     * Sets the widget's width, unlike the standard GWT "UIObject" method, this pWidth is "assumed" to include ALL
     * decorations (such as border, margin, and padding).  This means that a subsequent call to "getOffsetWidth()"
     * will "eventually" return the value "set"!
     * <p/>
     * This method is used by the 'X' RenderHelper via the GwtRenderDimensionAdapterX to bypass the normal delegation
     * on "setWidth()" to the 'X' RenderHelper.
     *
     * @param pWidth the Widget's new width, in CSS px (e.g. "10")
     */
    @Override
    public void LLsetWidgetWidth( int pWidth ) {
        Size.set( this, GwtElementDimensionHelperX.INSTANCE, getContainerElement(), pWidth, getDecorationSizeX() );
    }

    /**
     * Remove the Widget's width, after this call subsequent calls to "getOffsetWidth()" will "eventually" return the
     * "natural" width of the Widget!
     */
    @Override
    public void clearWidth() {
        Size.clear( this, GwtElementDimensionHelperX.INSTANCE, getContainerElement() );
    }

    /**
     * Sets the widget's height, overiding the method in "UIObject". Unlike the standard GWT "UIObject" method, this
     * pHeight is "assumed" to include ALL decorations (such as border, margin, and padding).  This means that a
     * subsequent call to "getOffsetHeight()" will "eventually" return the value "set"!
     * <p/>
     * This method is normally delegated to the 'Y' RenderHelper
     *
     * @param pHeight the Widget's new height, in CSS px (e.g. "10")
     */
    @Override
    public void setHeight( String pHeight ) {
        Parse.andSetSize( getRenderHelperY(), pHeight );
    }

    /**
     * Sets the widget's height, unlike the standard GWT "UIObject" method, this pHeight is "assumed" to include ALL
     * decorations (such as border, margin, and padding).  This means that a subsequent call to "getOffsetHeight()"
     * will "eventually" return the value "set"!
     * <p/>
     * This method is used by the 'Y' RenderHelper via the GwtRenderDimensionAdapterY to bypass the normal delegation
     * on "setHeight()" to the 'Y' RenderHelper.
     *
     * @param pHeight the Widget's new height, in CSS px (e.g. "10")
     */
    @Override
    public void LLsetWidgetHeight( int pHeight ) {
        Size.set( this, GwtElementDimensionHelperY.INSTANCE, getContainerElement(), pHeight, getDecorationSizeY() );
    }

    /**
     * Remove the Widget's height, after this call subsequent calls to "getOffsetHeight()" will "eventually" return the
     * "natural" height of the Widget!
     */
    @Override
    public void clearHeight() {
        Size.clear( this, GwtElementDimensionHelperY.INSTANCE, getContainerElement() );
    }

    @Override
    public void renderingParticipationChanged() {
        RenderingParticipationChangedHelper.participationChanged( this, getWidget() );
    }

    @Override
    public RenderHelper getRenderHelperX() {
        return mRenderHelperX;
    }

    @Override
    public RenderHelper getRenderHelperY() {
        return mRenderHelperY;
    }

    /**
     * Get a Container's Decoration (or Overhead) Size in the 'X' dimension - the difference between the outside size and the inside size (what is available
     * for child widgets)
     * <p/>
     * Note: this will NOT be called until the Container is reporting proper sizes!
     */
    @Override
    public int getDecorationSizeX() {
        return DecorationSize.calculate( this, GwtElementDimensionHelperX.INSTANCE, //
                                         getElement(), getContainerElement() );
    }

    /**
     * Get a Container's Decoration (or Overhead) Size in the 'Y' dimension - the difference between the outside size and the inside size (what is available
     * for child widgets)
     * <p/>
     * Note: this will NOT be called until the Container is reporting proper sizes!
     */
    @Override
    public int getDecorationSizeY() {
        return DecorationSize.calculate( this, GwtElementDimensionHelperY.INSTANCE, //
                                         getElement(), getContainerElement() );
    }

    @Override
    public void relayout() {
        getRenderHelperX().layout();
        getRenderHelperY().layout();
    }
}