// 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.commonfoundation.typeutils.*;
import org.litesoft.logger.*;
import org.litesoft.render.*;
import org.litesoft.uispecification.*;

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

public interface GwtRenderableRect extends RenderableRect
{
    public static final Logger LOGGER = LoggerFactory.getLogger( GwtRenderableRect.class );

    public static final Widget[] NO_WIDGETS = new Widget[0];

    /**
     * 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()
     */
    public void onAttach();

    /**
     * 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()
     */
    public void onDetach();

    /**
     * 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
     */
    public void setVisible( boolean pVisible );

    /**
     * Gets the Widget's offset width in pixels (not normally overiden from "UIObject"). This is the total width of the
     * Widget, including decorations such as border, margin, and padding.
     *
     * @return the Widget's offset width
     */
    public int getOffsetWidth();

    /**
     * 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")
     */
    public void setWidth( String 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")
     */
    public void LLsetWidgetWidth( int pWidth );

    /**
     * Remove the Widget's width, after this call subsequent calls to "getOffsetWidth()" will "eventually" return the
     * "natural" width of the Widget!
     */
    public void clearWidth();

    /**
     * Gets the Widget's offset height in pixels (not normally overiden from "UIObject"). This is the total height of the
     * Widget, including decorations such as border, margin, and padding.
     *
     * @return the Widget's offset height
     */
    public int getOffsetHeight();

    /**
     * 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")
     */
    public void setHeight( String 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")
     */
    public void LLsetWidgetHeight( int pHeight );

    /**
     * Remove the Widget's height, after this call subsequent calls to "getOffsetHeight()" will "eventually" return the
     * "natural" height of the Widget!
     */
    public void clearHeight();

    public static final GwtRenderableRect NULL_GRR = new NullGwtRenderableRect();

    public static class NullGwtRenderableRect extends NullRenderableRect implements GwtRenderableRect
    {
        @Override
        public void onAttach()
        {
            throw whatThe( "onAttach" );
        }

        @Override
        public void onDetach()
        {
            throw whatThe( "onDetach" );
        }

        @Override
        public void setVisible( boolean pVisible )
        {
            throw whatThe( "setVisible", Boolean.toString( pVisible ) );
        }

        @Override
        public int getOffsetWidth()
        {
            return 0;
        }

        @Override
        public void setWidth( String pWidth )
        {
            throw whatThe( "setWidth", pWidth );
        }

        @Override
        public void LLsetWidgetWidth( int pWidth )
        {
            throw whatThe( "LLsetWidgetWidth", pWidth );
        }

        @Override
        public void clearWidth()
        {
        }

        @Override
        public int getOffsetHeight()
        {
            return 0;
        }

        @Override
        public void setHeight( String pHeight )
        {
            throw whatThe( "setHeight", pHeight );
        }

        @Override
        public void LLsetWidgetHeight( int pHeight )
        {
            throw whatThe( "LLsetWidgetHeight", pHeight );
        }

        @Override
        public void clearHeight()
        {
        }
    }

    public static class Parse
    {
        public static Integer size( String pSize )
                throws NumberFormatException
        {
            String cleaned = Strings.deNull( pSize ).trim();
            if ( cleaned.length() == 0 )
            {
                return null;
            }
            String toParse = "0" + cleaned;
            if ( toParse.endsWith( "px" ) )
            {
                toParse = toParse.substring( 0, toParse.length() - 2 );
            }
            return Integer.parseInt( toParse );
        }

        public static void andSetSize( final RenderHelper pRenderHelper, String pSize )
        {
            Integer zInteger;
            try
            {
                zInteger = size( pSize );
            }
            catch ( NumberFormatException e )
            {
                LOGGER.error.log( e, pRenderHelper, " setSize( ", pSize, " )" );
                return;
            }
            if ( zInteger != null )
            {
                pRenderHelper.setSize( zInteger );
            }
        }
    }

    public static class Size
    {
        public static void set( Widget pOnWidget, GwtElementDimensionHelper pDimensionHelper, Element pContainerElement, int pNewSize, int pDecorationSize )
        {
            if ( LOGGER.trace.isEnabled() )
            {
                LOGGER.trace.log( "Size.set ", pDimensionHelper.getWhat(), " on ", pOnWidget.getClass(), " NewSize= " + pNewSize, //
                                  " DecorationSize= " + pDecorationSize, //
                                  " -> " + (pNewSize - pDecorationSize) );
            }
            set( pOnWidget, pDimensionHelper, pContainerElement, pNewSize - pDecorationSize );
        }

        @SuppressWarnings({"UnusedDeclaration"})
        public static void set( Widget pOnWidget, GwtElementDimensionHelper pDimensionHelper, Element pSizingElement, int pNewSize )
        {
            pDimensionHelper.setStyleDimension( pSizingElement, pNewSize );
        }

        @SuppressWarnings({"UnusedDeclaration"})
        public static void clear( Widget pOnWidget, GwtElementDimensionHelper pDimensionHelper, Element pSizingElement )
        {
            pDimensionHelper.removeStyleDimension( pSizingElement );
        }
    }

    public static class DecorationSize
    {
        @SuppressWarnings({"UnusedDeclaration"})
        public static int calculate( Widget pOnWidget, GwtElementDimensionHelper pDimensionHelper, Element pOuterElement, Element pContainerElement )
        {
            int zOuterDim = pDimensionHelper.getOffsetDimension( pOuterElement );
            int zContainerDim = pDimensionHelper.getOffsetDimension( pContainerElement );
            return zOuterDim - zContainerDim;
        }
    }

    public static class ContainerSupport
    {
        public static StyleContainerElements createSCEs( Element pStyleParentElement, StyleSet pStyleSet )
        {
            return (pStyleSet == null) ? //
                   new StyleContainerElements( pStyleParentElement ) : new StyleContainerElements( CommonElementHelper.appendToParent( pStyleSet.getOuterElement(), pStyleParentElement ), pStyleSet.getInnerElement() );
        }

        public static Overflow getAppropriateCombinedOverflow( RenderContainmentApproach pContainmentApproachX, RenderContainmentApproach pContainmentApproachY )
        {
            return pContainmentApproachX.getOverflow().mergeWith( pContainmentApproachY.getOverflow() );
        }

        public static Widget[] toArray( WidgetCollection pCollection )
        {
            int zSize = pCollection.size();
            if ( zSize == 0 )
            {
                return NO_WIDGETS;
            }
            Widget[] rv = new Widget[zSize];
            for ( int i = 0; i < zSize; i++ )
            {
                rv[i] = pCollection.get( i );
            }
            return rv;
        }
    }
}