MCL/sf/mw/classicui: comparison lafagnosticuifoundation/cone/src/COECNTRL.CPP

equal deleted inserted replaced

--1:000000000000
+:2f259fa3e83a
+// Copyright (c) 1997-2009 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 void 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 void CCoeControlStorage::Open()
+	{ 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. */
+	{
+	iCoeEnv = TheCoe();
+	iData = new CCoeControlStorage;		// Non-leaving allocation
+	if (iData)
+		{
+		iData->Open();
+		}
+	else
+		{
+		iFlags |= EMemoryAllocationFailed;	// Handle OOM later
+		}
+	SetFocusing(CCoeControlStaticSettings::FocusedByDefault(iCoeEnv));
+	}
+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.*/
+	{
+	iCoeEnv = aCoeEnv;
+	iData = new CCoeControlStorage;		// Non-leaving allocation
+	if(iData)
+		iData->Open();
+	else
+		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.
+*/
+	{
+	iFlags|=EIgnoresEventsUntilNextPointerUp;
+	}
+void CCoeControl::ProcessPointerEventL(const TPointerEvent& aPointerEvent)
+	{
+	TBool requiresFocus = EFalse;
+	TInt pointerNumber = TAdvancedPointerEvent::EDefaultPointerNumber;
+	if (aPointerEvent.IsAdvancedPointerEvent())
+		{
+		User::LeaveIfError(ValidateAdvancedPointerNumber(aPointerEvent));
+		pointerNumber = aPointerEvent.AdvancedPointerEvent()->PointerNumber();
+		}
+	if (aPointerEvent.iType==TPointerEvent::EButton1Down)
+		{
+		// If this is a window owning control with a hit-test object attached....
+		if(OwnsWindow())
+			{
+			// ...then if the hit-test fails, try passing the event up to the next level...
+			const MCoeControlHitTest* hitTest = HitTest();
+			if(hitTest && !hitTest->HitRegionContains(aPointerEvent.iPosition, *this))
+				{
+				// ...i.e. up to the next window owning parent, thus allowing even window owning controls
+				// to be transparent to pointer events.
+				CCoeControl* windowOwningParent = Parent()->WindowOwningParent();	// safe even if not parent exists
+				if(windowOwningParent)
+					{
+					windowOwningParent->ProcessPointerEventL(aPointerEvent);
+					return;	// Don't continue in this part of the control tree
+					}
+				}
+			}
+		SetGrabbed(EFalse, pointerNumber);	// Reset the grabbing
+		if (!IsVisible())
+			return;
+		if (IsDimmed())
+			{
+			ReportEventL(MCoeControlObserver::EEventInteractionRefused);
+			return;
+			}
+		// If the control does not aleady have focus (but can take focus)
+		// then generate a prepare-focus-transition event now, and a
+		// request-focus event once the pointer event has been handled
+		// (see end of this function)
+		if (!IsFocused() && !IsNonFocusing())
+			{
+			ReportEventL(MCoeControlObserver::EEventPrepareFocusTransition);
+			requiresFocus = ETrue;
+			}
+		SetGrabbed(ETrue, pointerNumber);	// Set the control grabbing any further pointer events.
+											// This ensures that the control that got the pointer down also gets the
+											// pointer up event (and any drag events).
+		}
+	else	// Mainly EButton1Up or EDrag. Other events will be ignored unless stray events are allowed (see below)
+		{
+		if ( IsGrabbed(pointerNumber) )	// If there's been a EButton1Down event...
+			{
+			if (aPointerEvent.iType==TPointerEvent::EButton1Up)	// ...and this is the matching EButton1Up event...
+				SetGrabbed(EFalse, pointerNumber);				// ...then terminate the grabbing state.
+			}
+		else	// If no EButton1Down event has been recorded; then either this is it, or it's a stray event.
+			{
+			if ( !(iFlags&EAllowStrayPointers) && !(aPointerEvent.iModifiers & EModifierAdvancedPointerEvent) )
+				return;			// Ignore stray events unless explicitly allowed
+//mm something's fishy here...
+			// The code that follows intends to resolve the problem that occurs when a pointer tap
+			// (down-up event) on a menu item results in a sub-menu being opened and that sub-menu
+			// appears "under" the pointer. In these cases the up-event must not invoke the menu item
+			// in the sub-menu that happens to be located at the coordinate of the event.
+			// If the pointer grab has been claimed (by calling ClaimPointerGrab())
+			if (iFlags&EIgnoresFirstExternalPointerUp)
+				{
+				// If the pointer event occured inside this control (and not in the "sub-menu")...
+				if (Rect().Contains(aPointerEvent.iPosition))
+					iFlags &= ~EIgnoresFirstExternalPointerUp;	// ...then no need to ignore the pointer up event.
+				else
+					{
+					if (aPointerEvent.iType==TPointerEvent::EButton1Up)	// If the event was the pointer-up...
+						iFlags &= ~EIgnoresFirstExternalPointerUp;		// ...then reset the flag...
+					return;												// ...and ignore the event.
+					}
+				}
+			}
+		}
+	// If flag is set, ignore all pointer events until the next pointer up.
+	// See doxygen comments for IgnoreEventsUntilNextPointerUp().
+	if (iFlags&EIgnoresEventsUntilNextPointerUp)
+		{
+		if (aPointerEvent.iType==TPointerEvent::EButton1Up)	// Reset the flag on the first pointer up
+			iFlags&=(~EIgnoresEventsUntilNextPointerUp);
+		return;	// Ignore the event
+		}
+	HandlePointerEventL(aPointerEvent);
+	// If there was a pointer down event on a non-focused control, then generate a request-focus event.
+	if (requiresFocus)
+		ReportEventL(MCoeControlObserver::EEventRequestFocus);
+	}
+/** Handles pointer events.
+This function gets called whenever a pointer event occurs in the control,
+i.e. when the pointer is within the control's extent, or when the control has
+grabbed the pointer. The control should implement this function to handle
+pointer events.
+Note: events of type EButton1Down are processed before HandlePointerEventL() is
+called, in order to transfer keyboard focus to the control in which the EButton1Down
+event occurred.
+If overriding HandlePointerEventL(), the implementation must include a base call to CCoeControl's
+HandlePointerEventL().
+The TPointerEvent& parameter aPointerEvent can be safely transformed into a TAdvancedPointerEvent
+at all times by deploying the following code:-
+const TAdvancedPointerEvent* advancedPointerEvent = aPointerEvent.AdvancedPointerEvent();
+@see TPointerEvent
+@see TAdvancedPointerEvent
+The TAdvancedPointerEvent methods supply safe and meaningful values even in systems not
+implementing advanced pointers.
+@param aPointerEvent The pointer event. */
+EXPORT_C void CCoeControl::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+	{
+	// The code below will traverse down the control hierarchy, effectively offer the pointer
+	// event to all controls intersecting the pointer event coordinate, from the window-owning
+	// parent down to the furthest child node.
+	// Offers the pointer down (and move) events to component controls in the order from the window-owning
+	// parent and down throught the control tree. Other events always go the the control that got the down event.
+	CCoeControl* pointerRecipient = NULL;
+	if (aPointerEvent.iType==TPointerEvent::EButton1Down
+						  || aPointerEvent.iType==TPointerEvent::EMove
+						  || aPointerEvent.iType==TPointerEvent::EEnterCloseProximity
+						  || aPointerEvent.iType==TPointerEvent::EExitCloseProximity
+						  || aPointerEvent.iType==TPointerEvent::EOutOfRange)
+		{
+		// For all children...
+		const TInt count = CountComponentControls();
+		for (TInt ii=count-1; ii>=0; ii--)
+			{
+			CCoeControl* ctrl = ComponentControl(ii);
+			// ...ignoring any window-owning children (as they would have got the event directly from the WServ
+			// if they intersect the pointer coordinate) and any invisible children...
+			if (ctrl->OwnsWindow() || !(ctrl->IsVisible()))
+				continue;
+			// ...if the child intersects the pointer coordinate...
+			if(ctrl->Rect().Contains(aPointerEvent.iPosition))
+				{
+				// ...check if the child has a hit-test object attached, and if it has then only progress down
+				// its branch if the test succeeded (this way controls that are partly transparent won't react
+				// to pointer events outside their visible area)...
+				const MCoeControlHitTest* childHitTest = ctrl->HitTest();
+				if(childHitTest && !childHitTest->HitRegionContains(aPointerEvent.iPosition, *ctrl)) // If the test failed...
+					continue;	// ...then offer the event to next sibling (two partly transparent siblings may overlap!)
+				pointerRecipient = ctrl;
+				break;
+				}
+			}
+		}
+	else
+		{
+		// Always offer all events except down- and move-events to the grabbing control (that got the original down event)
+		TInt pointerNum = aPointerEvent.IsAdvancedPointerEvent() ? aPointerEvent.AdvancedPointerEvent()->PointerNumber() : TAdvancedPointerEvent::EDefaultPointerNumber;
+		pointerRecipient = GrabbingComponent(pointerNum);
+		}
+	// Pass the pointer event on to the child found to intersect the pointer event coordintate
+	// (or that got the original pointer down event)
+	if (pointerRecipient)
+		pointerRecipient->ProcessPointerEventL(aPointerEvent);
+	}
+EXPORT_C void CCoeControl::ReportEventL(MCoeControlObserver::TCoeEvent aEvent)
+/** Sends an event to the control's observer (if the control has one).
+@param aEvent The event type. */
+	{
+	MCoeControlObserver* observer = DoGetObserver(iData->DynamicDataStorage());
+	if (observer)
+		observer->HandleControlEventL(this,aEvent);
+	}
+EXPORT_C void CCoeControl::PrepareForFocusLossL()
+/** Prepares the control for loss of focus.
+A control which is displayed within a dialog should implement this function
+if it wishes to validate data entered into the control.
+This function is called by the dialog framework immediately before it removes
+keyboard focus from a control within a dialog. It is intended to be used for
+validating the state of the control: for example, if the control allows the
+user to enter a date, PrepareForFocusLossL() would normally check to make
+sure the user did not enter an invalid date such as February 31st. If an invalid
+state is detected, PrepareForFocusLossL() should leave and issue a message
+to the user if appropriate. If it does leave, the framework does not perform
+the action that would have resulted in the control losing focus, and focus
+remains with the control to allow valid data to be entered.
+In standard GUI dialogs, various actions can result in a control losing focus,
+for instance if the user presses the OK button or the Enter key to close the dialog
+and enter the information, or if the user navigates away from
+the focussed control. These actions result in PrepareForFocusLossL() being
+called on the control that currently has keyboard focus.
+The default implementation of this function is empty, and it is not called
+from within the UI control framework. The function exists only to provide
+an interface to the control, for the GUI and any other UI library. */
+	{
+	}
+EXPORT_C void CCoeControl::PrepareForFocusGainL()
+/** Prepares the control for gaining focus.
+Implementations may by taking any action required, such as updating control
+information. The default implementation is empty. */
+	{
+	}
+EXPORT_C void CCoeControl::SetAdjacent(TInt /*aAdjacent*/)
+/** Sets the control's appearance when it is next to other controls.
+Its intended use is to remove the double border that may occur if two controls,
+both with borders, are adjacent within a container control.
+This function has an empty default implementation, and is not used within
+the UI control framework. However, it may be implemented and used by derived
+control classes.
+@param aAdjacent Typically a value defined in TGulAdjacent. */
+	{
+	}
+EXPORT_C void CCoeControl::SetNeighbor(CCoeControl* /*aNeighbor*/)
+/** Sets an associated control.
+This can be used to establish co-ordinated groups of controls for instance in dialogs
+without specific application co-operation.
+This function has an empty default implementation, and is not used within
+the UI control framework. However, it may be implemented and used by derived
+control classes.
+@param aNeighbor A control to be used by this function. */
+	{
+	}
+EXPORT_C TBool CCoeControl::HasBorder() const
+/** Tests if the control has a border.
+When component controls are arranged in a container, the container control
+may need to know whether or not the components have borders, as this may affect
+the way the components are laid out within the container.
+The default implementation of this function returns EFalse, but can
+be overridden to provide the required functionality.
+@return ETrue if the control has a border, EFalse if the control does not
+have a border. The default implementation of this function returns
+EFalse. */
+	{
+	return EFalse;
+	}
+EXPORT_C TSize CCoeControl::MinimumSize()
+/** Sets the control's minimum required size.
+This function should be overridden by the concrete control class if the control
+is to be displayed inside a dialog. Standard GUI dialogs set the size and
+position of their components automatically, and use this function to enquire
+the minimum size that a control requires.
+Other container controls that automatically calculate the layout of their
+components may also use this function.
+@return The minimum size required by the control. */
+	{
+	// designed to be overridden
+	MCoeLayoutManager* layoutManager = LayoutManager();
+	if (layoutManager)
+		{
+		return layoutManager->CalcMinimumSize(*this);
+		}
+	return(iSize);
+	}
+EXPORT_C void CCoeControl::HandleComponentControlsResourceChange(TInt aType)
+/** Handles a change to the resources in the components of a compound control.
+@param aType A message UID value.
+@see HandleResourceChange() */
+	{
+	const TInt count=CountComponentControls();
+	for(TInt ii=0;ii<count;ii++)
+		{
+		CCoeControl* control = ComponentControl(ii);
+		if (control && control->iWin)
+			{
+			control->HandleResourceChange(aType);
+			}
+		}
+	}
+/** Sets a pointer to a MCoeControlBackground object that is responsible for
+drawing the control's background
+@param aBackground Pointer to an object that implements MCoeControlBackground
+@see CCoeControl::EnableWindowTransparency()
+@publishedAll
+@released
+*/
+EXPORT_C void CCoeControl::SetBackground(const MCoeControlBackground* aBackground)
+	{
+	if(DoSetBackground(iData->DynamicDataStorage(), aBackground) == KErrNoMemory)
+		iFlags |= EMemoryAllocationFailed;
+	}
+/**
+By default, all windows are opaque. This means that semi-transparent drawing
+performed into the window will blend with other content of that window, but not
+with the content of the window(s) behind. This acts as an important performance
+optimization, limiting the amount of drawing needed to update the screen.
+Call this method to allow semi-transparent drawing into the window to be blended
+with the content of the windows behind. (Because of the performance implications,
+be careful not to enable window transparency unless really required.)
+This will set the window to use the alpha channel information of the drawing
+performed into it, and set the initialize window background to fully transparent
+(before any drawing is made into it).
+Note that although the same effect can be achieved by calling the RWindow methods
+directly, calling this method instead will allow correct drawing of semi-transparent
+control backgrounds (see MCoeControlBackground).
+This method must only be called on (non-BackedUp) window owning controls.
+@see MCoeControlBackground
+@publishedAll
+*/
+EXPORT_C void CCoeControl::EnableWindowTransparency()
+	{
+__ASSERT_DEBUG(OwnsWindow(), Panic(ECoePanicControlNotWindowOwning));
+__ASSERT_DEBUG(!(iFlags&EBackedUpWindow), Panic(ECoePanicControlWindowIsBackedUp));
+RWindow& win = Window();
+win.SetTransparencyAlphaChannel();
+win.SetBackgroundColor(~0);
+iFlags |= EWindowIsSemiTransparent;
+}
+/** Set the zoom factor for this control.
+@param aZoomFactor Amount of zoom (multiplied by 1000)
+@param aZoomType Absolute or relative (EAbsoluteZoom or ERelativeZoom)
+@publishedAll
+@released
+*/
+EXPORT_C void CCoeControl::SetZoomFactorL(TInt aZoomFactor, TZoomType aZoomType)
+{
+TCoeZoomWithType* zoom = GetZoomWithType();
+if(!zoom)
+{
+zoom = new (ELeave) TCoeZoomWithType;
+CleanupStack::PushL(zoom);
+User::LeaveIfError(SetZoomWithType(zoom));
+CleanupStack::Pop();
+}
+zoom->iZoomFactor = aZoomFactor;
+zoom->iZoomType = aZoomType;
+HandleResourceChange(KUidValueCoeZoomChangeEvent);
+RequestRelayout(this);
+}
+/** Set the font provider. This is an external object that takes the responsibililty
+for finding an appropriate font away from the control.
+@param aFontProvider The provider to use.
+@publishedAll
+@released
+*/
+EXPORT_C void CCoeControl::SetFontProviderL(const CCoeFontProvider& aFontProvider)
+{
+User::LeaveIfError(SetFontProvider(&aFontProvider));
+HandleResourceChange(KUidValueCoeFontChangeEvent);
+RequestRelayout(this);
+}
+/** Return the zoom factor for this control. Takes account of zoom factors in parent controls
+to calculate accumulated zoom factor.
+@return Accumulated zoom factor.
+@publishedAll
+@released
+*/
+EXPORT_C TZoomFactor CCoeControl::AccumulatedZoom() const
+{
+TZoomFactor accZoomFactor(iCoeEnv->ScreenDevice());
+const TCoeZoomWithType* zoomWithType = NULL;
+const CCoeControl* parent = this;
+#ifdef _DEBUG
+TInt safetyCount = 100;
+#endif
+while(parent)        // Look for all zoom factors, all the way up. Don't stop at the first parent with one set.
+{
+zoomWithType = parent->GetZoomWithType();
+if(zoomWithType)
+{
+if(zoomWithType->iZoomType == ERelativeZoom)
+	{
+	accZoomFactor.SetZoomFactor(accZoomFactor.ZoomFactor() * zoomWithType->iZoomFactor / 1000);
+	}
+else
+{
+accZoomFactor.SetZoomFactor(zoomWithType->iZoomFactor * accZoomFactor.ZoomFactor() /1000);
+break;
+}
+}
+parent = parent->Parent();
+#ifdef _DEBUG
+safetyCount--;
+__ASSERT_DEBUG(safetyCount, Panic(ECoePanicCyclicParentChildRelationship));
+#endif
+}
+if(zoomWithType && (zoomWithType->iZoomType == ERelativeZoom))
+	{
+		accZoomFactor.SetZoomFactor(accZoomFactor.ZoomFactor() * iCoeEnv->ZoomFactor().ZoomFactor() / 1000);
+	}
+return accZoomFactor;
+}
+/** Return the zoom factor but without taking into account the
+zoom factor of the parent. Use of AccumulatedZoom() is recommended as it takes
+into account the zoom factor of the parent.
+@publishedAll
+@released
+*/
+EXPORT_C const TCoeZoomWithType* CCoeControl::ZoomWithType() const
+	{
+	return DoGetZoomWithType(iData->DynamicDataStorage());
+	}
+/** Return the font provider used by this control
+@return The font provider used by this control
+*/
+EXPORT_C const CCoeFontProvider& CCoeControl::FindFontProvider() const
+{
+const CCoeFontProvider* fontProvider = GetFontProvider();
+const CCoeControl* parent = Parent();
+#ifdef _DEBUG
+TInt safetyCount = 100;
+while(!fontProvider && parent)
+{
+fontProvider = parent->GetFontProvider();
+parent = parent->Parent();
+safetyCount--;
+__ASSERT_DEBUG(safetyCount, Panic(ECoePanicCyclicParentChildRelationship));
+}
+#else
+while(!fontProvider && parent)
+{
+fontProvider = DoGetFontProvider(parent->iData->DynamicDataStorage());
+parent = parent->Parent();
+}
+#endif
+return (!fontProvider ? CCoeEnv::Static()->DefaultFontProvider() : *fontProvider);
+}
+/** Returns the closest matching font from the control's current font provider to the
+requested logical font, taking into account the control's zoom factor.
+This function should be used in preference to legacy functions like
+CEikonEnv::LegendFont(), CCoeEnv::NormalFont() or CCoeEnv::CreateScreenFontL().
+Example 1:
+Instead of the control using a CFont class member, or calling NormalFont(),
+LegendFont() etc, it is recommended the control (e.g. in its Draw() method) call the
+new ScreenFont() method to temporarily access a CFont object owned by the font provider.
+This is a lot more efficient than repeatedly e.g. calling GetNearestFontInPixels(),
+and allows the CFont object used for text drawing to vary depending on the current
+zoom factor. Thus the CFont reference must not be kept as class member data, as it
+may be changed by the font provider at any time.
+@code
+CSomeControl::Draw(const TRect& aRect)
+	{
+	XCoeTextDrawer textDrawer(TextDrawer());
+	textDrawer.SetAlignment(EHCenterVCenter);
+	textDrawer.DrawText(gc, iText, aRect, ScreenFont(TCoeFont::LegendFont());
+	}
+@endcode
+Example 2:
+Although efficiently implemented, try not to call ScreenFont() or CCoeFontProvider::Font()
+repeatedly unnecessarily. Instead, create and use a local const CFont& on the stack,
+as shown below.
+Note that the ScreenFont() call above is provided as short-hand for the code on
+the first two lines below. Also note that font providers and zoom factors apply
+hieratically to the control tree (i.e. setting the zoom factor or font provider on
+a container control affects the child controls too).
+@code
+CSomeControl::Draw(const TRect& aRect)
+	{
+	const CCoeFontProvider& fontProvider = FindFontProvider();
+	const CFont& font = fontProvider.Font(TCoeFont::LegendFont(), AccumulatedZoom());
+	XCoeTextDrawer textDrawer(TextDrawer());
+	textDrawer.SetAlignment(EHCenterVCenter);
+	textDrawer.DrawText(gc, iText, aRect, font);
+textDrawer.DrawText(gc, iText2, aRect, font);
+}
+@endcode
+@param aFont Logical font to use.
+@see CCoeFontProvider
+@see TCoeFont
+*/
+EXPORT_C const CFont& CCoeControl::ScreenFont(const TCoeFont& aFont) const
+{
+TZoomFactor zoomFactor = AccumulatedZoom();
+return FindFontProvider().Font(aFont, zoomFactor);
+}
+/** Notify controls that the font has changed
+*/
+void CCoeControl::NotifyFontChange(const CCoeFontProvider* aFontProvider)
+{
+if(!IsActivated() || Rect().IsEmpty())
+	return;
+if(!aFontProvider)        // Notify on highest possible level
+{
+HandleResourceChange(KUidValueCoeFontChangeEvent);
+RequestRelayout(NULL);
+}
+else if(aFontProvider == GetFontProvider())        // Look for use of the font provider that changed
+{
+HandleResourceChange(KUidValueCoeFontChangeEvent);
+RequestRelayout(NULL);
+}
+else        // As long as we didn't find the right font provider, keep looking down the control tree
+{
+const TInt numControls = CountComponentControls();
+for(TInt i = 0; i < numControls; i++)
+{
+CCoeControl* control = ComponentControl(i);
+control->NotifyFontChange(aFontProvider);
+}
+}
+}
+/** Force all CCoeFontProviders to update their logical-to-pixel mapping from CCoeControlStaticSettings
+@internalTechnology
+*/
+void CCoeControl::RefetchPixelMappingL()
+	{
+	CCoeFontProvider* fontProvider = const_cast<CCoeFontProvider*>(GetFontProvider());
+	if(fontProvider)
+		{
+		fontProvider->RefetchPixelMappingL();
+		}
+	// and search for CCoeFontProvider's down the control tree
+	const TInt numControls = CountComponentControls();
+for(TInt i = 0; i < numControls; i++)
+	{
+CCoeControl* control = ComponentControl(i);
+control->RefetchPixelMappingL();
+}
+	}
+EXPORT_C void CCoeControl::HandleResourceChange(TInt aType)
+/** Handles a change to the control's resources.
+The types of resources handled are those which are shared across the environment,
+e.g. colours or fonts. For colour scheme changes, DrawDeferred() is called in
+order to redraw the control.
+If overriding HandleResourceChange(), the implementation must include a base call to CCoeControl's
+HandleResourceChange().
+@param aType A message UID value.
+@see HandleComponentControlsResourceChange() */
+	{
+	HandleComponentControlsResourceChange(aType);
+	if ((aType == KUidValueCoeColorSchemeChangeEvent) || (aType == KUidValueCoeZoomChangeEvent))
+		{
+		DrawDeferred();
+		}
+	}
+EXPORT_C void CCoeControl::GetColorUseListL(CArrayFix<TCoeColorUse>& /*aColorUseList*/) const
+/** Gets the list of logical colours used to draw the control.
+The list includes an explanation of how each colour is used.
+The default implementation is empty.
+If overriding GetColorUseListL(), the implementation must include a base call to CCoeControl's
+GetColorUseListL().
+@param aColorUseList The colour list. */
+	{
+	}
+EXPORT_C void CCoeControl::GetHelpContext(TCoeHelpContext& /*aContext*/) const
+/** Gets the control's help context.
+The default implementation is empty. The function must be implemented in
+derived classes to associate the control with a particular Help file and
+topic in a context sensitive application. The implementation should set
+the public data members of TCoeHelpContext to the required Help file UID
+and context descriptor, as created using the Context-Sensitive Help Compiler.
+@param aContext The control's help context */
+	{
+	}
+EXPORT_C void CCoeControl::ConstructFromResourceL(TResourceReader& /*aSource*/)
+/** Constructs the control from a resource file.
+This function has an empty default implementation. It should be implemented
+if the control is to be displayed within a dialog. It should initialise the
+control, reading in resource values from the resource file.
+Note: if a control is not displayed in a dialog, it is necessary to set the control's
+associated window using SetContainerWindowL(). Since this may leave, the control
+should be constructed using ConstructL().
+@param aSource The resource reader with which to access the control's resource
+values. */
+	{
+	}
+EXPORT_C RWindow& CCoeControl::Window() const
+/** Gets the control's associated window.
+The control must be window owning, and the window must be of type RWindow.
+If you don't know whether the window is of type RWindow or RBackedUpWindow,
+you should use DrawableWindow().
+@return The control's associated window, cast to an RWindow. */
+	{
+	return(STATIC_CAST(RWindow&,*iWin));
+	}
+EXPORT_C RBackedUpWindow& CCoeControl::BackedUpWindow() const
+/** Gets the backed-up window owned by the control.
+The window must be of type RBackedUpWindow. If you don't know whether the
+window is of type RWindow or RBackedUpWindow, you should use DrawableWindow().
+@return The control's associated window, cast to an RBackedUpWindow.
+@deprecated
+*/
+	{
+	return(STATIC_CAST(RBackedUpWindow&,*iWin));
+	}
+EXPORT_C void CCoeControl::CloseWindow()
+/** Closes the window owned by this control.
+It is called from CCoeControl's destructor for window-owning controls. */
+	{
+	__ASSERT_DEBUG(OwnsWindow(),Panic(ECoePanicNoWindow));
+	if (iWin)
+		{
+		iWin->Close();
+		delete(iWin);
+		iWin=NULL;
+		}
+	iFlags&=(~(EOwnsWindow|EBackedUpWindow|EActivated));
+	}
+EXPORT_C void CCoeControl::CreateBackedUpWindowL(RWindowTreeNode& aParent)
+/** Creates a control's window as a backed-up window.
+The new window is the child of aParent and the display mode of the control
+becomes the same as that of aParent.
+@param aParent The window to be the parent of this control's window. Does
+not have to be a backed-up window.
+@deprecated
+*/
+	{
+	if(iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	TInt colors=0;
+	TInt grays=0;
+	TDisplayMode defaultMode=iCoeEnv->WsSession().GetDefModeMaxNumColors(colors,grays);
+	CreateBackedUpWindowL(aParent,defaultMode);
+	}
+EXPORT_C void CCoeControl::CreateBackedUpWindowL(RWindowTreeNode& aParent,TDisplayMode aDisplayMode)
+/** Creates a control's window as a backed-up window.
+The new window is the child of aParent. Furthermore, the window's extent is set to that of the control.
+The window will have the same display mode as the system display mode (the provided aDisplayMode is ignored).
+@param aParent The window of the control to be the parent of this control.
+Does not have to be a backed-up window.
+@param aDisplayMode Ignored. The window will always be created with the system display mode.
+@deprecated
+*/
+	{
+	if(iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	__ASSERT_DEBUG(!OwnsWindow(), Panic(ECoePanicWindowAlreadyCreated));
+	iWin=new(ELeave) RBackedUpWindow(iCoeEnv->WsSession());
+	iFlags|=EOwnsWindow|EBackedUpWindow;
+	User::LeaveIfError(((RBackedUpWindow*)iWin)->Construct(aParent,aDisplayMode,(TUint32)this));
+	const TInt err = (static_cast<RBackedUpWindow*>(iWin))->SetExtentErr(iPosition,iSize);
+	if (err!=KErrNone)
+				iFlags|=EMemoryAllocationFailed;
+	}
+EXPORT_C void CCoeControl::CreateWindowL(RWindowTreeNode& aParent)
+/** Creates a control's window, specifying its parent window and its extent.
+This function makes the specified control a window-owning control, and would
+typically be called in the control's ConstructL() function. It also sets the window's extent to that of the control.
+Note:
+The use of window owning controls is discouraged, as these tax run-time resources.
+Ideally only the top level control in an appUi would be window owning. There
+are some exceptions to this rule, e.g. floating controls like menus, dialogs
+and scroll bars.
+In general, the overload with no parameters should be used.
+@param aParent The window of the control to be the parent of this control. */
+	{
+	if(iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	__ASSERT_DEBUG(!OwnsWindow(), Panic(ECoePanicWindowAlreadyCreated));
+	iWin=new(ELeave) RWindow(iCoeEnv->WsSession());
+	iFlags|=EOwnsWindow;
+	User::LeaveIfError(((RWindow*)iWin)->Construct(aParent,(TUint32)this));
+	(static_cast<RWindow*>(iWin))->SetExtent(iPosition,iSize);
+	}
+//
+// Overloaded member function which creates a containing window for the control to own. The window
+// containing the control aParent is used as the window's parent if the control pointer is not NULL.
+// Otherwise the root window will be used as parent.
+//
+EXPORT_C void CCoeControl::CreateWindowL(const CCoeControl* aParent)
+/** Creates a control's window, specifying the parent control.
+The control's window is created as a child of the parent control's window.
+This function makes the specified control a window-owning control, and would
+typically be called in the control's ConstructL() function.
+Note:
+The use of window owning controls is discouraged, as these tax run-time resources.
+Ideally only the top level control in an appUi would be window owning. There
+are some exceptions to this rule, e.g. floating controls like menus, dialogs
+and scroll bars.
+In general, the overload with no parameters should be used.
+@param aParent The control to be the parent of this control. */
+	{
+	SetMopParent(const_cast<CCoeControl*>(aParent));
+	User::LeaveIfError(SetParent(const_cast<CCoeControl*>(aParent)));
+	CreateWindowL(aParent? (RWindowTreeNode&)(*aParent->iWin): (RWindowTreeNode&)iCoeEnv->RootWin());
+	}
+//
+// Overloaded member function which creates a containing window for the control to own. The window
+// group aParent is used as the window's parent if it is not NULL. Otherwise the root window will be
+// used as the parent.
+//
+EXPORT_C void CCoeControl::CreateWindowL(RWindowGroup* aParent)
+/** Creates a control's window, specifying its parent window group.
+This function makes the specified control a window-owning control, and would
+typically be called in the control's ConstructL() function.
+Note:
+The use of window owning controls is discouraged, as these tax run-time resources.
+Ideally only the top level control in an appUi would be window owning. There
+are some exceptions to this rule, e.g. floating controls like menus, dialogs
+and scroll bars.
+In general, the overload with no parameters should be used.
+@param aParent The window group of the control to be the parent of this control */
+	{
+	CreateWindowL(aParent? (RWindowTreeNode&)(*aParent): (RWindowTreeNode&)iCoeEnv->RootWin());
+	}
+//
+// Overloaded member function which creates a containing window for the control to own. The root window is
+// used as a parent.
+//
+EXPORT_C void CCoeControl::CreateWindowL()
+/** Creates a control's window.
+The created window is the child of the application's window group.
+This function makes the specified control a window-owning control, and would
+typically be called in the control's ConstructL() function.
+Note:
+The use of window owning controls is discouraged, as these tax run-time resources.
+Ideally only the top level control in an appUi would be window owning. There
+are some exceptions to this rule, e.g. floating controls like menus, dialogs
+and scroll bars. */
+	{
+	CreateWindowL(iCoeEnv->RootWin());
+	}
+EXPORT_C void CCoeControl::HandleRedrawEvent(const TRect& aRect) const
+/** Handles redraw events.
+In normal circumstances this function should not be used or overridden by
+the derived control class.
+@param aRect The rectangle to be redrawn. */
+	{
+	Window().BeginRedraw(aRect);
+	if (IsReadyToDraw())
+		{
+		ActivateGc();
+		// Draw the background if found, but not if this is a semi-transparent window-owning control
+		// without its own background attached (or we risk drawing a semi-transparent skin multiple times)
+		if ((OwnsWindow() || Background()) && !(iFlags&EWindowIsSemiTransparent && !Background()))
+	{
+			const MCoeControlBackground* background = FindBackground();
+			if (background)
+				background->Draw(SystemGc(), *this, aRect);
+			}
+		Draw(aRect);
+		DrawComponents(aRect);
+		DeactivateGc();
+		}
+	Window().EndRedraw();
+	}
+void CCoeControl::DrawComponents(const TRect& aRect) const
+	{
+	CWindowGc* containerGc = CustomGc();
+	CWindowGc* gc = (containerGc ? containerGc : &SystemGc());
+	const TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		const CCoeControl* ctrl=ComponentControl(ii);
+		if (!(ctrl->OwnsWindow()) && ctrl->IsVisible())
+			{
+			TRect rect;
+			const TRect* pRect=(&aRect);
+			if (!((ctrl->iFlags)&ECanDrawOutsideRect))
+				{
+				rect=ctrl->Rect();
+				rect.Intersection(aRect);
+				if (rect.IsEmpty())
+					continue;
+				pRect=(&rect);
+				}
+			const MCoeControlBackground* background = ctrl->Background();
+			if(background) // ctrl is always non-window owning. Draw if it itself has background attached
+				background->Draw(*gc, *ctrl, *pRect);
+			if (iContext)
+				iContext->ResetContext(*gc);
+			else
+				gc->Reset();
+			ctrl->Draw(*pRect);
+			ctrl->DrawComponents(*pRect);
+			}
+		}
+	}
+EXPORT_C void CCoeControl::Draw(const TRect& aRect) const
+/** Draws the control.
+All controls, except blank controls, should implement this function. The default
+implementation draws a blank control.
+This function is called by window server. It is used for window server-initiated
+redrawing of controls, and for some application-initiated drawing. It should be
+implemented by each control, but is only called from within CCoeControl's member
+functions, and not from the derived class. For this reason it is a private member
+function of CCoeControl.
+The rectangle aRect indicates the region of the control that needs to be redrawn.
+The implementation of Draw() must always draw to every pixel within this rectangle.
+Notes:
+For non-window-owning controls, care must be taken not to draw outside the
+control, as drawing will not be clipped to the control. Drawing is clipped
+to window-owning-controls, but not to non-window-owning controls.
+Drawing outside aRect may cause flicker.
+Drawing should be done using a graphics context (CWindowGc), which can be
+obtained using SystemGc().
+@param aRect The region of the control to be redrawn. Co-ordinates are relative
+to the control's origin (top left corner). */
+	{
+	if (iFlags&EBlank)
+		{ // else do nothing
+		// If there is a background then it will be used
+		// to draw the background so don't blank the window
+		if(!FindBackground())
+			{
+			CGraphicsContext& gc=SystemGc();
+			gc.SetPenStyle(CGraphicsContext::ENullPen);
+			gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+		gc.DrawRect(aRect);
+			}
+		}
+	}
+EXPORT_C void CCoeControl::DrawNow() const
+/** Draws the entire control
+This function is called by an application or other code.
+The application should call this function when the control is first created
+and is ready for drawing, or if a change in application data or the control's
+internal state means that entire control's appearance is no longer up-to-date.
+Partial redrawing of a control is sometimes more appropriate than drawing
+the entire control, and in this case, use DrawNow(const TRect &aRect) instead.
+DrawNow() is implemented by CCoeControl and MAY NOT be overridden. It calls
+Draw() on the control itself, and also on all its component controls, if it
+is a compound control. (To do this it uses CountComponentControls() and ComponentControl(),
+which should be implemented by the derived control class.) If the control
+is a window-owning control, it also calls Draw() for its child windows (if
+any). */
+	{
+	DrawNow(Rect());
+	}
+/** Draws the control, its components and child windows, within the bounds defined by the given rectangle.
+@param aRect The rectangular region of the control to be drawn. */
+EXPORT_C void CCoeControl::DrawNow(const TRect &aRect) const
+	{
+	if (!IsReadyToDraw())
+		return;
+	TBool backedUp=IsBackedUp();
+	if (!backedUp)
+		{
+		Window().Invalidate(aRect);
+		Window().BeginRedraw(aRect);
+		}
+	const CCoeControl* parent = WindowOwningParent();
+	if (parent && parent->IsReadyToDraw())	// Parents should always be ready to draw, but there are flaky code out there...
+		{
+		__ASSERT_DEBUG(parent->OwnsWindow(), User::Invariant());
+		parent->ActivateGc();
+		const MCoeControlBackground* background = parent->FindBackground();
+		// Draw the background if found, but not if this is a semi-transparent window-owning control
+		// without its own background attached (or we risk drawing a semi-transparent skin multiple times)
+		if (background && !(iFlags&EWindowIsSemiTransparent && !Background()))
+			background->Draw(parent->SystemGc(), *parent, aRect);
+		parent->Draw(aRect);
+		parent->DrawComponents(aRect);
+		parent->DeactivateGc();
+		if (!backedUp)
+			Window().EndRedraw();
+		parent->DrawWindowOwningComponentsNow(aRect);
+		}
+	else
+		{
+		ActivateGc();
+		Draw(aRect);
+		DrawComponents(aRect);
+		DeactivateGc();
+		if (!backedUp)
+			Window().EndRedraw();
+		DrawWindowOwningComponentsNow(aRect);
+		}
+	}
+void CCoeControl::DrawWindowOwningComponentsNow(const TRect &aRect) const
+	{
+	const TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		CCoeControl* ctrl=ComponentControl(ii);
+		if (!ctrl->OwnsWindow())
+			{
+			ctrl->DrawWindowOwningComponentsNow(aRect);
+			}
+		else
+			{
+			TRect adjustedRect(aRect);
+const RWindow& parentWindow = Window();
+const RDrawableWindow& childWindow = *(ctrl->DrawableWindow());
+if (parentWindow.WsHandle() != childWindow.WsHandle())
+				{
+const TPoint childRelativePos = childWindow.InquireOffset(parentWindow);
+// Adjust the parent referenced rectangle to the child window co-ordinates
+adjustedRect.Move(-childRelativePos);
+}
+else
+{
+// As the child owns the window, the parent is a lodger of the child, so allow for the parent position
+adjustedRect.Move(-iPosition);
+}
+adjustedRect.Intersection(ctrl->Rect());
+if (!adjustedRect.IsEmpty())
+				{
+ctrl->DrawNow(adjustedRect);
+}
+			}
+		}
+	}
+EXPORT_C void CCoeControl::DrawDeferred() const
+/** Draws the control, with low priority.
+This function is called by an application or other code.
+It causes the control area to be marked as invalid, which will
+eventually cause a redraw initiated by the window server. The control framework
+handles redraw events at a lower priority than user input events, which means
+that any pending user input events will be processed before the redraw event.
+DrawDeferred() therefore allows a control to do drawing at a lower priority
+than drawing performed by DrawNow().
+An advantage of using DrawDeferred() is that if you make multiple calls to
+DrawDeferred() on the same area of a control, the window server will not generate
+a redraw event to do drawing that has already been superceded. If you make
+multiple calls to DrawNow(), however, all of them get processed, even if they
+have already been superceded by the time they are processed. */
+	{
+	if (!IsReadyToDraw())
+		return;
+	if (IsBackedUp())
+		DrawNow();
+	else
+		Window().Invalidate(Rect());
+	const TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		const CCoeControl* ctrl=ComponentControl(ii);
+		if (ctrl->OwnsWindow())
+			ctrl->DrawDeferred();
+		}
+	}
+/** Find a control in the parent chain (including this) that owns a window
+*/
+CCoeControl* CCoeControl::WindowOwningParent()
+	{
+	CCoeControl* parent = this;	// start with this, in case it is window owning
+#ifdef _DEBUG
+	TInt safetyCount = 100;
+#endif
+	while(parent && !parent->OwnsWindow())
+		{
+		parent = parent->Parent();
+#ifdef _DEBUG
+		--safetyCount;
+		ASSERT(safetyCount);
+#endif
+		}
+	return parent;
+	}
+/** Returns the background drawer object associated with this object, if any.
+Null is returned if there is no such object. Compare with FindBackground(), which looks up the parent chain
+to find a background drawer.
+@return The background drawer object associated with this object. */
+EXPORT_C const MCoeControlBackground* CCoeControl::Background() const
+	{
+	return DoGetBackground(iData->DynamicDataStorage());
+	}
+/** Return an MCoeControlBackground object, if there is one - looking up
+the parent chain as necessary. Compare to Background(), which does not
+go up the parent chain.
+*/
+EXPORT_C const MCoeControlBackground* CCoeControl::FindBackground() const
+	{
+	const MCoeControlBackground* background = Background();
+	const CCoeControl* parent = Parent();
+#ifdef _DEBUG
+	TInt safetyCount = 100;
+#endif
+	while(!background && parent)
+		{
+		background = parent->Background();
+		parent = parent->Parent();
+#ifdef _DEBUG
+		safetyCount--;
+		ASSERT(safetyCount);
+#endif
+		}
+	return background;
+	}
+/** Sets aParent as the parent of this control.
+If setting aParent as parent of this control will create a cyclic relationship,
+this method does nothing.
+@param aParent The control to set as this control's parent.
+@return KErrNone if successful, otherwise another of the system error codes.
+*/
+EXPORT_C TInt CCoeControl::SetParent(CCoeControl* aParent)
+	{
+	if(aParent)	// Check for cyclic relationships only if parent is not being set to NULL
+		{
+		const CCoeControl* parent = aParent->SearchParent(this);
+		// If "parent" is non-NULL, it means that "this" is already a parent of aParent.
+		// Such circularity should not occur...
+		if(parent)				// ...but because there are bad controls out there (like CEikButtonGroupContainer)...
+			return KErrNone;	// ...do nothing, to avoid creating a cyclic parent-child relationship.
+		}
+	const TInt err = DoSetParent(iData->DynamicDataStorage(), aParent);
+	if(err)
+		 iFlags |= EMemoryAllocationFailed;	// Doom the control
+	return err;
+	}
+/** Safety check to avoid loops in the parent chain.
+*/
+const CCoeControl* CCoeControl::SearchParent(const CCoeControl* aParentToFind) const
+	{
+	const CCoeControl* parent = this;
+#ifdef _DEBUG
+	TInt safetyCount = 100;
+#endif
+	while (parent && parent != aParentToFind)
+		{
+		parent = parent->Parent();
+#ifdef _DEBUG
+		--safetyCount;
+		ASSERT(safetyCount);
+#endif
+		}
+	return parent;
+	}
+/**
+Sets the control's custom graphics context. This value overrides the system context for
+this control and any children.
+If aGraphicsContext is null, the control's graphics context is reset to the one it inherited
+from its parent, or to the default system graphics context (iCoeEnv->SystemGc()) if none of
+its parents have set their own graphics context.
+This value is retrieved by CCoeControl::SystemGc().
+@param aGraphContext The new graphics context for this class and its children.
+The caller keeps ownership.
+*/
+EXPORT_C TInt CCoeControl::SetCustomGc(CWindowGc* aGraphicsContext)
+	{
+	return DoSetCustomGc(iData->DynamicDataStorage(), aGraphicsContext);
+	}
+/**
+Returns the custom graphics context set for this control (if any). Note that unlike
+CCoeControl::SystemGc(), this function ignores the parent window's state and
+returns the context set explicitly for this control instance, or NULL if none has been set.
+@return The current graphics context.
+*/
+EXPORT_C CWindowGc* CCoeControl::CustomGc() const
+	{
+	return DoGetCustomGc(iData->DynamicDataStorage());
+	}
+/** Draws the control's background using its graphics context.
+Unlike DrawNow() and DrawDeferred(), this function does not propagate
+the draw to component controls.
+@param aRect The area to be redrawn. This can be the control's entire rectangle, or a
+sub-rectangle within it.
+*/
+EXPORT_C void CCoeControl::DrawBackground(const TRect& aRect) const
+	{
+	CWindowGc& gc=SystemGc();
+	const MCoeControlBackground* theBackground = Background();
+	if(theBackground)
+		{
+		theBackground->Draw(gc, *this, aRect);
+		}
+	}
+/** Draws the control's foreground using the control's graphics context.
+Unlike DrawNow() and DrawDeferred(), this function does not propagate the draw to component controls.
+@param aRect The area to be redrawn. This can be the control's entire rectangle, or a
+sub-rectangle within it.
+*/
+EXPORT_C void CCoeControl::DrawForeground(const TRect& aRect) const
+	{
+	Draw(aRect);
+	}
+/** Installs a hit tester for this control. The tester defines the hit region,
+which is the area within the control that accepts pointer events. If no hit region is set,
+pointer events are accepted in the control's entire rectangle.
+@param aHitTestControl Object which defines the hit region.
+@return KErrNone if successful, or another system error code.
+*/
+EXPORT_C TInt CCoeControl::SetHitTest(const MCoeControlHitTest* aHitTestControl)
+	{
+	return DoSetHitTest(iData->DynamicDataStorage(), aHitTestControl);
+	}
+/** Gets the object that defines the hit region inside the control's rectangle.
+The object is set by calling SetHitTest().
+@return The hit region tester.
+*/
+EXPORT_C const MCoeControlHitTest* CCoeControl::HitTest() const
+	{
+	return DoGetHitTest(iData->DynamicDataStorage());
+	}
+TCoeZoomWithType* CCoeControl::GetZoomWithType() const
+	{
+	return DoGetZoomWithType(iData->DynamicDataStorage());
+	}
+TInt CCoeControl::SetZoomWithType(TCoeZoomWithType* aZoomWithType)
+	{
+	return DoSetZoomWithType(iData->DynamicDataStorage(), aZoomWithType);
+	}
+const CCoeFontProvider* CCoeControl::GetFontProvider() const
+	{
+	return DoGetFontProvider(iData->DynamicDataStorage());
+	}
+TInt CCoeControl::SetFontProvider(const CCoeFontProvider* aFontProvider)
+	{
+	return DoSetFontProvider(iData->DynamicDataStorage(), aFontProvider);
+	}
+EXPORT_C CWindowGc& CCoeControl::SystemGc() const
+/** Gets the graphics context that is used when drawing the control.
+This function walks the CCoeControl hierarchy upwards from child to parent until a context
+is found. If no control in the hierarchy has defined its own graphics context, the default system
+graphics context (iCoeEnv->SystemGc()) is returned.
+All drawing is carried out through a graphics context. A graphics context
+must be activated before it can be drawn to, and deactivated
+when it is no longer needed. When drawing is done using Draw(), DrawNow()
+or DrawDeferred(), the application does not have to do this, as it is done
+within the control framework. However, for application-initiated drawing which
+is not done using DrawNow() or DrawDeferred(), the application should activate
+and deactivate the graphics context using ActivateGc() and DeactivateGc()
+(or CWindowGc::Activate() and CWindowGc::Deactivate()).
+@return The system graphics context. */
+	{
+	const CCoeControl* theControl = this;
+	do
+		{
+		CWindowGc* customGc = DoGetCustomGc(theControl->iData->DynamicDataStorage());
+		if(customGc)
+			return *customGc;
+		}
+	while((theControl=theControl->Parent()) != NULL);
+	return(iCoeEnv->SystemGc());
+	}
+EXPORT_C void CCoeControl::ActivateGc() const
+/** Activates the standard graphics context.
+This is the graphics context owned by the control environment (CCoeEnv).
+Applications do not normally need to call this function, as it is called
+by the control framework whenever it is about to call Draw(). */
+	{
+	CWindowGc& gc=SystemGc();
+	if (iContext)
+		iContext->ActivateContext(gc,*iWin);
+	else
+		gc.Activate(*iWin);
+	ActivateGcRecursive();
+	}
+void CCoeControl::ActivateGcRecursive() const
+	{
+	const TInt numComponentControls = CountComponentControls();
+	for(TInt i = numComponentControls - 1; i >= 0; i--)
+		{
+		const CCoeControl* control = ComponentControl(i);
+		if(control)
+			{
+			CWindowGc* redirectedgc = control->CustomGc();
+			CWindowGc* containerGc = CustomGc();
+			const TBool swapGc = (redirectedgc && (redirectedgc != containerGc));
+			if(swapGc)
+				{
+				if(iContext)
+					{
+					iContext->ActivateContext(*redirectedgc,*DrawableWindow());
+					}
+				else
+					{
+					redirectedgc->Activate(*DrawableWindow());
+					}
+				}
+			control->ActivateGcRecursive();
+			}
+		}
+	}
+EXPORT_C void CCoeControl::ResetGc() const
+/** Resets the standard graphics context.
+The function resets the graphics context owned by the control environment
+to its default settings. */
+	{
+	CWindowGc& gc=SystemGc();
+	if (iContext)
+		iContext->ResetContext(gc);
+	else
+		gc.Reset();
+	}
+EXPORT_C void CCoeControl::DeactivateGc() const
+/** Deactivates the standard graphics context owned by the UI control framework.
+Applications do not normally need to call this function, as it is called
+by the control framework whenever it has called Draw() and drawing is completed. */
+	{ // no harm done if Gc other than system one used
+	SystemGc().Deactivate();
+	DeactivateGcRecursive();
+	}
+void CCoeControl::DeactivateGcRecursive() const
+	{
+	TInt numComponentControls = CountComponentControls();
+	for(TInt i = numComponentControls - 1; i >= 0; i--)
+		{
+		const CCoeControl* control = ComponentControl(i);
+		if(control)
+			{
+			CWindowGc* redirectedgc = control->CustomGc();
+			CWindowGc* containerGc = CustomGc();
+			const TBool swapGc = (redirectedgc && (redirectedgc != containerGc));
+			if(swapGc)
+				{
+				redirectedgc->Deactivate();
+				}
+			control->DeactivateGcRecursive();
+			}
+		}
+	}
+EXPORT_C void CCoeControl::SetFocus(TBool aFocus,TDrawNow aDrawNow)
+/** Sets this control to have the keyboard focus.
+It sets the value of a focus flag within the control to the value
+given by aFocus. This flag indicates whether or not the control has keyboard
+focus, and its value can be enquired using IsFocused(). It then calls FocusChanged(),
+passing it the value given by aDrawNow, unless the control is invisible or
+not activated, in which case it passes ENoDrawNow.
+Note that setting focus does not initiate a redraw. The control's implementation
+of FocusChanged() should do this if required. The control's Draw() function,
+or that of its container, should normally change the appearance of the control
+to indicate whether or not it currently has focus.
+@param aFocus ETrue sets the control as having keyboard focus, EFalse sets
+it as not having keyboard focus.
+@param aDrawNow Flag to pass to FocusChanged(). */
+	{
+	iCoeEnv->QueueNotificationToFocusObserversOfChangeInFocus();
+	if (aFocus)
+		{
+		iFlags|=EFocused;
+		iFlags&=(~ENotifyFocusObserversOnDestruction);
+		}
+	else
+		{
+		if (iFlags&EFocused)
+			{
+			iFlags&=(~EFocused);
+			if(DoSetFocusObserverNotificationIdentifier(iData->DynamicDataStorage(), iCoeEnv->FocusObserverNotificationIdentifier()) == KErrNoMemory)
+				iFlags|=ENotifyFocusObserversOnDestruction;
+			else
+				iFlags&=(~ENotifyFocusObserversOnDestruction);
+			}
+		}
+	if (aDrawNow && !IsReadyToDraw())
+		aDrawNow=ENoDrawNow;
+	FocusChanged(aDrawNow);
+	}
+EXPORT_C void CCoeControl::FocusChanged(TDrawNow /*aDrawNow*/)
+/** Responds to a change in focus.
+This is called whenever the control gains or loses focus, as a result
+of a call to SetFocus(). A typical use of FocusChanged() is to change the
+appearance of the control, for example by drawing a focus rectangle around it.
+The default implementation is empty, and should be overridden by the CCoeControl-derived
+class.
+@param aDrawNow Contains the value that was passed to it by SetFocus(). */
+	{
+	}
+void CCoeControl::ReportControlStateChange(MCoeControlStateObserver::TCoeState aType)
+/** Reports a change in the controls visibility or dimmed state to the Mop Framework
+Looks for an object through the Mop framework both starting at this control and from the
+control enviroment.  Calls them both if they provide different objects.*/
+	{
+	if(iFlags&EReportControlStateChange && iCoeEnv->ControlStateChange())	//Do control state change only if it is enabled
+		{
+		MCoeControlStateObserver* stateObserver1=NULL;
+		MCoeControlStateObserver* stateObserver2=NULL;
+		iCoeEnv->MopGetObjectNoChaining(stateObserver1);
+		MopGetObject(stateObserver2);
+		if (stateObserver1)
+			stateObserver1->HandleControlStateChange(this,aType);	//Ignore returned error code
+		if (stateObserver2 && stateObserver1!=stateObserver2)
+			stateObserver2->HandleControlStateChange(this,aType);	//Ignore returned error code
+		}
+	}
+TInt CCoeControl::ValidateAdvancedPointerNumber( const TPointerEvent& aPointerEvent ) const
+/** Determines that the pointer-number in an advanced-pointer-event is within the supported range.
+@param aPointerEvent the TPointerEvent reference to be validated.
+@return KErrArgument if the pointer-number is out of range of the supported number of pointers.
+*/
+	{
+	TInt err = KErrNone;
+	// Called only for advancedpointerevent so AdvancedPointerEvent()->PointerNumber() is safe
+	if( aPointerEvent.AdvancedPointerEvent()->PointerNumber() >= ControlEnv()->SupportedPointers() )
+		{
+		err = KErrArgument;
+		}
+	return err;
+	}
+EXPORT_C void CCoeControl::SetDimmed(TBool aDimmed)
+/** Sets the control to be dimmed.
+This function sets a flag within the control which indicates whether or not
+the control is dimmed (greyed out). This is typically used to show that the
+control is temporarily unavailable.
+SetDimmed() does not initiate a redraw of the control. The application should
+call DrawNow() or DrawDeferred() if a redraw is required after calling SetDimmed().
+The control's Draw() function should draw the control appropriately according
+to whether it is dimmed or not. (This can be enquired using IsDimmed().)
+If overriding SetDimmed(), the implementation must include a base call to CCoeControl's
+SetDimmed().
+@param aDimmed ETrue to dim the control, EFalse to set the control as not
+dimmed. */
+	{
+	if (!(iFlags&EDimmed)==!aDimmed)
+		return;
+	if (aDimmed)
+		iFlags|=EDimmed;
+	else
+		iFlags&=(~EDimmed);
+	ReportControlStateChange(MCoeControlStateObserver::EStateDimmed);
+	}
+void CCoeControl::SetGrabbed(TBool aGrabbed, TInt aPointerNumber)
+/** Sets the control to grab pointer events
+*/
+	{
+	if (aGrabbed)
+		{
+		// sets pointer grab flag for given pointer number
+		iData->SetPointerGrab( (1 << aPointerNumber), 0 );
+		}
+	else
+		{
+		iData->SetPointerGrab( 0, (1 << aPointerNumber) );
+		}
+	}
+EXPORT_C void CCoeControl::MakeVisible(TBool aVisible)
+/** Sets this control as visible or invisible.
+This causes the control to disappear or reappear. When a control is created,
+it is made visible by default.
+MakeVisible() can be called before or after the control is activated.
+Notes:
+This function may be overridden.
+The visibility of the control can be queried using IsVisible().
+If MakeVisible() is used to make a component visible, and the control captures
+the pointer (see CapturesPointer()), MakeVisible() throws away any pending
+pointer events for that control.
+Typical uses are for scrollbars, or for dialogs where some user responses
+are not required in certain circumstances.
+@param aVisible ETrue to make the control visible, EFalse to make it invisible. */
+	{
+	DoMakeVisible(aVisible);
+	if (iFlags&ECapturesPointer)
+		CheckPointerEventPurge();
+	}
+void CCoeControl::DoMakeVisible(TBool aVisible)
+	{
+	TBool isVisible=IsVisible();
+	if ((isVisible && aVisible) || (!isVisible && !aVisible))
+		return;		// No change
+	if (aVisible)
+		iFlags&=(~EInvisible);
+	else
+		iFlags|=EInvisible;
+	if (OwnsWindow())
+		iWin->SetVisible(aVisible);
+	else if (IsActivated())
+		{
+		if (IsBackedUp())
+			DrawNow();
+		else
+			Window().Invalidate(Rect());
+		}
+	if (iFlags&EComponentsInheritVisibility)
+		{
+		const TInt count=CountComponentControls();
+		for (TInt ii=0; ii<count; ii++)
+			ComponentControl(ii)->MakeVisible(aVisible);
+		}
+	ReportControlStateChange(MCoeControlStateObserver::EStateVisibility);
+	}
+EXPORT_C void CCoeControl::SetComponentsToInheritVisibility(TBool aInherit)
+/** Sets the control's components to inherit the visibility setting of their
+container control.
+If set, when MakeVisible() is called on the compound control, the visibility
+setting is propagated to all its components.
+@param aInherit If ETrue, the control's components inherit its visibility
+setting; if EFalse they do not. */
+	{
+	if (aInherit)
+		iFlags|=EComponentsInheritVisibility;
+	else
+		iFlags&=(~EComponentsInheritVisibility);
+	}
+EXPORT_C TCoeInputCapabilities CCoeControl::InputCapabilities() const
+/** Gets the control's input capabilities.
+Classes that override CCoeControl::OfferKeyEventL() should also override this
+function, returning a TCoeInputCapabilities object whose attributes correspond
+to the behaviour of the OfferKeyEventL() function. The default implementation
+returns TCoeInputCapabilities::ENone.
+It is not necessary to call InputCapabilities() on any component controls
+from inside a class's InputCapabilities() function. This is done automatically
+by the UI Control Framework.
+@return The control's input capabilities. */
+	{
+	return TCoeInputCapabilities(TCoeInputCapabilities::ENone);
+	}
+EXPORT_C void CCoeControl::SetGloballyCapturing(TBool aGlobal)
+/** Sets the global pointer capture flag.
+This flag indicates whether or not pointer capture should be global.
+The flag is used by SetPointerCapture() to determine what value to pass to
+RWindowBase::SetPointerCapture(). The default for the global capture flag,
+when a control is created, is EFalse.
+@param aGlobal Value for global capture flag. */
+	{
+	if (aGlobal)
+		iFlags|=EGloballyCapturing;
+	else
+		iFlags&=(~EGloballyCapturing);
+	}
+EXPORT_C void CCoeControl::SetNonFocusing()
+/** Deprecated. Use SetFocusing().
+Sets the control as unable to receive keyboard focus. The function would typically
+be called during construction of the control. */
+	{
+	iFlags|=ENonFocusing;
+	}
+EXPORT_C void CCoeControl::SetFocusing(TBool aFocusing)
+/** Sets the control as able to receive keyboard focus.
+@param aFocusing ETrue if the control can have focus, EFalse if it can't. */
+	{
+	if (aFocusing)
+		iFlags&=(~ENonFocusing);
+	else
+		iFlags|=ENonFocusing;
+	}
+EXPORT_C TBool CCoeControl::IsNonFocusing() const
+/** Tests if the control can receive focus.
+@return ETrue if the control cannot receive focus, EFalse if it can.
+@see SetNonFocusing() */
+	{
+	return(iFlags&ENonFocusing);
+	}
+EXPORT_C void CCoeControl::SetAllowStrayPointers()
+/** Sets whether or not to allow stray pointer events.
+This function sets a flag that affects the way the control framework handles
+pointer events. By default, the flag is not set, and the control will ignore
+any pointer drag events and up events where the matching pointer down event
+occurred in a different control. This would happen if a user pressed the pointer
+down in a control, but then dragged the pointer into a different control before
+releasing it.
+SetAllowStrayPointers() is typically used for menus, where stray pointer events
+are required because it is the pointer up event that is used to activate a
+menu option even when the pointer down event occured in a different menu pane.
+This is not the case in some other components such as command buttons,
+where a pointer down event and up event in succession are required to activate
+the button. */
+	{
+	iFlags|=EAllowStrayPointers;
+	}
+EXPORT_C void CCoeControl::SetCanDrawOutsideRect()
+/** Allows the control to draw outside its own extent.
+When a compound control is drawn, all its component controls are also drawn.
+However, unless this flag is set, they are not drawn if the rectangle they
+inhabit on the screen doesn't intersect with the rectangle to be drawn.
+Setting this flag has the effect of allowing a component control to draw outside
+its own extent. It should be used with caution! By default, this flag is not
+set. */
+	{
+	iFlags|=ECanDrawOutsideRect;
+	}
+EXPORT_C void CCoeControl::SetBlank()
+/** Sets a flag to indicate that the control is blank.
+Once set, this flag cannot be unset for the lifetime of the control.
+@see IsBlank() */
+	{
+	iFlags|=EBlank;
+	}
+EXPORT_C void CCoeControl::SetRect(const TRect& aRect)
+/** Sets the control's extent, specifying a rectangle.
+Note: calling this function results in a call to SizeChanged().
+@param aRect The rectangle that defines the control's extent. The rectangle's
+origin is relative to the origin of its associated window. */
+	{
+	SetExtent(aRect.iTl,aRect.Size());
+	}
+EXPORT_C void CCoeControl::SetExtentToWholeScreen()
+/** Sets the control's extent to the whole screen.
+Note: calling this function results in a call to SizeChanged(). */
+	{
+	SetExtent(TPoint(0,0),iCoeEnv->ScreenDevice()->SizeInPixels());
+	}
+EXPORT_C void CCoeControl::SetExtent(const TPoint& aPosition,const TSize& aSize)
+/** Sets the control's extent, specifying a size and a position.
+Note: calling this function results in a call to SizeChanged().
+@param aPosition The position of the control, relative to its associated window.
+@param aSize The size of the control, in pixels. */
+	{
+	if (OwnsWindow())
+		{
+		if (IsBackedUp())
+			{
+			const TInt err=iWin->SetExtentErr(aPosition,aSize);
+			if (err!=KErrNone)
+				iFlags|=EMemoryAllocationFailed;	// Doom the control
+			}
+		else
+			Window().SetExtent(aPosition,aSize);
+		}
+	iPosition=aPosition;
+	iSize=aSize;
+	SizeChanged();
+	}
+EXPORT_C void CCoeControl::SizeChanged()
+/** Responds to changes to the size and position of the contents of this control.
+For a simple control this might include text or graphics. For a compound control
+it sets the size and position of the components.
+The function is called whenever SetExtent(), SetSize(), SetRect(), SetCornerAndSize(),
+or SetExtentToWholeScreen() are called on the control. Note that the window
+server does not generate size-changed events: SizeChanged() gets called only
+as a result of calling the functions listed above. Therefore, if a resize
+of one control affects the size of other controls, it is up to the application
+to ensure that it handles the re-sizing of all affected controls. */
+	{
+	MCoeLayoutManager* layout = LayoutManager();
+	if (layout)
+		{
+		layout->PerformLayout();
+		}
+	}
+EXPORT_C void CCoeControl::PositionChanged()
+/** Responds to changes in the position of a control.
+It has an empty default implementation which may be overridden by the CCoeControl-derived
+class.
+This function is called whenever the application calls SetPosition() on
+the control. */
+	{
+	}
+EXPORT_C void CCoeControl::SetSize(const TSize& aSize)
+/** Sets the control's size.
+If the size, but not the position, of a control is set, then its position
+will default to TPoint(0,0).
+Note: calling this function results in a call to SizeChanged().
+@param aSize The control's size, in pixels. */
+	{
+	SetSizeWithoutNotification(aSize);
+	SizeChanged();
+	}
+EXPORT_C TInt CCoeControl::SetMaximumWidth(TInt aMaxWidth)
+/** Sets the controls maximum width.
+@param aMaxWidth The control's maximum width.
+@return  Error Code. (KErrNone if max width was set successfully) */
+	{
+	//  Set the maximum width value
+	return DoSetMaximumWidth(iData->DynamicDataStorage(), aMaxWidth);
+	}
+EXPORT_C void CCoeControl::SetPosition(const TPoint& aPosition)
+/** Sets the control's position.
+If the control owns its containing window, it achieves this by setting the position of the window.
+Otherwise, the position of the control is set relative to its containing window. The
+positions of the control's components are adjusted accordingly and PositionChanged()
+is called.
+@param aPosition The position of the the top-left of the control, relative to its
+associated window. */
+	{
+	if (OwnsWindow())
+		{
+		iPosition=aPosition;
+		iWin->SetPosition(aPosition);
+		}
+	else
+		{
+		const TPoint delta=aPosition-iPosition;
+		iPosition=aPosition;
+		const TInt count=CountComponentControls();
+		for (TInt ii=0;ii<count;ii++)
+			{
+			CCoeControl* ctrl=ComponentControl(ii);
+			const TPoint pos=ctrl->Position();
+			ctrl->SetPosition(pos+delta);
+			}
+		}
+	PositionChanged();
+	}
+/** Sets a control's size without calling SizeChanged().
+If the size, but not the position, of a control is set, then its position
+will default to TPoint(0,0).
+@param aSize The control's size, in pixels.
+@see SetSize() */
+EXPORT_C void CCoeControl::SetSizeWithoutNotification(const TSize& aSize)
+	{
+	if (OwnsWindow())
+		{
+		if (IsBackedUp())
+			{
+			const TInt err=iWin->SetSizeErr(aSize);
+			if (err!=KErrNone)
+				iFlags|=EMemoryAllocationFailed;	// Doom the control
+			}
+		else
+			Window().SetSize(aSize);
+		}
+	iSize=aSize;
+	}
+/** Creates a component array to store child controls.
+This function is useful when the control is a compound control. It creates an array where the
+child controls can be stored. The CCoeControl::Components return the created array. The CCoeControlArray class
+provides functions to easily add and remove controls.
+*/
+EXPORT_C void CCoeControl::InitComponentArrayL()
+	{
+	CCoeControlArray* array = DoGetComponentArray(iData->DynamicDataStorage());
+	if(!array)
+		{
+		array = CCoeControlArray::NewL(*this);
+		if(DoSetComponentArray(iData->DynamicDataStorage(), array) != KErrNone)
+			{
+			delete array;
+			User::LeaveNoMemory();
+			}
+		}
+	}
+/** Returns a component array to store child controls.
+This function is useful when the control is a compound control. The CCoeControlArray class
+provides functions to easily add and remove controls. The array must have been created before
+this function can be called. The InitComponentArrayL does this.
+@return The control array
+@see CCoeControl::InitComponentArrayL()
+*/
+EXPORT_C CCoeControlArray& CCoeControl::Components()
+	{
+	return *DoGetComponentArray(iData->DynamicDataStorage());
+	}
+/** Returns a component array to store child controls.
+This function is useful when the control is a compound control. The CCoeControlArray class
+provides functions to easily add and remove controls. The array must have been created before
+this function can be called. The InitComponentArrayL does this.
+@return The control array
+@see CCoeControl::InitComponentArrayL()
+*/
+EXPORT_C const CCoeControlArray& CCoeControl::Components() const
+	{
+	return *DoGetComponentArray(iData->DynamicDataStorage());
+	}
+/** Handles events generated by the CCoeControlArray.
+This function is useful when the control is a compound control and the CCoeControlArray functionality is used.
+The CCoeControlArray functions that add and remove controls will use this event handler to notify the
+control that child controls have been added or removed.
+The default implementation of this function forwards the events to the layout manager (if there is one). If the
+event is EControlAdded it also sets the container window of the new child control unless the child control is a window
+owning control. If the event is EControlRemoved it also sets the parent of the removed child control to null.
+@param aEvent The type of the event
+@param aArray The array that generated the event
+@param aControl The control affected by the event
+@param aControlId The id of the control affected by the event
+*/
+EXPORT_C void CCoeControl::HandleControlArrayEventL(CCoeControlArray::TEvent aEvent, const CCoeControlArray* aArray,
+													CCoeControl* aControl, TInt /*aControlId*/)
+	{
+	if (aArray != &Components())
+		return; 	// some other array
+	switch(aEvent)
+		{
+		case CCoeControlArray::EControlAdded:
+			{
+			__ASSERT_DEBUG(aControl->Parent() == NULL || aControl->Parent() == this, Panic(ECoePanicIncorrectControlParent));
+			__ASSERT_DEBUG(DrawableWindow(), Panic(ECoePanicNoWindow));	// Make sure the container window is set
+			if(!aControl->OwnsWindow())
+				aControl->SetContainerWindowL(*this);
+			MCoeLayoutManager* layoutManager = LayoutManager();
+			if(layoutManager)
+				layoutManager->HandleAddedControlL(*this, *aControl);
+			}
+			break;
+		case CCoeControlArray::EControlRemoved:
+			{
+			MCoeLayoutManager* layoutManager = LayoutManager();
+			if(layoutManager)
+				layoutManager->HandleRemovedControl(*this, *aControl);
+			aControl->SetParent(NULL);
+			}
+			break;
+		default:
+			ASSERT(0);
+		}
+	}
+/** Gets an indexed component of a compound control.
+There are 2 ways to implement a compound control. One way is to override this function. The other way
+is to use the CCoeControlArray functionality (see the InitComponentArrayL method).
+Note: within a compound control, each component control is identified by an index,
+where the index depends on the order the controls were added: the first is
+given an index of 0, the next an index of 1, and so on.
+@param aIndex The index of the control.
+@return The component control with an index of aIndex.
+*/
+EXPORT_C CCoeControl* CCoeControl::ComponentControl(TInt aIndex) const
+	{
+	CCoeControlArray* components = DoGetComponentArray(iData->DynamicDataStorage());
+	return ( components ? components->At(aIndex).iControl : NULL );
+	}
+EXPORT_C void CCoeControl::ActivateL()
+/** Sets the control as ready to be drawn.
+The application should call this function on all controls that are not components
+in a compound control.
+The purpose of this function is that controls are not always ready to be drawn
+as soon as they have been constructed. For example, it may not be possible
+to set the control's extent during construction, but its extent should always
+be set before it is drawn. Similarly, if a control is to be made invisible,
+this should be done before it is activated.
+The default implementation sets a flag in the control to indicate it is ready
+to be drawn. If the control is a compound control, the default implementation
+also calls ActivateL() for all the control's components. To get the control's
+components it uses CountComponentControls() and ComponentControl(), which
+should be implemented by the compound control.
+ActivateL() is typically called from the control's ConstructL() function .
+Notes:
+This function can be overridden. This is useful for doing late initialisation
+of the control, using information that was not available at the time the control
+was created. For example, a text editor might override ActivateL() and use it
+to enquire whether it is focused: if it is, it makes the cursor and any highlighting
+visible. At the time when the editor is created, it doesn't know whether or
+not it has keyboard focus.
+If overriding ActivateL(), the implementation must include a base call to CCoeControl's
+ActivateL().*/
+	{
+	if (iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	if (!(iFlags&EActivated))
+		{
+		iFlags|=EActivated;
+		if (OwnsWindow())
+			{
+			iWin->Activate();
+			if (iFlags&ECapturesPointer)
+				CheckPointerEventPurge();
+			if (IsBackedUp())
+				DrawNow();
+			}
+		iData->AttemptCompress();	// Purge any unused member data memory
+		}
+	const TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		CCoeControl* child = ComponentControl(ii);
+		if(!child->Parent())
+			child->SetParent(this);		// Set the parent if not already set
+		child->ActivateL();
+		}
+	}
+EXPORT_C TRect CCoeControl::Rect() const
+/** Gets the control's extent.
+The position of the top-left of the rectangle is (0,0) if the control owns its
+window. Otherwise, its position is relative to its window.
+@return The control's extent. */
+	{
+	return(TRect(OwnsWindow()? TPoint(0,0): iPosition,iSize));
+	}
+EXPORT_C void CCoeControl::SetContainerWindowL(const CCoeControl& aContainer)
+/** Sets the control's containing window by copying it from aContainer.
+It also copies the control context from aContainer if one has not previously been set.
+This function can only be called on non-window-owning (or 'lodger') controls.
+If overriding SetContainerWindowL(), the implementation must include a base call to CCoeControl's
+SetContainerWindowL().
+@param aContainer The compound control that is the container for this control. */
+	{
+	if(iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	if(OwnsWindow())
+CloseWindow();
+	iWin = aContainer.iWin;
+	if (!iContext)
+		iContext = aContainer.iContext;
+	if (aContainer.IsBackedUp())
+		iFlags |= EBackedUpWindow;
+	SetMopParent(const_cast<CCoeControl*>(&aContainer));
+	User::LeaveIfError(SetParent(const_cast<CCoeControl*>(&aContainer)));
+	}
+EXPORT_C void CCoeControl::SetContainerWindowL(RWindow& aWindow)
+/** Sets the control's containing window, without transferring ownership
+of the window to this control.
+This function can only be called on non-window-owning ('lodger') controls.
+Note: the container's window can be accessed using Window(), DrawableWindow(), or
+BackedUpWindow().
+@param aWindow The window owned by the container control. */
+	{
+	if(iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	if(OwnsWindow())
+CloseWindow();
+	iWin=&aWindow;
+	}
+EXPORT_C void CCoeControl::SetContainerWindowL(RBackedUpWindow& aWindow)
+/** Sets the control's containing window without transferring ownership
+of the window to this control.
+The function can only be called on non-window-owning ('lodger') controls.
+Note: the container's window can be accessed using Window(), DrawableWindow(), or
+BackedUpWindow().
+@param aWindow The backed up window owned by the container control.
+@deprecated
+*/
+	{
+	if(iFlags&EMemoryAllocationFailed)
+		User::LeaveNoMemory();
+	if(OwnsWindow())
+CloseWindow();
+	iWin=&aWindow;
+	iFlags|=EBackedUpWindow;
+	}
+EXPORT_C void CCoeControl::SetCornerAndSize(TGulAlignment aCorner,const TSize& aSize)
+/** Sets the control's alignment and size.
+The control's position is calculated, relative to the screen, according to
+the requested alignment.
+Note: calling this function results in a call to SizeChanged().
+@param aCorner The alignment of the control.
+@param aSize The control's size. */
+	{ // the following assumes the window is being positioned wrt the screen
+	TPoint pos=aCorner.InnerTopLeft(iCoeEnv->ScreenDevice()->SizeInPixels(),aSize);
+	SetExtent(pos,aSize);
+	}
+/** Gets the number of controls contained in a compound control.
+There are 2 ways to implement a compound control. One way is to override this function. The other way
+is to use the CCoeControlArray functionality (see the InitComponentArrayL method).
+@return The number of component controls contained by this control. */
+EXPORT_C TInt CCoeControl::CountComponentControls() const
+	{
+	CCoeControlArray* components = DoGetComponentArray(iData->DynamicDataStorage());
+	return ( components ? components->Count() : 0 );
+	}
+EXPORT_C void CCoeControl::EnableDragEvents()
+/** Requests pointer drag events.
+This function should be called if a control is required to receive pointer
+drag and move events. The default behaviour for all controls is that pointer
+drag and move events are not delivered.
+The control framework does not provide a function to disable drag events at
+a later time, but this can be done via the Window Server API, by calling Window()->PointerFilter().
+Note:
+By default, pointer move events are not delivered, even after calling EnableDragEvents(),
+because they are not normally required in a pen-based system. The window server
+can be configured to deliver pointer move events if required, e.g. for a mouse-based
+system.
+@see RWindowBase::PointerFilter() */
+	{
+	const TInt KPointerFilterBitsAllClear = 0;
+	iWin->PointerFilter(EPointerFilterDrag, KPointerFilterBitsAllClear);
+	}
+EXPORT_C void CCoeControl::SetPointerCapture(TBool aCapture)
+/** Sets pointer capture.
+Once set, pointer capture lasts until SetPointerCapture() is called on the
+control with aCapture=EFalse.
+This function is typically used by dialogs, to discard any pointer events
+that occur outside of the dialog.
+@param aCapture If ETrue, passes the following value as the argument to
+RWindowBase::SetPointerCapture(): RWindowBase::TCaptureFlagAllGroups|RWindowBase::TCaptureFlagEnabled,
+if the control's global capture flag is set to ETrue (see SetGloballyCapturing())
+or RWindowBase::TCaptureFlagEnabled if the control's global capture flag is
+set to EFalse. If EFalse, passes EFalse as the argument to RWindowBase::SetPointerCapture().
+@see RWindowBase::SetPointerCapture() */
+	{
+	TInt captureFlags=0;
+	iFlags&=(~ECapturesPointer);
+	if (aCapture)
+		captureFlags=(iFlags&EGloballyCapturing? RWindowBase::TCaptureFlagAllGroups|RWindowBase::TCaptureFlagEnabled: RWindowBase::TCaptureFlagEnabled);
+	iWin->SetPointerCapture(captureFlags);
+	if (aCapture)
+		{
+		iFlags|=ECapturesPointer;
+		CheckPointerEventPurge();
+		}
+	}
+EXPORT_C TBool CCoeControl::CapturesPointer() const
+/** Tests whether pointer capture is set for the control.
+This returns true if SetPointerCapture() has been called with aCapture=ETrue.
+@return ETrue if pointer capture is set. EFalse if it isn't. */
+	{
+	return iFlags&ECapturesPointer;
+	}
+void CCoeControl::CheckPointerEventPurge() const
+	{
+	if (IsReadyToDraw())
+		iCoeEnv->WsSession().PurgePointerEvents();
+	}
+EXPORT_C TInt CCoeControl::Index(const CCoeControl* aControl) const
+/** Gets the index of a control that is a component of this control.
+@param aControl The component control.
+@return The index of the component control within the compound control, or
+KErrNotFound if aControl is not a component of this control. */
+	{
+	TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		if (aControl==ComponentControl(ii))
+			return(ii);
+		}
+	return(KErrNotFound);
+	}
+EXPORT_C void CCoeControl::SetControlContext(MCoeControlContext* aContext)
+/** Set the control context for this control.
+@param aContext The context for this control. */
+	{
+	iContext=aContext;
+	}
+EXPORT_C void CCoeControl::CopyControlContextFrom(const CCoeControl* aControl)
+/** Sets the control's context from another control.
+@param aControl The control whose context is copied. */
+	{
+	iContext=aControl->iContext;
+	}
+EXPORT_C MCoeControlContext* CCoeControl::ControlContext() const
+/** Gets the control context being used by this control.
+The function does not transfer ownership to the caller.
+@return The control context. */
+	{
+	return iContext;
+	}
+EXPORT_C CCoeControl* CCoeControl::GrabbingComponent() const
+/** Returns the component of this control which is grabbing the pointer
+in systems implementing a single pointer. Or in a multi-pointer system where
+single-pointer emulation is enabled on this control's window.
+@return The component control that is currently grabbing the pointer. If no
+component of this control is grabbing the pointer, or if this
+is not a compound control, the function returns NULL. */
+	{
+	return GrabbingComponent(TAdvancedPointerEvent::EDefaultPointerNumber);
+	}
+EXPORT_C CCoeControl* CCoeControl::GrabbingComponent(TInt aPointer) const
+/** Returns the component of this control which is grabbing the specified pointer.
+This method is to be used on controls who's window has multiple-pointer events enabled.
+@return The component control that is currently grabbing the pointer. If no
+component of this control is grabbing the pointer, or if this
+is not a compound control, the function returns NULL. */
+	{
+	const TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		{
+		CCoeControl* ctrl=ComponentControl(ii);
+		if ( ctrl && ctrl->IsGrabbed(aPointer) )
+			{
+			return(ctrl);
+			}
+		}
+	return(NULL);
+	}
+TInt CCoeControl::FindColor(TInt aLogicalColor) const
+	{
+	CArrayFix<SColorOverride>* colorOverrides = DoGetColorOverrides(iData->DynamicDataStorage());
+	if(colorOverrides)
+		{
+		TInt pos;
+		TKeyArrayFix key(4,ECmpTInt);
+		SColorOverride override;
+		override.iLogicalColor=aLogicalColor;
+		override.iColor=TRgb(); // ignore the actual color
+		if (colorOverrides->Find(override,key,pos)==KErrNone)
+			return pos;
+		}
+	return KErrNotFound;
+	}
+EXPORT_C void CCoeControl::OverrideColorL(TInt aLogicalColor,TRgb aColor)
+/** Overrides the control's colour setting, as specified in the application's colour
+scheme.
+This function does not change the application's colour scheme. It changes
+the colour mapping used in this control only.
+@param aLogicalColor The logical colour. Indicates which part of a control
+the physical colour maps to. The set of logical colours for a standard application
+are defined in TLogicalColor.
+@param aColor The new physical colour to which the logical colour should be
+mapped.
+@see GetColor() */
+	{
+	CArrayFix<SColorOverride>* colorOverrides = DoGetColorOverrides(iData->DynamicDataStorage());
+	if (!colorOverrides)
+		{
+		colorOverrides=new(ELeave) CArrayFixFlat<SColorOverride>(2);
+		if(DoSetColorOverrides(iData->DynamicDataStorage(), colorOverrides) == KErrNoMemory)
+			{
+			delete colorOverrides;
+			User::LeaveNoMemory();
+			}
+		}
+	SColorOverride override;
+	override.iLogicalColor=aLogicalColor;
+	override.iColor=aColor;
+	const TInt index=FindColor(aLogicalColor);
+	if (index==KErrNotFound)
+		colorOverrides->AppendL(override);
+	else
+		(*colorOverrides)[index]=override;
+	const TInt count=CountComponentControls();
+	for (TInt ii=0; ii<count; ii++)
+		ComponentControl(ii)->OverrideColorL(aLogicalColor,aColor);
+	}
+EXPORT_C TBool CCoeControl::GetColor(TInt aLogicalColor,TRgb& aColor) const
+/** Gets the overridden physical colour.
+This is the colour which has been mapped to the logical colour specified by
+a call to OverrideColorL(). If the logical colour specified has not been overridden,
+the aColor value is not changed.
+@param aLogicalColor The logical colour for which the corresponding physical
+colour will be retrieved. The set of logical colours for a standard GUI application
+are defined in TLogicalColor.
+@param aColor On return, contains the physical colour which has been mapped
+to aLogicalColour by a call to OverrideColorL().
+@return ETrue if aLogicalColour has been overridden, EFalse otherwise. */
+	{
+	CArrayFix<SColorOverride>* colorOverrides = DoGetColorOverrides(iData->DynamicDataStorage());
+	if(!colorOverrides)
+		return EFalse;
+	const TInt index=FindColor(aLogicalColor);
+	if(index==KErrNotFound)
+		return EFalse;
+	aColor=(*colorOverrides)[index].iColor;
+	return ETrue;
+	}
+/**
+Gets the input capabilities of the control and all its components.
+@since     6.0
+@return   "TCoeInputCapabilities"
+The input capabilities of the control.
+*/
+void CCoeControl::RecursivelyMergeInputCapabilities(TCoeInputCapabilities& aInputCapabilities) const
+	{
+	if (!IsBeingDestroyed())
+		{
+		if (IsFocused())
+			{
+			aInputCapabilities.MergeWith(InputCapabilities());
+			}
+		for (TInt i=CountComponentControls()-1; i>=0; --i)
+			{
+			ComponentControl(i)->RecursivelyMergeInputCapabilities(aInputCapabilities);
+			}
+		}
+	}
+/** Gets the input capabilities of the control and all its components.
+@return The input capabilities of the control. */
+EXPORT_C TCoeInputCapabilities CCoeControl::RecursivelyMergedInputCapabilities() const
+	{
+	TCoeInputCapabilities inputCapabilities(TCoeInputCapabilities::ENone);
+	RecursivelyMergeInputCapabilities(inputCapabilities);
+	return inputCapabilities;
+	}
+#ifndef _DEBUG
+void CCoeControl::WriteInternalStateNowL(RWriteStream&) const
+	{}
+#else
+void CCoeControl::WriteInternalStateNowL(RWriteStream& aWriteStream) const
+	{
+	WriteInternalStateL(aWriteStream);
+	}
+#endif
+#ifdef _DEBUG
+/** Writes the internal state of the control and its components to aWriteStream.
+Does nothing in release builds.
+This function is designed to be overidden and base called by subclasses
+wishing to output state information.
+If overriding WriteInternalStateL(), the implementation must include a base call to CCoeControl's
+WriteInternalStateL().*/
+EXPORT_C void CCoeControl::WriteInternalStateL(RWriteStream& aWriteStream) const
+	{
+	_LIT8(KCoeLitControlSt,"<CCoeControl>\r\n");
+	_LIT8(KCoeLitControlEnd,"</CCoeControl>\r\n");
+	TBuf8<100> element;
+	aWriteStream.WriteL(KCoeLitControlSt);
+	_LIT8(KCoeLitPosition, "<iPosition iX=\"%d\" iY=\"%d\"/>\r\n");
+	element.Format(KCoeLitPosition,iPosition.iX,iPosition.iY);
+	aWriteStream.WriteL(element);
+	_LIT8(KCoeLitSize, "<iSize iWidth=\"%d\" iHeight=\"%d\"/>\r\n");
+	element.Format(KCoeLitSize,iSize.iWidth,iSize.iHeight);
+	aWriteStream.WriteL(element);
+	// extension stuff
+	_LIT8(KCoeLitFlags, "<Flags value=\"0x%08x\"/>\r\n");
+	element.Format(KCoeLitFlags,iFlags);
+	aWriteStream.WriteL(element);
+	_LIT8(KCoeLitColors, "<ColorOverrides>\r\n");
+	_LIT8(KCoeLitColorsEnd, "</ColorOverrides>\r\n");
+	aWriteStream.WriteL(KCoeLitColors);
+	CArrayFix<SColorOverride>* colorOverrides = DoGetColorOverrides(iData->DynamicDataStorage());
+	if (colorOverrides)
+		{
+		TBuf8<8> integer;
+		const TInt count=colorOverrides->Count();
+		for(TInt i=0; i<count; i++)
+			{
+			const SColorOverride& colOvrride=(*colorOverrides)[i];
+			integer.Num(MAKE_TINT64(0,colOvrride.iColor.Color16M()));
+			aWriteStream.WriteL(integer);
+			integer.Num(MAKE_TINT64(0,colOvrride.iLogicalColor));
+			aWriteStream.WriteL(integer);
+			}
+		}
+	aWriteStream.WriteL(KCoeLitColorsEnd);
+	const TInt components=CountComponentControls();
+	_LIT8(KCoeLitComponent,"<Component>\r\n");
+	_LIT8(KCoeLitComponentEnd,"</Component>\r\n");
+	//
+	for(TInt i=0;i<components;i++)
+		{
+		aWriteStream.WriteL(KCoeLitComponent);
+		//
+		ComponentControl(i)->WriteInternalStateL(aWriteStream);
+		//
+		aWriteStream.WriteL(KCoeLitComponentEnd);
+		}
+	aWriteStream.WriteL(KCoeLitControlEnd);
+	}
+#else
+EXPORT_C void CCoeControl::WriteInternalStateL(RWriteStream&) const
+	{}
+#endif
+EXPORT_C void CCoeControl::Reserved_2()
+	{
+	}
+/** Sets the context - that is, the enclosing parent control - for this control.
+If setting aParent as MopParent of this control creates a cyclic relationship,
+this method will do nothing.
+@param aParent The parent object which is the context for the control. */
+EXPORT_C void CCoeControl::SetMopParent(MObjectProvider* aParent)
+	{
+	if (aParent)
+		{
+		const MObjectProvider* mopParent = aParent->FindParent(static_cast<MObjectProvider*>(this));
+		if (mopParent)
+			return;
+		}
+	iMopParent = aParent;
+	}
+/** Retrieves an object of the same type as that encapsulated in aId.
+This function is used to allow controls to ask their owners for access to
+other objects that they own.
+Other than in the case where NULL is returned, the object returned must be
+of the same object type - that is, the ETypeId member of the object pointed
+to by the pointer returned by this function must be equal to the iUid member
+of aId.
+@param aId An encapsulated object type ID.
+@return Encapsulates the pointer to the object provided. Note that the encapsulated
+pointer may be NULL. */
+EXPORT_C TTypeUid::Ptr CCoeControl::MopSupplyObject(TTypeUid /*aId*/)
+	{
+	return TTypeUid::Null();
+	}
+/** Retrieves the control's parent.
+This function may be overridden to continue the
+chain of object providers which are to be asked to supply an object.
+When overriding this function for any given class of control, it is important
+to ensure that the function does not return, either directly or indirectly,
+a pointer to the instance of that class on which the function was called.
+For example, suppose that bar is an object of class foo. The override for
+the class foo could legitimately return a pointer to the object provider in
+which bar is contained, but must never return a pointer either to bar or to
+an object provider which may return bar. Failure to observe this restriction
+may result in an infinite loop.
+@return A pointer to an object provider, or NULL if none is defined.
+@publishedAll
+@released */
+EXPORT_C MObjectProvider* CCoeControl::MopNext()
+	{
+	return iMopParent;
+	}
+// TEXT DRAWER
+/**
+Gets the text drawer to be used for the control.
+This method returns a reference simply because the return value must never be NULL.
+The ownership transfer rules of the returned CCoeTextDrawerBase object obey specific rules.
+If the CCoeTextDrawerBase::IsReusable() flag is set then the caller must call Reset when the object
+is not needed anymore else it should simply delete the object. The XCoeTextDrawer class is a wrapper
+around the CCoeTextDrawerBase that will implement this logic automatically.
+The method will start with the default text drawer.
+It then allows  the childs background control to change the text drawer if the child itself is window owning.
+Otherwise only the  parent control can change the text drawer.
+@param aKey This parameter can be used by clients that need some custom behaviour. The framework
+doesn't use this parameter.
+@return reference to a CCoeTextDrawerBase object
+*/
+EXPORT_C CCoeTextDrawerBase& CCoeControl::TextDrawer(TInt aKey) const
+	{
+	// Get the default text drawer
+	CCoeTextDrawerBase* textDrawer = &iCoeEnv->DefaultTextDrawer();
+	// Retrieve a background object
+	const MCoeControlBackground* background = FindBackground();
+	// Let the text drawer be updated according to the background object
+	if(background)
+		background->GetTextDrawer(textDrawer, this);
+	// Let the text drawer be updated according to the text drawers of the
+	// parent hierarchy.
+	RecursivelyMergeTextDrawers(textDrawer, this, aKey);
+	return *textDrawer;
+	}
+/**
+This method recursively merges the control's parents' text drawers if it is non-window owning. If a parent control creates
+a new text drawer, this method makes sure that the old one is deleted or reset.
+@param aTextDrawer reference to the CCoeTextDrawerBase object to be updated
+@param aKey TInt
+@return void
+*/
+void CCoeControl::RecursivelyMergeTextDrawers(CCoeTextDrawerBase*& aTextDrawer,
+	const CCoeControl* aDrawingControl, TInt aKey) const
+	{
+	const CCoeControl* parent = Parent();
+	if(parent && !OwnsWindow())
+		parent->RecursivelyMergeTextDrawers(aTextDrawer, aDrawingControl, aKey);
+	CCoeTextDrawerBase* oldTextDrawer = aTextDrawer;
+	GetTextDrawer(aTextDrawer, aDrawingControl, aKey);
+	if(!aTextDrawer)	// in case allocation of new text drawer failed
+		aTextDrawer = oldTextDrawer;
+	if(aTextDrawer != oldTextDrawer)	// delete or reset the old text drawer
+										// if a new one was created
+		{
+		if(!oldTextDrawer->IsReusable())
+			delete oldTextDrawer;
+		else
+			oldTextDrawer->Reset();
+		}
+	}
+/**
+Controls that want to change or replace the text drawer that it or its children
+controls use shall override this method. The aTextDrawer argument is guaranteed
+never to be NULL, and the control can choose to modify it or create a new
+text drawer in its place.
+*/
+EXPORT_C void CCoeControl::GetTextDrawer(CCoeTextDrawerBase*& /*aTextDrawer*/, const CCoeControl* /*aDrawingControl*/, TInt /*aKey*/) const
+	{}
+EXPORT_C CCoeControl* CCoeControl::Parent()
+	{
+	return DoGetParent(iData->DynamicDataStorage());
+	}
+EXPORT_C const CCoeControl* CCoeControl::Parent() const
+	{
+	return DoGetParent(iData->DynamicDataStorage());
+	}
+/**
+Gets the offset to the first text baseline relative to the top of the control.
+The default implementation calls CalcTextBaselineOffset of the layout manager if
+one is installed. It returns 0 if no layout manager is installed.
+Derived classes that don't want to use the layout manager and still want to
+return a baseline offset should re-implement this function.
+@param aRect The offset of the baseline may depend on the size of the control. This argument specifies the size to use when computing the baseline offset.
+@return The offset of the baseline from the top of the control.
+*/
+EXPORT_C TInt CCoeControl::TextBaselineOffset(const TSize& aSize) const
+	{
+	TInt retval = 0;
+	if(LayoutManager())
+		retval = LayoutManager()->CalcTextBaselineOffset(*this, aSize);
+	return retval;
+	}
+/**
+Sets the spacing between text baselines.
+The default implementation calls SetTextBaselineSpacing of the layout manager if one is installed. It does nothing if there is no layout manager.
+Derived classes that don't want to use the layout manager and still want to do something when the this function is called should re-implement it.
+@param aBaselineSpacing The baseline spacing i.e. the space in pixels between the text baselines.
+*/
+EXPORT_C void CCoeControl::SetTextBaselineSpacing(TInt aBaselineSpacing)
+	{
+	if(LayoutManager())
+		LayoutManager()->SetTextBaselineSpacing(aBaselineSpacing);
+	}
+/**
+* Returns a Unique Handle (identifier) previously allocated to the control.
+*
+* @see SetUniqueHandle
+* @return Previously allocated value.
+*/
+EXPORT_C TInt CCoeControl::UniqueHandle() const
+	{
+	return DoGetUniqueHandle(iData->DynamicDataStorage());
+	}
+/**
+* Sets a Unique Handle (identifier).  That the number is unique is the perogative
+* of the caller!
+*
+* @see UniqueHandle()
+* @param a number.  This number is used to identify this control
+* @return Standard error code
+*/
+EXPORT_C TInt CCoeControl::SetUniqueHandle( TInt aUniqueHandle )
+	{
+	return DoSetUniqueHandle(iData->DynamicDataStorage(), aUniqueHandle);
+	}
+/** Sets the layout manager
+If the control already has a layout manager, its <code>MCoeLayoutManager::Detatch()</code> is called.
+<code>MCoeLayoutManager::Attach()</code> is called on <code>aLayout</code>
+The control doesn't take ownership of the Layout manager.
+@see MCoeLayoutManager::Attach
+@param aLayout The new layout manager, <code>NULL</code> if you just want to remove the current
+layout manager.
+*/
+EXPORT_C void CCoeControl::SetLayoutManagerL(MCoeLayoutManager* aLayout)
+	{
+	MCoeLayoutManager* layout = LayoutManager();
+	if (layout)
+		layout->Detach(*this);
+	User::LeaveIfError(DoSetLayoutManager(iData->DynamicDataStorage(), NULL));
+	if (aLayout)
+		aLayout->AttachL(*this);
+	User::LeaveIfError(DoSetLayoutManager(iData->DynamicDataStorage(), aLayout));
+	}
+/** Gets the layout manager
+@return The current layout manager, or <code>NULL</code> if the control has no layout manager
+*/
+EXPORT_C MCoeLayoutManager* CCoeControl::LayoutManager() const
+	{
+	// Try to retrieve the layout manager if one has been set, otherwise return NULL.
+	return DoGetLayoutManager(iData->DynamicDataStorage());
+	}
+/** Requests a relayout
+The default implementation is to call the parents <code>RequestRelayout()</code>.
+Should normally be overridden by top-level controls, such as scrollable containers. Classes that
+override this function must ensure that they don't cause infinite loops, since a relayout might
+cause calls to <code>RequestRelayout()</code> itself, This might be solved like this:
+@code
+TBool CAnyControl::RequestRelayout(const CCoeControl* aChildControl)
+	{
+	if(iRelayoutInProgress) return EFalse;
+	iRelayoutInProgress = ETrue;
+	//perform the relayout
+	iRelayoutInProgress = EFalse;
+	return ETrue;
+	}
+@endcode
+When the request is addressed the requesting control knows that its <code>SizeChanged()</code>
+will be called.
+@param aChildControl The child control that requests the relayout, might be <code>NULL</code>
+@return <code>ETrue</code> if the request is addressed, otherwise <code>EFalse</code>
+*/
+EXPORT_C TBool CCoeControl::RequestRelayout(const CCoeControl* aChildControl)
+	{
+	TBool reqComplete = EFalse;
+	if(aChildControl && !aChildControl->IsActivated())
+		{
+		reqComplete = EFalse;
+		}
+	else if(Parent())
+		{
+		reqComplete = Parent()->RequestRelayout(this);
+		}
+	return reqComplete;
+	}
+void CCoeControl::RemoveFromParent()
+	{
+	CCoeControl* parent = Parent();
+	if (parent)
+		{
+		parent->Components().Remove(this);
+		}
+	}
+/**
+Set the status of the report control state change.
+@param aState Set the state as Enable or Disable to control the report control state change.
+@see SetDimmed(), MakeVisible()
+*/
+EXPORT_C void CCoeControl::EnableReportControlStateChange(TBool aState)
+	{
+	if(aState)
+		{
+		iFlags |= EReportControlStateChange;
+		}
+	else
+		{
+		iFlags &= ~EReportControlStateChange;
+		}
+	}
+/** @internalComponent */
+EXPORT_C void CCoeControl::Reserved_CCoeControl_8()
+	{
+	}
+/** @internalComponent */
+EXPORT_C void CCoeControl::Reserved_CCoeControl_9()
+	{
+	}
+/** @internalComponent */
+EXPORT_C void CCoeControl::Reserved_CCoeControl_10()
+	{
+	}
+/** @internalComponent */
+EXPORT_C void CCoeControl::Reserved_CCoeControl_11()
+	{
+	}
+/** @internalComponent */
+EXPORT_C void CCoeControl::Reserved_CCoeControl_12()
+	{
+	}
+/** @internalComponent */
+EXPORT_C void CCoeControl::Reserved_CCoeControl_13()
+	{
+	}
+/**
+Default empty method.
+@param aTextDrawer Not used.
+@param aDrawingControl Not used.
+*/
+EXPORT_C void MCoeControlBackground::GetTextDrawer(CCoeTextDrawerBase*& /*aTextDrawer*/, const CCoeControl* /*aDrawingControl*/) const
+{}
+// For future use
+EXPORT_C  void MCoeControlBackground::MCoeControlBackground_Reserved1() {}
+EXPORT_C  void MCoeControlBackground::MCoeControlBackground_Reserved2() {}
+EXPORT_C  void MCoeControlBackground::MCoeControlBackground_Reserved3() {}
+EXPORT_C  void MCoeControlBackground::MCoeControlBackground_Reserved4() {}
+EXPORT_C  void MCoeControlBackground::MCoeControlBackground_Reserved5() {}
+//
+// From coecntrl.h (MCoeLayoutManager)
+//
+EXPORT_C MCoeLayoutManager::MCoeLayoutManager() : iMCoeLayoutManager_Reserved1(0) {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_1() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_2() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_3() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_4() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_5() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_6() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_7() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_8() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_9() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_10() {}
+EXPORT_C void MCoeLayoutManager::Reserved_MCoeLayoutManager_11() {}
+//
+// From coecntrl.h (MCoeControlBackground)
+//
+EXPORT_C MCoeControlBackground::MCoeControlBackground()	{}
+//
+// From coecntrl.h (MCoeControlHitTest)
+//
+EXPORT_C MCoeControlHitTest::MCoeControlHitTest() : iMCoeControlHitTest_Reserved1(0) {}
+EXPORT_C void MCoeControlHitTest::MCoeControlHitTest_Reserved1() {}
+EXPORT_C void MCoeControlHitTest::MCoeControlHitTest_Reserved2() {}
+//
+// From coecobs.h (MCoeControlObserver)
+//
+EXPORT_C MCoeControlObserver::MCoeControlObserver() : iMCoeControlObserver_Reserved1(0) {}
+EXPORT_C void MCoeControlObserver::MCoeControlObserver_Reserved1() {}
+EXPORT_C void MCoeControlObserver::MCoeControlObserver_Reserved2() {}

changeset 0	2f259fa3e83a
child 6	9f56a4e1b8ab