// Copyright (c) 1997-2010 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:

//

#include <coecntrl.h>

#include <coecntss.h>

#include <coeccntx.h>

#include <coemain.h>

#include <coeaui.h>

#include "COETLS.H"

#include "coepanic.h"

#include <coeinput.h>

#include <coedef.h>

#include <coefontprovider.h>

#include <coefont.h>

#include <coelayoutman.h>

#include <hal.h>

#include "CoeDynamicStorage.inl"

#include "coedefkeys.h"

//

// class CCoeControl

//

enum

	{

	ECoeCntrlUnused1					=0x00000001,

	EWindowIsSemiTransparent			=0x00000002,	// Indicated that the window has been set to make use of the alpha channel

	EOwnsWindow						 	=0x00000004,	// Signals that the control is window-owning

	EFocused							=0x00000008,	// Control has focus

	EActivated						  	=0x00000010,	// Control has been activated (thus ready to draw if visible)

	EInvisible						  	=0x00000020,	// Control is currently invisible

	EDimmed								=0x00000040,	// Control is currently dimmed (unavailable to the user)

	ESpareEnumReUseMe					=0x00000080,	// Was EGrabbed, now available for re-use

	EBackedUpWindow					 	=0x00000100,	// 

	ENonFocusing						=0x00000200,	// 

	EAllowStrayPointers					=0x00000400,	// Unless set, pointer up and drag events will be ignored unless 

														// there's been a pointer down event in the control previously

	ECanDrawOutsideRect					=0x00000800,	// 

	EBlank								=0x00001000,	// 

	ECapturesPointer					=0x00002000,	// 

	EIgnoresFirstExternalPointerUp		=0x00004000,	// For resolving problem with new windows being created on pointer down

	EIgnoresEventsUntilNextPointerUp	=0x00008000,	// For ignoring drag and up events after the user has pressed Esc

	EComponentsInheritVisibility		=0x00010000,	// 

	EGloballyCapturing					=0x00020000,	// 

	EIsBeingDestroyed					=0x00040000,	// 

	EMemoryAllocationFailed				=0x00080000,	// 

	ENotifyFocusObserversOnDestruction	=0x00100000, 	// This flag is needed as if CCoeControl::SetFocus needs to call 

														// CCoeControlExtension::SetFocusObserverNotificationIdentifier 

														// but can't because it can't create the CCoeControlExtension object

	EReportControlStateChange			=0x00200000		// This flag is used to control the ReportControlStateChange

	};

class CCoeControlStorage

	{

public:

	inline CCoeControlStorage();

	inline RCoeDynamicDataStorage& DynamicDataStorage();

	inline const RCoeDynamicDataStorage& DynamicDataStorage() const;

	inline TInt Open();

	inline void Close();

	inline void AttemptCompress();

	void SetPointerGrab(TUint aSet, TUint aClear);

	TUint8& PointerGrab();

private:

	RCoeDynamicDataStorage iDynamicDataStorage;

	TUint8 iPointerGrabFlags; // The grab-status of each of the supported pointers

	};

void CCoeControlStorage::SetPointerGrab(TUint aSet, TUint aClear)

	{

	ASSERT(aSet != aClear);

	iPointerGrabFlags &= ~aClear;

	iPointerGrabFlags |= aSet;

	}

TUint8& CCoeControlStorage::PointerGrab()

	{

	return iPointerGrabFlags;

	}

inline CCoeControlStorage::CCoeControlStorage()

: iDynamicDataStorage(), iPointerGrabFlags(0)  

	{}

inline RCoeDynamicDataStorage& CCoeControlStorage::DynamicDataStorage()

	{ return iDynamicDataStorage; }

inline const RCoeDynamicDataStorage& CCoeControlStorage::DynamicDataStorage() const

	{ return iDynamicDataStorage; }

inline TInt CCoeControlStorage::Open()

	{ return iDynamicDataStorage.Open(); }

inline void CCoeControlStorage::Close()

	{ iDynamicDataStorage.Close(); }

inline void CCoeControlStorage::AttemptCompress()

	{ iDynamicDataStorage.AttemptCompress(); }

EXPORT_C CCoeControl::CCoeControl()

/** Default C++ constructor. 

Initialises the CCoeControl base class.

Note: CCoeControl is normally used as a base class from which concrete 

control classes are derived. However, it can also be instantiated as a concrete 

class. */

	{

	Constructor(TheCoe());

	}

EXPORT_C CCoeControl::CCoeControl(CCoeEnv* aCoeEnv)

/** C++ constructor. 

Initialises the CCoeControl base class.

Note: CCoeControl is normally used as a base class from which concrete 

control classes are derived. However, it can also be instantiated as a concrete 

class. 

@param aCoeEnv The control environment.*/

	{

	Constructor(aCoeEnv);

	}

void CCoeControl::Constructor(CCoeEnv* aCoeEnv)

	{

	iCoeEnv = aCoeEnv;

	iData = new CCoeControlStorage;		// Non-leaving allocation

	if (!iData || iData->Open()!=KErrNone)

		iFlags |= EMemoryAllocationFailed;	// Handle OOM later

	SetFocusing(CCoeControlStaticSettings::FocusedByDefault(iCoeEnv));

	}

EXPORT_C CCoeControl::~CCoeControl()

/** Destructor. 

It destroys the window owned by the control, if it is a window-owning control.

In debug builds, this checks if the control still exists 

on the control stack and raises a CONE 44 panic if it is. An application 

must remove every control that it has added to the stack. */

	{

#if defined(_DEBUG)

	CCoeAppUi* appUi=static_cast<CCoeAppUi*>(iCoeEnv->AppUi());

	if (appUi && appUi->IsControlOnStack(this))

		Panic(ECoePanicControlNotRemovedFromStack);

#endif

	iFlags |= EIsBeingDestroyed;

	if ((iFlags&EFocused) || (iFlags&ENotifyFocusObserversOnDestruction)  && iCoeEnv->FocusObserverNotificationIsStillPending(DoGetFocusObserverNotificationIdentifier(iData->DynamicDataStorage())))

		iCoeEnv->NotifyFocusObserversOfDestructionOfFocusedItem();

	// The CCoeControlArray d'tor calls delete on components

	// which are not owned externally.

	delete DoGetComponentArray(iData->DynamicDataStorage());

	if (OwnsWindow())

		CloseWindow();

	MCoeLayoutManager* layoutMan = LayoutManager();

	if (layoutMan)

		layoutMan->Detach(*this);

	delete DoGetColorOverrides(iData->DynamicDataStorage());

	delete DoGetZoomWithType(iData->DynamicDataStorage());

	if(iData)

		iData->Close();

	delete iData;

	}

/**@return ETrue if the component array exists, EFalse otherwise

*/	

EXPORT_C TBool CCoeControl::ComponentArrayExists() const

    {

    CCoeControlArray* array = DoGetComponentArray(iData->DynamicDataStorage());

    return (array != NULL);

    }

EXPORT_C TBool CCoeControl::IsFocused() const

/** Tests if the control has focus. 

Focus is set and unset using SetFocus().

@return ETrue if the control has focus, EFalse if it doesn't. */

	{

	return (iFlags&EFocused);

	}

EXPORT_C TBool CCoeControl::IsVisible() const

/** Tests if the control is visible.

Unless MakeVisible() has been called with argument EFalse, the control is 

visible.

@return ETrue if the control is visible, EFalse if it is invisible. */

	{

	return (!(iFlags&EInvisible));

	}

EXPORT_C TBool CCoeControl::IsDimmed() const

/** Tests if the control is dimmed.

This function returns the value of a flag within the control which is set 

and unset using SetDimmed().

@return ETrue if the control is dimmed, EFalse if it is not dimmed. */

	{

	return (iFlags&EDimmed);

	}

EXPORT_C RDrawableWindow* CCoeControl::DrawableWindow() const

/** Gets the control's associated drawable window. 

The control must be a window-owning control. 

This function should be called if it is not known whether the window is of 

type RWindow or RBackedUpWindow. RDrawableWindow is an abstract base class 

from which RWindow and RBackedUpWindow are derived.

@return The control's associated window.

@see Window() */

	{

	return iWin;

	}

EXPORT_C TSize CCoeControl::Size() const

/** Gets the control's size.

@return The control's size, in pixels. */

	{

	return iSize;

	}

EXPORT_C TInt CCoeControl::MaximumWidth() const

/** Gets the control's maximum width

@return The controls maximum width. (0 if no value set). */

	{

	// Try to retrieve a maximum width value if one has been set, otherwise return zero.

	return DoGetMaximumWidth(iData->DynamicDataStorage());

	}

EXPORT_C TPoint CCoeControl::Position() const

/** Gets the control's position.

@return The position of the control, relative to its associated window. */

	{

	return iPosition;

	}

EXPORT_C TPoint CCoeControl::PositionRelativeToScreen() const

/** Gets the control's position relative to screen origin. 

The screen origin is its top-left corner.

@return The position of the control, measured in pixels, relative to the screen 

origin. */

	{

	TPoint ret=iWin->InquireOffset(iCoeEnv->RootWin());

	if (!OwnsWindow())

		ret+=iPosition;

	return ret;

	}

EXPORT_C void CCoeControl::SetObserver(MCoeControlObserver* aObserver)

/** Sets the control's observer.

@param aObserver The observer. */

	{

	if(DoSetObserver(iData->DynamicDataStorage(), aObserver) == KErrNoMemory)	

		iFlags |= EMemoryAllocationFailed;

	}

EXPORT_C MCoeControlObserver* CCoeControl::Observer() const

/** Gets the control's observer.

@return The control's observer. */

	{

	return DoGetObserver(iData->DynamicDataStorage());

	}

EXPORT_C TBool CCoeControl::IsReadyToDraw() const

/** Tests if the control is ready for drawing. 

This returns true if the control has been activated and is visible.

@return ETrue if the control is ready for drawing, EFalse if it is not ready 

for drawing. */

	{

	return ((iFlags&(EInvisible|EActivated))==(EActivated)) || (iFlags&EBackedUpWindow);

	}

EXPORT_C TBool CCoeControl::OwnsWindow() const

/** Tests if the control is window-owning.

@return ETrue if the control is window-owning. EFalse if the control is non-window-owning. */

	{

	return (iFlags&EOwnsWindow);

	}

EXPORT_C TBool CCoeControl::IsBackedUp() const

/** Tests if the window owned by the control is a backed-up window.

@return ETrue if the window owned by this control is a backed-up window. EFalse 

if it is not a backed-up window.

@deprecated

*/

	{

	return (iFlags&EBackedUpWindow);

	}

EXPORT_C TBool CCoeControl::IsActivated() const

/** Tests if the control has been activated. 

A control is not ready to draw until it is activated.

@return ETrue if the control is activated, EFalse if it is not activated. */

	{

	return (iFlags&EActivated);

	}

EXPORT_C TBool CCoeControl::IsBlank() const

/** Tests if the control is blank. 

This simply gets the value of the flag set by SetBlank().

@return ETrue if SetBlank() has been called on the control. EFalse if SetBank() 

has not been called on the control. */

	{

	return (iFlags&EBlank);

	}

EXPORT_C TBool CCoeControl::IsBeingDestroyed() const

/** Tests if the control is being destroyed.

@return ETrue if the control is being destroyed, otherwise EFalse. */

	{

	return (iFlags&EIsBeingDestroyed);

	}

/**

 @param aPointerNumber The pointer number. Defaulted to zero in the declaration.

*/

TBool CCoeControl::IsGrabbed(TInt aPointerNumber) const

	{

	ASSERT( ((aPointerNumber < KConeMaxSupportedPointers) && (aPointerNumber >= 0)) );

	return ( iData->PointerGrab() & (1 << aPointerNumber) );

	}

EXPORT_C TKeyResponse CCoeControl::OfferKeyEventL(const TKeyEvent& /*aKeyEvent*/,TEventCode /*aType*/)

/** Handles key events.

If a control wishes to process key events, it should implement this function. 

The implementation must ensure that the function returns EKeyWasNotConsumed 

if it does not do anything in response to a key event, otherwise, other 

controls or dialogs may be prevented from receiving the key event. If it is 

able to process the event it should return EKeyWasConsumed.

When a key event occurs, the control framework calls this function for each 

control on the control stack, until one of them can process the key event 

(and returns EKeyWasConsumed).

Each keyboard key press results in three separate events: EEventKeyDown, EEventKey, 

and EEventKeyUp, in that order. 

To receive key events, which can be processed by this function, the application 

should call CCoeAppUi::AddToStackL() to add the control to the stack. This 

only applies, however, to controls which are not components of a compound 

control. Compound controls should pass key events to their components as necessary: 

the components themselves do not go on the stack.

Classes that override CCoeControl::OfferKeyEventL() should also override the 

InputCapabilities() virtual function, returning a TCoeInputCapabilities object 

whose attributes correspond to the behaviour of the OfferKeyEventL() function. 

Note that it is not necessary to call InputCapabilities() on any component 

controls from inside a class' InputCapabilities() function. This is done 

automatically by the UI Control Framework.

If overriding OfferKeyEventL(), the implementation must include a base call to CCoeControl's

OfferKeyEventL().

@param aKeyEvent The key event.

@param aType The type of key event: EEventKey, EEventKeyUp or EEventKeyDown.

@return Indicates whether or not the key event was used by this control. */

	{

	return(EKeyWasNotConsumed);

	}

void CCoeControl::ProcessPointerBufferReadyL()

	{

	CCoeControl* destination=NULL;

	for (TInt i=0; i<CountComponentControls(); i++)

		{

		CCoeControl* ctrl=ComponentControl(i);

		if (ctrl->IsGrabbed() && !(ctrl->OwnsWindow()))

			destination=ctrl;

		}

	if (destination)

		destination->ProcessPointerBufferReadyL();

	else

		HandlePointerBufferReadyL();

	}

EXPORT_C void CCoeControl::HandlePointerBufferReadyL()

/** Handles pointer buffer ready events.

This function is called whenever the control receives an event of type EEventPointerBufferReady, 

unless one of its component controls has grabbed the pointer, in which case 

the function is called on that control. An event of type EEventPointerBufferReady 

will only be received if the pointer move buffer has been set up using window 

server functions. 

The pointer move buffer is typically used when the application requires a 

continuous stream of pointer drag events, such as in a drawing application.

@see RWindowBase::AllocPointerMoveBuffer() */

	{

	}

EXPORT_C void CCoeControl::ClaimPointerGrab(TBool aSendUpEvent)

/** Claims the pointer-grab from another control. 

This ensures that all subsequent pointer events are delivered to it and not 

to the control that originally owned the grab.

The function allows a control to claim the pointer grab only if the pointer 

is already grabbed by another control.

This method is to be used in systems implementing single-pointer events. Or in systems 

implementing multiple-pointer events but where this control's window has single-pointer 

emulation enabled.

@param aSendUpEvent Passed as the argument to RWindowBase::ClaimPointerGrab().

@see RWindowBase::ClaimPointerGrab() */

	{

	iFlags |= EAllowStrayPointers|EIgnoresFirstExternalPointerUp;	// EIgnoresFirstExternalPointerUp reset in ProcessPointerEventL()

	iWin->SetPointerGrab(ETrue);

	iWin->ClaimPointerGrab(aSendUpEvent);

	ControlClaimPointerGrab(TAdvancedPointerEvent::EDefaultPointerNumber);	

	}

EXPORT_C TInt CCoeControl::ClaimPointerGrab( TInt aPointerNumber, TBool aSendUpEvent )

/** Claims pointer grab from another control.

This ensures that all subsequent pointer events of the specified pointer are delivered 

to it and not to the control that originally owned the grab.

The function allows a control to claim the pointer grab only if the pointer 

is already grabbed by another control.

This method is intended to be called on a control who's window implements multi-pointer events.

If called on a window without multiple pointers enabled, wserv will ignore the pointer 

number and grab the emulated pointer. 

@param aSendUpEvent Passed as the argument to RWindowBase::ClaimPointerGrab().

@param aPointerNumber The number of the pointer for which to claim the grab.

@return KErrNone if successful, KErrNotFound if pointer number out of range (Panics in debug build), or KErrNotSupported if incorrect pointer grab claimed for window in emulation mode.

@see RWindowBase::ClaimPointerGrab() 

@see RWindowBase::EnableMMultiplePointers() */

	{ 

	__ASSERT_DEBUG( ((aPointerNumber < ControlEnv()->SupportedPointers()) && (aPointerNumber >= 0)), Panic(ECoePanicNoSuchNumberedPointer) );

	iFlags |= EAllowStrayPointers|EIgnoresFirstExternalPointerUp;	// EIgnoresFirstExternalPointerUp reset in ProcessPointerEventL()

	iWin->SetPointerGrab(ETrue);

	TInt errNo = iWin->ClaimPointerGrab(aPointerNumber, aSendUpEvent);

	if(KErrNone == errNo)

		{

		ControlClaimPointerGrab(aPointerNumber);

		}

	return errNo;

	}

void CCoeControl::ControlClaimPointerGrab(TInt aPointerNumber)

	{

	// Without this code, claiming pointer grab only work between 

	// window owning controls, not between controls in the same window 

	const CCoeControl* parent = WindowOwningParent(); 

	if(parent)

		{

		CCoeControl* ctrl = parent->GrabbingComponent( aPointerNumber );

		if(ctrl)

			{

			ctrl->SetGrabbed(EFalse, aPointerNumber);

			}

		}

	SetGrabbed(ETrue, aPointerNumber);		

	}

EXPORT_C void CCoeControl::IgnoreEventsUntilNextPointerUp()

/** Sets the control to ignore pointer events until the next pointer up.

This means that all events until and including the next pointer up event are 

discarded and are not processed. 

This can be used for example if the user presses the Esc key while selecting

text by dragging the pointer device to ensure that further dragging does not

result in continued selection.

*/