/*
* Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
* which accompanies this distribution, and is available
* at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#ifndef __AKNAPPUI_H__
#define __AKNAPPUI_H__
// INCLUDES
#include <eikappui.h>
#include <Eikspane.h>
#include <eikcba.h>
#include <avkon.hrh>
#include <akndef.h>
#include <AknTouchPaneObserver.h>
// FORWARD DECLARATIONS
class CEikButtonGroupContainer;
class CAknAppShutter;
class CAknAppUiExtension;
class CAknWsEventMonitor;
class CAknKeySoundSystem;
class CAknAppUiBaseExtension;
class CAknTouchPane;
class CAknToolbar;
class CAknPointerEventModifier;
// MACROS
#define iAvkonAppUi ((CAknAppUi*)CEikonEnv::Static()->EikAppUi())
#define iAvkonAppUiBase ((CAknAppUiBase*)CEikonEnv::Static()->EikAppUi())
/**
* Avkon key resolver interface
*
* @since S60 3.1
*/
class MAknAliasKeyCodeResolver
{
public:
/**
* Resolves keyboard layout dependent keycode for the given event
*
* @since S60 3.1
* @param aCode reference to variable to contain new keycode
* @param aKeyEvent reference to original, complete, event
* @param aType indicating original event type
* @return KErrNone on success, otherwise system wide error codes
*/
virtual TInt GetAliasKeyCode(TUint& aCode, const TKeyEvent& aKeyEvent,TEventCode aType)=0;
};
// CLASS DECLARATION
/**
* Abstract Avkon application UI base class
*
* @since S60 3.0
*/
class CAknAppUiBase : public CEikAppUi
{
private:
friend class CAknAppUi;
enum
{
EAppOrientationSpecifiedFlag = 0x00010000, // In area reserved for System Guis
EAppOrientationLandscapeFlag = 0x00020000,
EAppOrientationAutomaticFlag = 0x00040000,
EAknEnableSkinFlag = 0x00080000,
// Since 3.0
EAknDisableHighlightAnimationFlag = 0x00100000,
EAknEnableMSKflag = 0x00200000,
/**
* When enabled, avkon does not complete startup effect
* application has to do it by itself.
*
* @since S60 3.2
*
*/
EAknExplicitStartupEffectCompletionFlag = 0x00400000,
/**
* Application supports touch (doesn't need keyboard). If the flag
* is missing and compatibility mode is enabled in a device,
* application is run in a compatibility mode (QVGA window with a
* virtual keypad.
*
* @since S60 5.0
*/
EAknTouchCompatibleFlag = 0x00800000
};
public:
enum TAppUiOrientation
{
/**
* Use the default device screen rotation of the product for this
* application. This is the default rotation setting for an
* application, and it should be used by nearly all applications.
*/
EAppUiOrientationUnspecified,
/**
* Use a portrait screen rotation for this application.
* This should only be used when an application specifically wants
* portrait rotation. The device will select an appropriate portrait
* rotation, if one is available.
*/
EAppUiOrientationPortrait,
/**
* Use a landscape screen rotation for this application.
* This should only be used when an application specifically wants
* landscape rotation. The device will select an appropriate landscape
* rotation, if one is available.
*/
EAppUiOrientationLandscape,
/**
* Use the normal device screen rotation for this application.
* Both portrait and landscape screen rotations are possible. The
* application rotation follows device screen rotation.
*/
EAppUiOrientationAutomatic
};
enum
{
/**
* Flag indicating that default skin parameters should be provided by
* UI controls created within the scope of this AppUi instance.
* This value (or binary combination with some other values) should
* be given as a parameter to <code>BaseConstructL</code> in case
* the application wants to enable default skin parameters for all
* the Avkon controls supporting them.
*
* Note: The value can be queried by using
* <code>AknsUtils::AvkonSkinEnabled()</code> from AknSkins.lib.
*
* @since S60 2.0
*/
EAknEnableSkin = EAknEnableSkinFlag,
EAppOrientationPortrait = EAppOrientationSpecifiedFlag,
EAppOrientationLandscape = EAppOrientationSpecifiedFlag
| EAppOrientationLandscapeFlag,
EAppOrientationAutomatic = EAppOrientationSpecifiedFlag
| EAppOrientationAutomaticFlag,
// Since 3.0
EAknDisableHighlightAnimation = EAknDisableHighlightAnimationFlag,
// Since 3.1
EAknEnableMSK = EAknEnableMSKflag,
// Since 3.2
EAknExplicitStartupEffectCompletion = EAknExplicitStartupEffectCompletionFlag,
// Since 5.0
EAknTouchCompatible = EAknTouchCompatibleFlag
};
enum TKeyEventFlag
{
EDisableSendKeyShort = 0x01, // Short press of send key
EDisableSendKeyLong = 0x02 // Long press of send key
};
public:
/**
* Destructor.
*/
IMPORT_C ~CAknAppUiBase();
/**
* C++ Default constructor.
*/
IMPORT_C CAknAppUiBase();
public:
/**
* Initialises this Avkon base app UI with standard values.
* @c aAppUiFlags values are common with
* @c CEikAppUi::BaseConstructL(aAppUiFlags).
* @param aAppUiFlags Application user interface flags.
*/
IMPORT_C void BaseConstructL( TInt aAppUiFlags );
/**
* Handles changes in keyboard focus when an application switches to,
* or from, the foreground. This function calls
* @c CEikAppUi::HandleForegroundEventL.
* @param aForeground @c ETrue if the application is in the foreground,
* otherwise @c EFalse.
*/
IMPORT_C void HandleForegroundEventL(TBool aForeground);
public: // From CEikAppUi
/**
* From @c CEikAppUi. Completes construction. The implementation of
* @c ConstructL() in @c CAknAppUiBase simply calls @c BaseConstructL().
*/
IMPORT_C void ConstructL(); // virtual
/**
* From @c CEikAppUi. Closes the app UI.
*/
IMPORT_C void Exit(); //virtual
/**
* From @c CEikAppUi. Sets whether the windows are faded.
* @param aFaded @c ETrue if windows are faded, otherwise windows are
* unfaded.
*/
IMPORT_C void SetFadedL(TBool aFaded); // virtual
/**
* From @c CEikAppUi. Handles a change to the application's resources which
* are shared across the environment. This function calls
* @c CEikAppUi::HandleResourceChangeL except when @c aType is
* @c KEikDynamicLayoutVariantSwitch.
* @param aType The type of resources that have changed.
*/
IMPORT_C void HandleResourceChangeL(TInt aType); // virtual
/**
* From @c CEikAppUi. Gets the total area of the screen available to the
* application. This includes the space that is available for a toolbar,
* toolband or title band, if the application requires them.
* @return The total area of the screen available to the application.
*/
IMPORT_C TRect ApplicationRect() const; //virtual
public: // from CCoeAppUiBase
/**
* From @c CCoeAppUiBase. Performs pre-exit processing by calling
* @c CEikAppUi::PrepareToExit() to ensure the application will exit
* cleanly.
*/
IMPORT_C void PrepareToExit();
public: // New Functions
/**
* Determines whether the system is faded.
* @return @c ETrue if system is faded
*/
IMPORT_C TBool IsFaded() const;
/**
* Returns the object which allows events to be spyed upon in addition to
* normal event handling.
* @return Pointer to window server event monitor object.
*/
IMPORT_C CAknWsEventMonitor* EventMonitor() const;
/**
* Gets a pointer to KeySound API object.
* @return Pointer to KeySound API object.
*/
IMPORT_C CAknKeySoundSystem* KeySounds() const;
/**
* Determines whether the application is full screen application.
* @return @c ETrue if the application is full screen application.
*/
IMPORT_C TBool IsFullScreenApp() const;
/**
* Determines whether the application is layout aware.
* @return @c ETrue if the application is layout aware.
*/
IMPORT_C TBool IsLayoutAwareApp() const;
/**
* Determines whether the application has MSK enabled.
* @return @c ETrue if the application has MSK enabled.
*
* @since 3.1
*/
TBool IsMSKEnabledApp() const;
/**
* Determines whether the application is closing.
* In practice this means that CEikonEnv has been destroyed.
* @return @c ETrue if the application is closing.
*
* @since 3.2
*/
TBool IsAppClosing() const;
/**
* Set application layout aware.
* @param aLayoutAwareApp @c ETrue if the application is layout aware,
* @c EFlase otherwise.
*/
IMPORT_C void SetLayoutAwareApp(TBool aLayoutAwareApp);
/**
* Determines whether the application is foreground.
* @return @c ETrue if the application is foreground.
*/
IMPORT_C TBool IsForeground() const;
/**
* Determines whether the application is partially foreground.
* @return @c ETrue if the application is partially foreground.
*/
IMPORT_C TBool IsPartialForeground() const;
/**
* Gets the application screen orientation.
* @return Application screen orientation.
*/
IMPORT_C TAppUiOrientation Orientation() const;
/**
* Tests whether it is possible for this app to have a
* practical effect on the screen orientation, through
* SetOrientationL().
* @since S60 3.2
* @return ETrue if SetOrientationL can change the orientation, EFalse otherwise.
*/
IMPORT_C TBool OrientationCanBeChanged() const;
/**
* Sets the application screen orientation.
* Note: this API has no effect on non-full-screen app UIs.
* @param aOrientation application screen orientation.
*/
IMPORT_C void SetOrientationL(TAppUiOrientation aOrientation);
/**
* Find the window group ID of the application below this application.
* @return the window group ID of the application below this application.
*/
TInt FindAppWgIdBelowMeL();
/**
* Simply return @c KEikPartialForeground if @c aPartialFg == @c ETrue,
* otherwise if @c aForeground == @c ETrue then return @c EEventFocusGained
* else return @c EEventFocusLost.
* @return if @c aPartialFg then return KEikPartialForeground.
*/
TInt EventForForegroundState(TBool aPartialFg, TBool aForeground);
/**
* Determines whether the thread owning this application window group is
* foreground.
* @return @c ETrue if the thread owning this application window group is
* foreground, @c EFlase otherwise.
*/
TBool ThreadIsForeground() const;
/**
* Simulates an event being received from wserv
* @param aEvent the event id being simulated.
*/
void SimulateWsEventL(TInt aEvent);
/**
* Gets the application local zoom
* @return Application local zoom
* @since 3.1
*/
IMPORT_C TAknUiZoom LocalUiZoom() const;
/**
* Sets the application local zoom. However, in order to have any
* effect, it may be necessary to make a subsequent call to
* @c ApplyLayoutChangeL.
*
* @param aZoom application local zoom
* @since 3.1
*/
IMPORT_C void SetLocalUiZoom(TAknUiZoom aZoom);
/*
* Can be used to apply changes to settings that affect the current layout,
* such as changes to the local zoom. Optionally reports the change
* to the layout to all controls in the application. There are a number of
* different possible usages of this API:
* <ul>
* <li> Can be used to immediately change the local zoom, by passing in
* ETrue for the reporting parameter.</li>
* <li> Can be called before BaseConstructL without leaving, the effect
* is the same as passing EFalse for the reporting parameter, as
* the correct layout data is picked up later on during control layout.</li>
* <li>Can be used by implementors of the
* @c MAknSettingCacheUpdatePlugin interface, in order to set the local
* zoom whilst updating the settings cache. By passing in EFalse for the
* reporting parameter, the layout switch is deferred to the usual
* processing in @c UpdateSettingCacheAndForwardEventL.</li>
* <li> Can be used by controls that require a different local zoom to
* the underlying application, such as a dialog. By not
* reporting the change during construction, the dialog will lay itself out
* correctly. However, the dialog must then report the change back to the
* app zoom level when it closes, ignoring the resulting resource changed
* layout switch event.</li>
* </ul>
*
* @param aReportChange if this is true, then the layout event will be
* reported to controls on the control stack
* @since 3.1
*/
IMPORT_C void ApplyLayoutChangeL(TBool aReportChange);
/**
* Checks if application UI has full or partial foreground status.
* @since 3.2
* @return ETrue if application UI has full or partial foreground status.
* Otherwise EFalse.
*/
TBool HasFullOrPartialForeground() const;
/**
* Sets the flags for default key event handling
* @since 5.0
* @param aFlags which can be a combination of flags
* declared in enumeration TKeyEventFlag
*/
IMPORT_C void SetKeyEventFlags( const TInt aFlags );
/**
* Returns a pointer to appui's pointer event modifier. This method is
* intended for internal usage only.
*
* @since S60 v5.0
* @return pointer event modifier
*/
IMPORT_C CAknPointerEventModifier* PointerEventModifier();
/**
* Checks if the application is touch compatible i.e. it has been
* constructed with the flag EAknTouchCompatible.
*
* @since S60 v5.0
* @return ETrue if the application is touch compatible
*/
IMPORT_C TBool IsTouchCompatible() const;
protected: // From CCoeAppUiBase
/**
* From @c CCoeAppUiBase.
* Calls CCoeAppUi::HandleScreenDeviceChangedL().
*/
IMPORT_C virtual void HandleScreenDeviceChangedL(); // was Reserved_1()
protected: // From CCoeAppUi
/**
* From @c CCoeAppUi. Handles an application specific event.
* @param aType The type of the event that occurred. This should be a
* unique identifier constant.
* @param aEvent The window server event that occurred.
*/
IMPORT_C virtual void HandleApplicationSpecificEventL(TInt aType,
const TWsEvent& aEvent);
protected: // New functions
/**
* Set the application to be a full screen application.
* @param aIsFullScreen is @c ETrue if the application is a full screen
* application, @c EFlase otherwise.
*/
IMPORT_C void SetFullScreenApp(TBool aIsFullScreen);
/**
* Replace current key sound server with new one.
* @param aUid ID of the new key sound server.
*/
IMPORT_C void ReplaceKeySoundsL( TInt aUid );
protected: // from MObjectProvider
IMPORT_C virtual TTypeUid::Ptr MopSupplyObject(TTypeUid aId);
public: // not exported
void SetScreenModeL(TInt aModeNumber);
TInt ScreenMode() const;
private:
void UpdateSettingCacheAndForwardEventL( TInt aEventId );
// Method tests on aError. If < KErrNone, it calls CCoeEnv::SetAppUi in order to pass
// ownership to the environment. CCoeEnv then will delete the AppUi at the usual point in the destruct order
void SetAppUiAndLeaveIfErrorL( TInt aError );
TBool AlwaysForwardEvent( TInt aEventId );
void RelinquishPriorityToForegroundAppLC();
private:
// Avkon app ui class flags
TBitFlags iAknFlags;
// Added for Avkon. Monitor events for emergency call support
CAknWsEventMonitor* iEventMonitor;
// Added for Avkon. Provides access to keysound server.
// Moved from CAknAppUi, because CEikSrvUi needs it as well
CAknKeySoundSystem* iKeySounds;
CAknAppUiBaseExtension* iAppUiBaseExtension;
};
/**
* Abstract Avkon application UI class
*
* @since S60 0.9
*/
class CAknAppUi : public CAknAppUiBase, MEikStatusPaneObserver,
public MCoeViewDeactivationObserver,
public MAknTouchPaneObserver
{
public:
/**
* Initialises this Avkon app UI with standard values. @c aAppUiFlags
* values are common with @c CEikAppUi::BaseConstructL(aAppUiFlags).
* Additionally those @c aAppUiFlags values can be bitwise ORed with
* @c EAknEnableSkin flag to provide default skin parameters for this AppUi
* instance.
* @param aAppUiFlags Application user interface flags.
*/
IMPORT_C void BaseConstructL(TInt aAppUiFlags=EStandardApp);
/**
* Destructor.
*/
IMPORT_C ~CAknAppUi();
public: // From CEikAppUi
/**
* From @c CEikAppUi. Completes construction. The implementation of
* @c ConstructL() in @c CAknAppUi simply calls @c BaseConstructL().
*/
IMPORT_C void ConstructL(); // virtual
public:
/**
* Gets a pointer to the status pane.
* @return Pointer to the status pane
*/
IMPORT_C CEikStatusPane* StatusPane();
/**
* Gets a pointer to the Command Button Area.
* @return Pointer to the CBA
*/
IMPORT_C CEikButtonGroupContainer* Cba();
/**
* Gets a pointer to the touch pane.
* @return Pointer to the the touch pane
* @since S60 5.0
*/
IMPORT_C CAknTouchPane* TouchPane();
/**
* Gets a pointer to the application toolbar.
* @return Pointer to the applicaton toolbar or NULL
* @since S60 3.1
*/
IMPORT_C CAknToolbar* PopupToolbar() const;
/**
* Gets a pointer to the current toolbar( view toolbar is priority ).
* @return Pointer to the current toolbar or NULL
* @since S60 3.1
*/
IMPORT_C CAknToolbar* CurrentPopupToolbar() const;
/**
* Gets a pointer to the current fixed toolbar( view toolbar is priority ).
* @return Pointer to the current fixed toolbar or NULL
* @since S60 5.0
*/
IMPORT_C CAknToolbar* CurrentFixedToolbar() const;
/**
* Hides popup toolbar if it is visible
* @since S60 3.1
*/
void StopDisplayingPopupToolbar();
/**
* Processes user commands.
* This function passes @c aCommand (except values @c EAknSoftkeyOptions,
* @c EAknCmdExit, @c EEikCmdCanceled) to user derived @c HandleCommandL.
* @param aCommand A command ID.
*/
IMPORT_C void ProcessCommandL(TInt aCommand);
/**
* Handles errors.
* @param aError The error code.
* @param aExtErr For extended error messages. Not used.
* @param aErrorText Error text. Not used.
* @param aContextText Text describing the context of the error. Not used.
* @return @c ENoDisplay if Error handled proper way, else
* @c EErrorNotHandled
*/
IMPORT_C TErrorHandlerResponse HandleError (TInt aError,
const SExtendedError& aExtErr, TDes& aErrorText, TDes& aContextText);
/**
* Run the application shutter if it exists.
*/
IMPORT_C void RunAppShutter();
/**
* Determines whether the application shutter is active.
* @return @c ETrue if application shutter is active.
*/
IMPORT_C TBool IsAppShutterRunning() const;
/**
* Determines whether the application is hidden in background.
* (i.e. HideInBackground has been called and application has not
* yet been activated)
* @return @c ETrue if application is hidden in background.
*/
TBool IsAppHiddenInBackground() const;
public: // MCoeViewDeactivationObserver
/**
* From @c MCoeViewDeactivationObserver.
* Handles the deactivation of the view identified by
* @c aViewIdToBeDeactivated before the newly activated view with id
* @c aNewlyActivatedViewId is marked as current.
* Default implementation calls @c iAvkonEnv->CloseAllIntermediateStates()
* without using @c aViewIdToBeDeactivated and @c aNewlyActivatedViewId.
* @param aViewIdToBeDeactivated
* @param aNewlyActivatedViewId
*/
IMPORT_C virtual void HandleViewDeactivation(
const TVwsViewId& aViewIdToBeDeactivated,
const TVwsViewId &aNewlyActivatedViewId);
public: // from CCoeAppUiBase
/**
* From @c CCoeAppUiBase. Performs pre-exit processing to ensure the
* application will exit cleanly.
*/
IMPORT_C void PrepareToExit();
public: // from MAknTouchPaneObserver
/**
* From @MAknTouchPaneObserver.
* Handles a change in the size or position of touch pane.
*/
IMPORT_C void HandleTouchPaneSizeChange();
protected:
// from MEikStatusPaneObserver
/**
* From @c MEikStatusPaneObserver. Handles a change in the position or size
* of the screen area occupied by the status pane.
*/
IMPORT_C void HandleStatusPaneSizeChange();
// from CCoeAppUi
/**
* From @c CCoeAppUi. Handles system events generated by the window server.
* @param aEvent The window server event that occurred.
*/
IMPORT_C void HandleSystemEventL(const TWsEvent& aEvent);
protected: // formerly from MTopSetMember<CEikMenuBar>, now reserved
IMPORT_C virtual void Reserved_MtsmPosition();
IMPORT_C virtual void Reserved_MtsmObject();
protected:
/**
* Handles changes in keyboard focus when an application switches to,
* or from, the foreground.
* @param aForeground @c ETrue if the application is in the foreground,
* otherwise @c EFalse.
*/
IMPORT_C void HandleForegroundEventL(TBool aForeground);
/**
* Handles window server events.
* @param aEvent The window server event that occurred.
* @param aDestination The control associated with the event.
*/
IMPORT_C void HandleWsEventL(const TWsEvent& aEvent,
CCoeControl* aDestination);
/**
* Set key block mode.
* In default mode, the S60 Developer Platform blocks simultaneous key
* presses.
* @param aMode @c ENoKeyBlock if no key block, otherwise
* @c EDefaultBlockMode
*/
IMPORT_C void SetKeyBlockMode(TAknKeyBlockMode aMode);
IMPORT_C void HandleErrorL(TInt aError, HBufC** aErrorDesc, TBool aShowNote = ETrue );
#ifdef _DEBUG
/**
* Prints out information about the control and all its subcontrols to
* RDebug console.
* @param aControl object to be printed.
* @param aLevel positioning constant.
* @param aDebug stream for printing.
*/
void DumpControl(CCoeControl* aControl, TInt aLevel, RDebug& aDebug);
#endif
/**
* Try to set window server buffer size to @c KAknDefaultWsBufferSize.
*/
void DecideWsClientBufferSizesL();
private:
void UpdateKeyBlockMode();
TBool SimulateHashKeyMarkingEvent(const TWsEvent& aEvent);
private:
TBool iDumpNextControl;
CAknAppShutter* iAppShutter;// May be set to NULL by the app shutter itself
TAknKeyBlockMode iBlockMode;
CAknAppUiExtension * iExtension;
public:
/**
* Hide application from Fast-swap window.
* @since S60 2.6
* @param aHide @c ETrue if application is hided from Fast-swap window, otherwise
* @c EFalse
*/
IMPORT_C void HideApplicationFromFSW(TBool aHide=ETrue);
/**
* Gets keyboard layout specific keycode. Uses given resolver
* SetAliasKeyCodeResolverL() if set, by default
* fetches alternative code from avkon server.
*
* @since S60 3.1
* @param aCode reference to variable to contain new keycode
* @param aKeyEvent reference to original, complete, event
* @param aType indicating original event type
*/
IMPORT_C void GetAliasKeyCodeL(TUint& aCode, const TKeyEvent& aKeyEvent,TEventCode aType);
/**
* Sets custom resolver for keycode aliases
* Creates iExtension if it doesn't exist
* @since S60 3.1
* @param aHandler instance implementing MAknAliasKeyCodeResolver
*/
IMPORT_C void SetAliasKeyCodeResolverL(MAknAliasKeyCodeResolver* aResolver);
/**
* This is same as RWindowGroup::CaptureKey, except that this version takes
* S60 keymappings into account and captures the key that produces requested
* aKeyCode according to S60 keymappings. Standard RWindowgroup::CaptureKey
* functionality takes place before S60 AppUi framework and has no knowledge
* of S60 keymappings.
* Note: This method requires same capabilites as RWindowGroup::CaptureKey()
*
* @since S60 V3.2
* @param aKeycode The key code for the key to be captured. Key codes for
* special keys are defined in TKeyCode.
* @param aModifier Mask Only the modifier keys in this mask are tested against
* the states specified in aModifier.
* @param aModifier The key is captured only when the modifier keys specified in
* aModifierMask match these states, where 1=modifier set,
* and 0=modifier not set. Modifier key states are defined
* in TEventModifier.
* @return A handle identifying the capture key, or one of the system-wide error
* codes (if <0). Handles should be kept in order to be passed to
* CancelCaptureKey() later.
*/
IMPORT_C TInt32 CaptureKey(TUint aKeycode, TUint aModifierMask, TUint aModifier);
/**
* This is same as RWindowGroup::CaptureKey, except that this version takes
* S60 keymappings into account and captures the key that produces requested
* aKeyCode according to S60 keymappings. This version leaves instead of returning
* an error code. Standard RWindowgroup::CaptureKey functionality takes place
* before S60 AppUi framework and has no knowledge of S60 keymappings.
* Note: This method requires same capabilites as RWindowGroup::CaptureKey()
*
* @since S60 V3.2
* @param aKeycode The key code for the key to be captured. Key codes for
* special keys are defined in TKeyCode.
* @param aModifier Mask Only the modifier keys in this mask are tested against
* the states specified in aModifier.
* @param aModifier The key is captured only when the modifier keys specified in
* aModifierMask match these states, where 1=modifier set,
* and 0=modifier not set. Modifier key states are defined
* in TEventModifier.
* @param aHandle identifying the capture key. Handles should be kept in order
* to be passed to CancelCaptureKey() later.
*/
IMPORT_C void CaptureKeyL(TUint aKeycode, TUint aModifierMask, TUint aModifier, TInt32& aHandle);
/**
* This tells the application if it is allowed to hide itself in the
* background in response to a user (menu or softkey) exit command,
* instead of actually exiting.
* If the application appears to exit, but actually leaves itself in
* memory, it may appear to start faster next time the user activates it.
*
* @since S60 V5.0
* @return ETrue if the application can hide itself in the background,
* EFalse if it must exit properly by calling Exit().
*/
IMPORT_C TBool ExitHidesInBackground() const;
/**
* Hide the running instance of this application from the user, which
* makes it appear as if the application has exited.
* This is done by placing the application in the background, behind
* all other apps, and removing the application from the Fast Swap Window.
* When the application comes to the foreground again, it will be
* restored to the Fast Swap Window (in HandleForegroundEventL). If the
* application is not supposed to be in the Fast Swap Window, it will have
* to remove itself again.
* @since S60 V5.0
*/
IMPORT_C void HideInBackground();
/**
* Disables next key sound (and repeated key sounds until pointer up event).
*
* @since S60 V5.0
* @param aScanCode Scan code of disabled key.
*/
IMPORT_C void DisableNextKeySound( TInt aScanCode );
private:
TBool ExitHidesInBackgroundL() const;
};
#endif