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

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

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

public class SizeableQBEboxedPanel extends AbstractSizeableSimplePanel {
    private static final String STYLE = "NineCeller";

    public static final int STANDARD_SIZE = 11;
    public static final int LEFT_WIDTH = 36;

    private static final String QBEPOPUP_POINTER = "common/images/QBEpopup/pointer.gif";
    private static final int POINTER_HEIGHT = 32;
    private static final int POINTER_WIDTH = 27;

    private Element mPointer;
    private int mAt = 0;
    private boolean mShowingPointer = true;

    public SizeableQBEboxedPanel() {
        mPointer = createPointer();
        Element zGraphRoot = CommonElementHelper.createTable();
        Element zTBody = CommonElementHelper.appendToParent( DOM.createTBody(), zGraphRoot );
        addRow( zTBody, CompassPoint.NW, CompassPoint.N, CompassPoint.NE );
        Element zInnerElement = addRow( zTBody, CompassPoint.W, mPointer, CompassPoint.center, null, CompassPoint.E, createTransparentImg( STANDARD_SIZE ) );
        addRow( zTBody, CompassPoint.SW, CompassPoint.S, CompassPoint.SE );
        initializeElements( getHelper().create_OeTable_SeDiv_IeGraph( true, zGraphRoot, zInnerElement ), "LayoutSizeableQBEpopupPanel" );
        addStyleName( STYLE );
        show( false );
    }

    public SizeableQBEboxedPanel( Widget pWidget ) {
        this();
        setWidget( pWidget );
    }

    public SizeableQBEboxedPanel style( String pStyleName ) {
        addStyleName( pStyleName );
        return this;
    }

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

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

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

    @Override
    public void setWidget( Widget pWidget ) {
        Widget zWidget = getWidget();
        if ( zWidget == null ) {
            super.setWidget( pWidget );
        } else {
            int zWidth = zWidget.getOffsetWidth();
            int zHeight = zWidget.getOffsetHeight();
            super.setWidget( pWidget );
            pWidget.setWidth( "" + zWidth );
            pWidget.setHeight( "" + zHeight );
        }
    }

    public void show( boolean pShow ) {
        UtilsGwt.setHidden( this, !pShow );
        CommonElementHelper.setHidden( mPointer, !pShow );
    }

    public boolean isPointerShowing() {
        return mShowingPointer;
    }

    public int getPointsAt() {
        return mAt + (POINTER_HEIGHT / 2);
    }

    public void pointTo( Widget pWidget ) {
        pointTo( pWidget, HasVerticalAlignment.ALIGN_MIDDLE );
    }

    public void pointTo( Widget pWidget, HasVerticalAlignment.VerticalAlignmentConstant pValign ) {
        pointTo( pWidget.getElement(), pValign );
    }

    public void pointTo( Element pElement ) {
        pointTo( pElement, HasVerticalAlignment.ALIGN_MIDDLE );
    }

    public void pointTo( Element pElement, HasVerticalAlignment.VerticalAlignmentConstant pValign ) {
        int zAt = pElement.getAbsoluteTop();
        if ( pValign != HasVerticalAlignment.ALIGN_TOP ) {
            int zHeight = pElement.getOffsetHeight();
            if ( pValign == HasVerticalAlignment.ALIGN_BOTTOM ) {
                zAt += zHeight - 1;
            } else // Assume Middle
            {
                zAt += zHeight / 2;
            }
        }
        pointTo( zAt );
    }

    public void pointTo( int pTopOfPageOffset ) {
        int zPointerTDAt = mPointer.getParentElement().getAbsoluteTop();
        int zAt = pTopOfPageOffset - zPointerTDAt; // Make Relative to my TD
        zAt -= POINTER_HEIGHT / 2;
        setAt( constrainAt( zAt ), zAt );
        show( true );
    }

    private void setAt( int zAt, int zDesiredAt ) // PreConstrained
    {
        mPointer.getStyle().setPropertyPx( "top", mAt = zAt );
        mShowingPointer = (zAt == zDesiredAt);
        CommonElementHelper.setHidden( mPointer, !mShowingPointer );
    }

    private int constrainAt( int zAt ) {
        int zMaxAt = mPointer.getParentElement().getOffsetHeight() - POINTER_HEIGHT;
        zAt = Math.min( zAt, zMaxAt );
        zAt = Math.max( 0, zAt );
        return zAt;
    }

    private Element createPointer() {
        Element zElement = CommonElementHelper.setImgSrc( DOM.createImg(), QBEPOPUP_POINTER );
        zElement.getStyle().setProperty( "position", "relative" );
        zElement.getStyle().setPropertyPx( "width", POINTER_WIDTH );
        zElement.getStyle().setPropertyPx( "height", POINTER_HEIGHT );
        return zElement;
    }

    private Element createTransparentImg( int pWidth ) {
        Element zElement = CommonElementHelper.setImgSrc( DOM.createImg(), TransparentImage.URL );
        zElement.getStyle().setPropertyPx( "width", pWidth );
        zElement.getStyle().setPropertyPx( "height", STANDARD_SIZE );
        return zElement;
    }

    /**
     * @return Center TD
     */
    private Element addRow( Element pTBody, CompassPoint pLeftCP, Element pLeftElement, CompassPoint pCenterCP, Element pCenterElement, CompassPoint pRightCP,
                            Element pRightElement ) {
        Element zTR = CommonElementHelper.appendToParent( DOM.createTR(), pTBody );
        CommonElementHelper.setTDvAlign( addTD( zTR, pLeftCP, pLeftElement ), HasVerticalAlignment.ALIGN_TOP );
        Element zCenterTD = addTD( zTR, pCenterCP, pCenterElement );
        addTD( zTR, pRightCP, pRightElement );
        return zCenterTD;
    }

    private Element addTD( Element pTR, CompassPoint pCP, Element pElement ) {
        Element zTD = CommonElementHelper.appendToParent( DOM.createTD(), pTR );
        if ( pElement != null ) {
            zTD.appendChild( pElement );
        }
        zTD.setClassName( "CP_" + pCP );
        return zTD;
    }

    private void addRow( Element pTBody, CompassPoint pLeft, CompassPoint pCenter, CompassPoint pRight ) {
        addRow( pTBody, pLeft, createTransparentImg( LEFT_WIDTH ), pCenter, createTransparentImg( STANDARD_SIZE ), pRight,
                createTransparentImg( STANDARD_SIZE ) );
    }

    @Override
    public void setWidth( String width ) {
        super.setWidth( width );
    }

    @Override
    public void setHeight( String height ) {
        super.setHeight( height );
        int zAt = constrainAt( mAt );
        if ( zAt != mAt ) {
            setAt( zAt, mAt );
        }
    }
}