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

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

public abstract class AbstractSizeableTextBoxBase extends AbstractSizeableComposite
        implements SourcesChangeEvents,
                   SourcesClickEvents,
                   HasText,
                   HasFocus
{
    abstract protected TextBoxBase getTextBoxBase();

    private DelegatingKeyboardListenerCollection mKeyboardListeners;
    private DelegatingClickListenerCollection mClickListeners;
    private DelegatingFocusListenerCollection mFocusListeners;
    private DelegatingChangeListenerCollection mChangeListeners;

    public void addKeyboardListener( KeyboardListener listener )
    {
        if ( listener != null )
        {
            if ( mKeyboardListeners == null )
            {
                mKeyboardListeners = new DelegatingKeyboardListenerCollection( this, getTextBoxBase() );
            }
            mKeyboardListeners.add( listener );
        }
    }

    public void removeKeyboardListener( KeyboardListener listener )
    {
        if ( (listener != null) && (mKeyboardListeners != null) && //
             mKeyboardListeners.remove( listener ) && mKeyboardListeners.isEmpty() )
        {
            getTextBoxBase().removeKeyboardListener( mKeyboardListeners );
            mKeyboardListeners = null;
        }
    }

    public void addClickListener( ClickListener listener )
    {
        if ( listener != null )
        {
            if ( mClickListeners == null )
            {
                mClickListeners = new DelegatingClickListenerCollection( this, getTextBoxBase() );
            }
            mClickListeners.add( listener );
        }
    }

    public void removeClickListener( ClickListener listener )
    {
        if ( (listener != null) && (mClickListeners != null) && //
             mClickListeners.remove( listener ) && mClickListeners.isEmpty() )
        {
            getTextBoxBase().removeClickListener( mClickListeners );
            mClickListeners = null;
        }
    }

    public void addFocusListener( FocusListener listener )
    {
        if ( listener != null )
        {
            if ( mFocusListeners == null )
            {
                mFocusListeners = new DelegatingFocusListenerCollection( this, getTextBoxBase() );
            }
            mFocusListeners.add( listener );
        }
    }

    public void removeFocusListener( FocusListener listener )
    {
        if ( (listener != null) && (mFocusListeners != null) && //
             mFocusListeners.remove( listener ) && mFocusListeners.isEmpty() )
        {
            getTextBoxBase().removeFocusListener( mFocusListeners );
            mFocusListeners = null;
        }
    }

    public void addChangeListener( ChangeListener listener )
    {
        if ( listener != null )
        {
            if ( mChangeListeners == null )
            {
                mChangeListeners = new DelegatingChangeListenerCollection( this, getTextBoxBase() );
            }
            mChangeListeners.add( listener );
        }
    }

    public void removeChangeListener( ChangeListener listener )
    {
        if ( (listener != null) && (mChangeListeners != null) && //
             mChangeListeners.remove( listener ) && mChangeListeners.isEmpty() )
        {
            getTextBoxBase().removeChangeListener( mChangeListeners );
            mChangeListeners = null;
        }
    }

    /**
     * Selects all of the text in the box.
     */
    public void selectAll()
    {
        getTextBoxBase().selectAll();
    }

    /**
     * Sets the cursor position.
     *
     * @param pos the new cursor position
     */
    public void setCursorPos( int pos )
    {
        getTextBoxBase().setCursorPos( pos );
    }

    /**
     * If a keyboard event is currently being handled by the text box, this method
     * replaces the unicode character or key code associated with it. This allows
     * listeners to easily filter keyboard input.
     *
     * @param key the new key value
     */
    public void setKey( char key )
    {
        getTextBoxBase().setKey( key );
    }

    public void setName( String name )
    {
        getTextBoxBase().setName( name );
    }

    /**
     * Sets the range of text to be selected.
     *
     * @param pos    the position of the first character to be selected
     * @param length the number of characters to be selected
     */
    public void setSelectionRange( int pos, int length )
    {
        getTextBoxBase().setSelectionRange( pos, length );
    }

    public void setText( String text )
    {
        getTextBoxBase().setText( text );
    }

    /**
     * If a keyboard event is currently being handled on this text box, calling
     * this method will suppress it. This allows listeners to easily filter
     * keyboard input.
     */
    public void cancelKey()
    {
        getTextBoxBase().cancelKey();
    }

    /**
     * Gets the current position of the cursor (this also serves as the beginning
     * of the text selection).
     *
     * @return the cursor's position
     */
    public int getCursorPos()
    {
        return getTextBoxBase().getCursorPos();
    }

    public String getName()
    {
        return getTextBoxBase().getName();
    }

    /**
     * Gets the text currently selected within this text box.
     *
     * @return the selected text, or an empty string if none is selected
     */
    public String getSelectedText()
    {
        return getTextBoxBase().getSelectedText();
    }

    /**
     * Gets the length of the current text selection.
     *
     * @return the text selection length
     */
    public int getSelectionLength()
    {
        return getTextBoxBase().getSelectionLength();
    }

    public String getText()
    {
        return getTextBoxBase().getText();
    }

    public boolean isEnabled()
    {
        return getTextBoxBase().isEnabled();
    }

    public void setEnabled( boolean enabled )
    {
        TextBoxBase zTextBox = getTextBoxBase();
        
        if( enabled )
        {
            zTextBox.removeStyleName( "DisabledTextArea" );
            zTextBox.addStyleName( "EnabledTextArea" );
        }
        else
        {
            zTextBox.removeStyleName( "EnabledTextArea" );
            zTextBox.addStyleName( "DisabledTextArea" );
        }

        zTextBox.setEnabled( enabled );
    }

    public int getTabIndex()
    {
        return getTextBoxBase().getTabIndex();
    }

    public void setTabIndex( int index )
    {
        getTextBoxBase().setTabIndex( index );
    }

    public void setAccessKey( char key )
    {
        getTextBoxBase().setAccessKey( key );
    }

    public void setFocus( boolean focused )
    {
        getTextBoxBase().setFocus( focused );
    }
}