/*

* 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 "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: 

*

*/

#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,

        /**

         * Application supports single click.

         *

         * @since S60 5.2

         */

        EAknSingleClickCompatibleFlag           = 0x01000000

        };

    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,

        // Since 5.2

        EAknSingleClickCompatible = EAknSingleClickCompatibleFlag

        };

    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;

    /**

     * Checks if the application is single click compatible i.e.

     * it has been constructed with the flag EAknSingleClickCompatible.

     *

     * @since S60 v5.0

     * @return ETrue if the application is single click compatible

     */

    IMPORT_C TBool IsSingleClickCompatible() 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

*/