/*

* Copyright (c) 2005-2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0""

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  header file of base controls

*

*/

#ifndef C_CFEPUIBASECTRL_H

#define C_CFEPUIBASECTRL_H

#include <e32base.h>

#include <w32std.h>

#include <w32adll.h>

#include <peninputuilayoutownerinf.h>

#include <peninputuilayoutbase.h>

#include <peninputlayoutminterface.h>

class CFepUiLayout;

class CLayoutTimer;

class CCandidateWnd;

class CFepUiLayoutRootCtrl;

class CCoeControl;

const TInt KDefaultFrameWidth = 1;

// There are 8 shadow bitmaps

const TInt KShadowBitmapTotalNum = 8;

//for mask bitmap

const TUint32 KTransparentColor = 0x0;

const TUint32 KOpaqueColor = 0xffffff;

#define KDEFAULTBASELINERATIO 3/4

//base control type

typedef TInt64 TControlType;

const TInt KPenInputOwnDeviceChange = -1;

const TUint KFepCtrlExtId = 0x00000000;

//UI layout leave code

enum TUiLayoutErrorCode

    {

    EUiLayoutNotReady = -2000,

    EUiLayoutOwnerNotReady,

    EUiLayoutBadControlIndex,

    EUiLayoutBadEvent,

    EUiLayoutBadControlType,

    EUiLayoutCandiateNumIsNotSet,    

    EUiLayoutFuncNotImplemented,

    EUiLayoutBadKeyBmpIndex,

    EUiLayoutNoShadowBmp,

    EUiLayoutNoKey,

    EUiGeneralIndexError,

    EUiFullscreenWithoutHWRWnd,

    EUiLayoutBadParentType,

    EUiNullParam,

    EUiCursorNoOwner,

    EUiNoparent

    };

//define base control types

//Derived class should not re-assign new ctrl type.

enum TStockBaseCtrlType

    {

    ECtrlBaseCtrl           = 0x0001,

    ECtrlTactileFeedback    = 0x0002,    

    ECtrlHwrWnd             = 0x0004 | ECtrlBaseCtrl,     //HWR writing window 

    ECtrlTransparentHwrWnd  = 0x0008 | ECtrlHwrWnd,       //HWR transparent window

    ECtrlCandidateList      = 0x0010 | ECtrlBaseCtrl,     //Candidate list

    ECtrlButton             = 0x0020 | ECtrlBaseCtrl | ECtrlTactileFeedback,     //Button

    ECtrlDragBar            = 0x0040 | ECtrlButton,       //drag bar

    ECtrlControlGroup       = 0x0080 | ECtrlBaseCtrl/* | ECtrlTactileFeedback*/,      //control group    

//    ECtrlButtonGroup        = 0x0080 | ECtrlControlGroup,       //button group    

    ECtrlEditAreaBase       = 0x0100 | ECtrlBaseCtrl | ECtrlTactileFeedback,		//editor base

    ECtrlInputContextArea   = 0x0200 | ECtrlEditAreaBase,   //input context area

    ECtrlVirtualKeyboard    = 0x0400 | ECtrlBaseCtrl,   	//virtual keyboard

    ECtrlPopupWindow		= 0x0800 | ECtrlBaseCtrl,   	//pop up window

    ECtrlPopupChoiceList	= 0x1000 | ECtrlPopupWindow | ECtrlTactileFeedback,   	//pop up choice list

    //ECtrlVirtualItutKeypad  = 0x2000 | ECtrlVirtualKeyboard,

    ECtrlVirtualKey         = 0x2000 | ECtrlBaseCtrl | ECtrlTactileFeedback,       //virtual key control

    ECtrlVirtualItutKey     = 0x4000 | ECtrlVirtualKey,		//virtual itut key control

    ECtrlBackgroundCtrl	    = 0x8000,

    ECtrlCursor             = 0x00010000 | ECtrlBaseCtrl,   //editor cursor

    //Add more stock controls here. E.g ECtrlOskKey for VKB key

    ECtrlWndBasedCtrl           = 0x00040000,

    EUserCtrlBase = 0x00080000

    };

//button type

enum TButtonBmpType

    {    

    EBtnBmpNonActive ,                //bitmap for non active control

    EBtnBmpNonActivePressed,      //bitmap for pressed active control, 

    EBtnBmpActive,                //bitmap for active control

    EBtnBmpActivePressed,         //bitmap for pressed active control

    EBtnBmpDisabled,              //bitmap for disabled control

    EBtnBmpDimmed = EBtnBmpDisabled,    

    EBtnBmpMovingIndicator,

    EBtnBmpLastType = EBtnBmpMovingIndicator                 

    };

//control event type

enum TControlEvent

    {

    EEventButtonDown,               //for button

    EEventButtonUp,                 //for button

    EEventDraggingStart,             //for drag bar

    EEventDragging,                   //for drag bar

    EEventDraggingEnd,                //for drag bar

    EEventVirtualKeyUp,             //for virtual key

    EEventVirtualKeyDown,           //for virtual key

    EEventHwrStrokeStarted,         //for hwr window

    EEventHwrStrokeFinished,        //for hwr window

    EEventHwrCharacterTimerOut,     //for hwr window

    EEventCandidateSelected,        //for candidate window

    EEventButtonLongPress,          //for dragbar long press event  

    EEventSizeChanged,              //for base control size change

    EEventRegionUpdated,            //region has been updated

    EEventSetAppCursorSelection,    //for app cursor selection changing

    EEventControlFocusGained,

    EEventControlFocusLost,

    //Cancel button down event, this happends when button up in another control

    EEventButtonDownCanceled,  

    EEventHwrStrokeCanceled,     

    EEventControlDestroyed,

    EEventChoiceSelected,

    EEventPointerLeftControl,      //Pointer leaves a control after button down

    EEventPointerEnterControl,      //pointer re-enters a control after button down

    EEventVirtualKeyLatched,    //pointer down in a latched virtual key

    EEventVirtualKeyUnLatched,      //point down in a unlatched virtaul key

    EEventICFSelectionChanged,  //ICF selection has been changed   

    EEventRawKeyDownEvent,		//raw ITU-T key down event  

    EEventRawKeyUpEvent,		//raw ITU-T key up event  

    EEventPointerDownOnNomatch, //pointer down on ICF nomatch range

    EEventPointerDownOnInline, // pointer down on ICF inline, but not in nomatch range

    EEventCapturePointer,

    EEventIcfPointerUpEvent,		   //Point up in icfevent

    EEventTooltipPointerUp,

    EEventTooltipPointerLeave,

    EEventTooltipPointerEnter,

    EEventCommitUnderLine,

    EEventInsertSpace,

    EEventControlExtBase = 1000,    //extended event for common control

    EEventControlUserBase = 2000    //user event starts from here

    };

//shadow bitmap index

/****************************************************************************/

// A shadow is drawn by 8 bitmaps. Their position is defined here

//

//      tl  tm  tr

//      lm      rm

//      bl  bm  br

//

/****************************************************************************/

enum TShadowBitmapIndex

    {

    KShadowBmpTl,   //top left bitmap

    KShadowBmpTm,   //top middle bitamp     

    KShadowBmpTr,   //top right bitmap

    KShadowBmpLm,   //left middle bitmap

    KShadowBmpRm,   //right middle bitmap    

    KShadowBmpBl,   //bottom left bitmap

    KShadowBmpBm,   //bottom middle bitmap    

    KShadowBmpBr,   //bottom right bitmap   

    };

/**

 *  CFepUiBaseCtrl

 *

 *  Base control for all FEP UI layout controls.

 *

 *  @lib feplayoutcontrol.lib

 *  @since S60 v4.0

 */

class CFepUiBaseCtrl : public CBase, public MPositionObserver,

                        public MOnResourceChangFunctions

    {

friend class CControlGroup;    

friend class CInsertionPoint;

public:

    NONSHARABLE_CLASS(CFepUiBaseCtrlExtension) : public CBase

        {

        public: 

        CFepUiBaseCtrlExtension();

        /**

         * Set Tactile Feedback Type

         * Advanced Tactile feedback REQ417-47932

         */

        void SetTactileFeedbackType(TInt aTactileType);

        /**

        * Return tactile feedback type

        *

        * Advanced Tactile feedback REQ417-47932

        * @return the tactile feedback type

        */  

        IMPORT_C TInt TactileFeedbackType();

public:

            TBool iExtResponseAreaActive;

            TRect iExtResponseArea;

            TBool iExtResponseAreaEnabled;

            TRect  iExtResponseAreaMargin;

        private:

        /**

         * Tactile Feedback type

         */

        TInt iTactileType;    

        public:

            ~CFepUiBaseCtrlExtension();

            CFbsBitmap* Bitmap() { return iBitmap;}

            CFbsBitmap* MaskBitmap() { return iMaskBitmap;}

            CFbsBitGc* Gc() { return iGc;}

            CFbsBitmapDevice* BitmapDevice() { return iBitmapDevice;}

            CFbsBitmapDevice* MaskBitmapDevice() { return iMaskBitmapDevice;}

            void SetBitmap(CFbsBitmap* aBmp) { iBitmap = aBmp;}

            void SetGc(CFbsBitGc* aGc) { iGc = aGc;}

            void SetBmpDevice(CFbsBitmapDevice* aDevice) { iBitmapDevice = aDevice;}

            void SetMaskBmpDevice(CFbsBitmapDevice* aDevice) { iMaskBitmapDevice = aDevice;}

        private:

            CFbsBitmap* iBitmap; // not own, don't delete

            CFbsBitmap* iMaskBitmap; // not own, don't delete

            /** 

             * graphic context

             * Not own

             */    

            CFbsBitGc* iGc;

            CFbsBitmapDevice* iBitmapDevice;

            CFbsBitmapDevice* iMaskBitmapDevice;

friend class CFepUiBaseCtrl;            

        };

public:

    enum TZOrder

        {

        EOrderBackground = 1500, //order for background control

        EOrderNomal = 1000, //default z-order for control

        EOrderFront = 500,  // front order for control

        EOrderTopMost = 0  // for top most control

        };

public:

    /**

     * Constructor

     *

     * @since S60 V4.0

     * @param aRect The rectangle area for this control

     * @param aUiLayout Ui layout who contains this control. Ownership not transferred

     * @param aControlId control Id

     */    

    IMPORT_C CFepUiBaseCtrl(const TRect& aRect,CFepUiLayout* aUiLayout,

                                                            TInt aControlId);

    /**

     * Constructor. Used internally by CControlGroup

     *

     * @since S60 V4.0

     * @param aControl The control to be added. The control must set its extent

     *                  before added to the layout.

     * @param aUiLayout Ui layout who contains this control. Ownership not transferred               

     * @param aOwnership The ownership of the window control. ETrue if it's transfered 

     * to this control

     */                                                                    

     CFepUiBaseCtrl(CCoeControl* aControl, CFepUiLayout* aUiLayout,TBool aOwnership = ETrue);

    /**

     * Do base contruction. Allocate event data buffer

     * Each derived control must call this in its contruction time

     * 

     * @since S60 v4.0

     */

    IMPORT_C void BaseConstructL();    

    /**

     * Destructor.

     *

     * @since S60 V4.0        

     */    

    IMPORT_C virtual ~CFepUiBaseCtrl();           

    /**

     * Pure virtual function, draws the control

     *

     * @since S60 V4.0

     */               

     IMPORT_C virtual void Draw();

    /**

     * Redraws the content in a control

     *

     * @since S60 V4.0

     * @param aRect The rect to be redrawed

     */               

     IMPORT_C virtual void ReDrawRect(const TRect& aRect);     

    /**

     * Capture or release the pointer. 

     * After capturing, all UI layout event will be processed by this control

     *

     * @since S60 V4.0

     * @param aFlag The flag indicates capturing or releasing.

     * @return The control which captures the pointer before.

     */               

    IMPORT_C CFepUiBaseCtrl* CapturePointer(TBool aFlag = ETrue);

    /**

     * Clear the whole control area

     *

     * @since S60 V4.0

     */        

    IMPORT_C void Clear();

    /**

     * Clear a area in the control

     *

     * @since S60 V4.0

     * @param aRect The rect to be cleared.

     */                        

    IMPORT_C void ClearRect(const TRect& aRect);

    /**

     * Hide or shoe control. A hiden control will not handle the event.

     *

     * @since S60 V4.0

     * @param aFlag ETrue if want to hide the control.

     */                                               

    IMPORT_C virtual void Hide(TBool aFlag);

    /**

     * Bring the control to top most in current control group and show it.

     *

     * @since S60 V5.0

     */                                               

    IMPORT_C void BringToTop();

    /**

     * Bring the control to back most in current control group and show it.

     *

     * @since S60 V5.0

     */                                                   

    IMPORT_C void BringToBack();

    /*

     * Set background bitmap

     *

     * @since S60 V4.0

     * @param aBmp The background bitmap. Ownership transferred to control

     */

    IMPORT_C virtual void SetBackgroundBitmapL(CFbsBitmap* aBmp);

    /**

     * Set background mask bitmap

     *

     * @since S60 V4.0

     * @param aBmp The background bitmap. Ownership transferred to control

     */

    IMPORT_C virtual void SetBackgroundMaskBitmapL(CFbsBitmap* aBmp);

    /**

     * Check whether this control contains the point

     *

     * @since S60 V4.0

     * @param aPoint The point to be checked

     * @return ETrue if control valid region contains the point, otherwise EFalse

     */

    IMPORT_C virtual TBool Contains(const TPoint& aPt);

    /**

     * Set control's rectangle

     *

     * @since S60 V4.0

     * @param aRect The new control area

     */                                       

    IMPORT_C virtual void SetRect(const TRect& aRect);

    /**

     * Set shadow rect. Shadow rect defines the outside rect of the control.

     * The shadow is drawn between this rect and control's rect using bitmaps

     *

     * @since S60 V4.0

     * @param aRect The shadow rect. Shadow rect must bigger than control's

     *        rect, otherwise no effect.

     */    

    IMPORT_C void SetShadowRect(const TRect& aRect);        

    /**

     * Set shadow rect for a shadow area.

     * The nth shadow is drawn in this shadow rect

     *

     * @since S60 V4.0

     * @param aRect The shadow rect.

     * @param aIndex The index position for shadow rect 

     */        

    IMPORT_C void SetShadowAreaRect(const TRect& aRect, TShadowBitmapIndex aIndex);

    /**

     * Add event obeserver.

     * The observer will get notified when control event happens.

     *

     * @since S60 V4.0

     * @param aObserver An event obeserver. Ownership not transferred

     */                                       

    IMPORT_C void AddEventObserver(MEventObserver* aObserver);

    /**

     * Remove event obeserver

     *

     * @since S60 V4.0

     * @param aObserver An event obeserver to be removed.

     */                                                       

    IMPORT_C void RemoveEventObserver(MEventObserver* aObserver);

    /**

     * Report event to event observer

     *

     * @since S60 V4.0

     * @param aEventType the event type

     * @param aEventData Event data

     */

    IMPORT_C void ReportEvent(TInt aEventType, const TDesC& aEventData = KNullDesC);

    /**

     * Update control's valid region when other control hiding or displaying.

     * This is usually used for HWR window to change it's writing area.

     *

     * @since S60 V4.0

     * @param aCtrl The control whose displaying status changed

     * @param bFlag ETrue if control is hiden, otherwise EFalse

     */        

    IMPORT_C virtual void UpdateValidRegion(CFepUiBaseCtrl* aCtrl,TBool aRemoveFlag);

    /**

     * Move conntrol

     *

     * @since S60 V4.0

     * @param aOffset The offset to be moved

     */                

    IMPORT_C virtual void Move(const TPoint& aOffset);

    /**

     * Set control active

     *

     * @since S60 V4.0

     * @param aFlag The active flag. ETrue if active, otherwise EFalse

     */                                

    IMPORT_C virtual void SetActive(TBool aFlag);   

    /**

     * Handle pointer down event

     *

     * @since S60 V4.0

     * @param aPoint The point position relative the layout

     * @return The control which handles the event.

     */                                        

    IMPORT_C virtual CFepUiBaseCtrl* HandlePointerDownEventL(const TPoint& aPoint);

    /**

     * Handle pointer move event

     *

     * @since S60 V4.0

     * @param aPoint The point position relative the layout

     * @return The control which handles the event.     

     */                  

    IMPORT_C virtual CFepUiBaseCtrl* HandlePointerMoveEventL(const TPoint& aPoint);

    /**

     * Handle pointer up event

     *

     * @since S60 V4.0

     * @param aPoint The point position relative the layout

     * @return The control which handles the event.     

     */                  

    IMPORT_C virtual CFepUiBaseCtrl* HandlePointerUpEventL(const TPoint& aPoint);

    /**

     * Cancel pointer down event.

     * This will be called when a control has pointer down but pointer up 

     * event happens in other ways. If overrided, this base implementation 

     * must be called in order to report the event.

     *

     * @since S60 V4.0

     * @param aFocusedFlag ETrue if got focused, otherwise EFalse

     */                                

    IMPORT_C virtual void CancelPointerDownL();

    /**

     * Handle pointer levae event. 

     * This will be called only when it's got pointer down event before and 

     * now pointer leaves without pointer up event

     *

     * @since S60 V4.0