--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiaccelerator_plat/alf_core_toolkit_api/inc/uiacceltk/HuiEnv.h Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,993 @@
+/*
+* Copyright (c) 2006-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: Defines CHuiEnv, a common working environment for the Toolkit.
+*
+*/
+
+
+
+#ifndef __HUIENV_H__
+#define __HUIENV_H__
+
+#include <e32base.h>
+#include <w32std.h>
+#include <barsread.h>
+#include <coemain.h>
+
+#include <uiacceltk/HuiTextureManager.h>
+#include <uiacceltk/huifontmanager.h>
+#include <uiacceltk/HuiCommand.h>
+#include <uiacceltk/HuiObserverArray.h>
+#include <uiacceltk/HuiRenderer.h>
+#include <uiacceltk/huilowmemoryobserver.h>
+
+/* Forward declarations */
+class CCoeControl;
+class CHuiStatic;
+class CHuiDisplay;
+class CHuiRosterImpl;
+class CHuiSkin;
+class CHuiScheduler;
+class CHuiControl;
+class CHuiControlGroup;
+class CHuiVisualFactory;
+class CHuiVisual;
+class MHuiActionObserver;
+class THuiEvent;
+class CDirectScreenAccess;
+class MHuiEventHandler;
+class CHuiTextStyleManager;
+class CHuiThemeManager;
+class CHuiCanvasTextureCache;
+class CHuiFxEngine;
+
+class CHighResTimer;
+const TInt KHuiEnvReleasedActionId = 0x200100F8;
+const TInt KHuiEnvRestoredActionId = 0x200100F9;
+
+
+/**
+ * THuiRefreshMode modes can be used to define when the screen redraws
+ * should be performed.
+ * @see CHuiEnv::SetRefreshMode()
+ */
+enum THuiRefreshMode
+ {
+ /** Refresh occurs only when requested by calling CHuiEnv::RefreshCallBack(). */
+ EHuiRefreshModeManual,
+
+ /** Refresh is done automatically when necessary. */
+ EHuiRefreshModeAutomatic, // = default
+
+ /** Refresh is done all the time, even if nothing has changed. Dirty regions
+ are not used for determining what has changed. Instead, displays are
+ always fully redrawn. */
+ EHuiRefreshModeForced
+ };
+
+
+/**
+ * HUI environment observer. Instance of this class can be created
+ * by user application and passed in constructor to CHuiEnv. The
+ * observer class will be called for certain events.
+ */
+class MHuiEnvObserver
+ {
+public:
+
+ /**
+ * Called to create a new CHuiSkin derived object for the use
+ * of the calling CHuiEnv object. This method can return
+ * either an application specific Skin - object or NULL for
+ * allowing CHuiEnv to create it's default Skin object. The calling
+ * CHuiEnv will take responsibility of the created CHuiSkin object.
+ *
+ * @param aEnv The CHuiEnv object to which to create the
+ * new skin object.
+ *
+ * @return New instance of a CHuiSkin - derived object.
+ */
+ virtual CHuiSkin* CreateSkinL(CHuiEnv& aEnv) = 0;
+
+ };
+
+
+/**
+ * Interface for observing action commands. When the scheduler executes an
+ * action command, the registered listeners that implement this interface
+ * will receive a notification of the action.
+ */
+class MHuiActionObserver
+ {
+public:
+
+ /**
+ * Called by the scheduler when an action command is executed.
+ *
+ * @param aActionCommand The command that is being executed.
+ */
+ virtual void HandleActionL(const THuiActionCommand& aActionCommand) = 0;
+
+ };
+
+
+/**
+ * CHuiEnv is a common working environment for the Toolkit. CHuiEnv manages
+ * the common data for a HUITK application, such as displays, the texture
+ * manager, visual factory and currently used skin.
+ *
+ * An application that uses HUITK will need to create one CHuiEnv. Also
+ * destroying the CHuiEnv instance will clean up all resources associted
+ * with the UI.
+ *
+ * @see NewL()
+ * @see NewLC()
+ */
+NONSHARABLE_CLASS(CHuiEnv) : public CBase,
+ public MHuiTextureManagerStateChangedObserver,
+ public MHuiTextureLoadingCompletedObserver
+ {
+public:
+
+ /* Types. */
+
+ /** Flags for creating new displays. */
+ enum TNewDisplayFlags
+ {
+ ENewDisplayFullScreen = 0x1,
+ ENewDisplayOverlaid = 0x2
+ };
+
+
+ /** @beginAPI */
+
+ /* Constructors and destructor. */
+
+ /**
+ * Constructs a new HUI environment. An application that uses HUI will
+ * need to create one CHuiEnv. This will not start the timing used
+ * inside Hitchcock UI Toolkit. The animation timing will be started
+ * from the point in time when the first frame is drawn. So UI build up
+ * and precalculation can be done without affecting the animation time.
+ *
+ * @param aRenderer Rendering interface to use in the environment.
+ * @param aObserver Pointer to observer class instance that will be called
+ * to perform application specific configurations. Can be
+ * NULL to create a default CHuiEnv.
+ *
+ * @return HUI environment.
+ */
+ IMPORT_C static CHuiEnv* NewL(THuiRenderer aRenderer = EHuiRendererDefault,
+ MHuiEnvObserver* aObserver = NULL);
+
+ /**
+ * Constructs a new HUI environment and leaves it on the cleanup stack.
+ * This will not start the timing used inside Hitchcock UI Toolkit.
+ * The animation timing will be started from the point in time when
+ * the first frame is drawn. So UI build up and precalculation can be
+ * done without affecting the animation time.
+ *
+ * @param aRenderer Rendering interface to use in the environment.
+ * @param aObserver Pointer to observer class instance that will be called
+ * to perform application specific configurations. Can be
+ * NULL to create a default CHuiEnv.
+ *
+ * @return HUI environment.
+ */
+ IMPORT_C static CHuiEnv* NewLC(THuiRenderer aRenderer = EHuiRendererDefault,
+ MHuiEnvObserver* aObserver = NULL);
+
+ /** @endAPI */
+
+
+ /**
+ * Destructor.
+ */
+ virtual ~CHuiEnv();
+
+
+ /* Methods. */
+
+ /** @beginAPI */
+
+ /**
+ * Determines which renderer is currently in use. Always returns the real
+ * explicit identifier of the renderer, and not an ambiguous identifier
+ * like "Default".
+ *
+ * @return THuiRenderer enum.
+ */
+ IMPORT_C THuiRenderer Renderer() const;
+
+ /**
+ * Creates a new HuiDisplay.
+ *
+ * @param aRect Size of the display.
+ * @param aNativeControl Native control to which to associate the display.
+ * @param aFlags Flags for the display (TNewDisplayFlags).
+ * @param aRosterOwningDisplay The display that will share its roster.
+ * @param aDisplayType Display type.
+ *
+ * @return Display.
+ */
+ IMPORT_C CHuiDisplay& NewDisplayL(const TRect& aRect,
+ CCoeControl* aNativeControl = 0,
+ TInt aFlags = 0,
+ CHuiDisplay* aRosterOwningDisplay = NULL,
+ TInt aDisplayType = 0 );
+
+ /**
+ * Creates a new HuiDisplay.
+ *
+ * @param aRect Size of the display.
+ * @param aNativeControl Native control to which to associate the display.
+ * @param aFlags Flags for the display (TNewDisplayFlags).
+ * @param aRosterOwningDisplay The display that will share its roster.
+ * @param aDisplayType Display type.
+ * @param aBackBufferUid Screen back buffer uid.
+ *
+ * @return Display.
+ */
+ IMPORT_C CHuiDisplay& NewDisplayL(const TRect& aRect,
+ CCoeControl* aNativeControl,
+ TInt aFlags,
+ CHuiDisplay* aRosterOwningDisplay,
+ TInt aDisplayType,
+ TUid aBackBufferUid );
+
+
+ /**
+ * Creates a new HuiDisplay.
+ *
+ * @param aNativeWindow Native window to which to associate the display.
+ * @param aFlags Flags for the display (TNewDisplayFlags).
+ * @param aRosterOwningDisplay The display that will share its roster.
+ * @param aDisplayType Display type.
+ * @param aBackBufferUid Screen back buffer uid.
+ *
+ * @return Display.
+ */
+ IMPORT_C CHuiDisplay& NewDisplayL(RWindow* aNativeWindow,
+ TInt aFlags,
+ CHuiDisplay* aRosterOwningDisplay,
+ TInt aDisplayType,
+ TUid aBackBufferUid );
+
+ /**
+ * Determines the number of displays currently created with NewDisplayL().
+ *
+ * @return Display count.
+ */
+ IMPORT_C TInt DisplayCount() const;
+
+ /**
+ * Sets the refresh mode.
+ *
+ * @param aMode New refresh mode.
+ *
+ * @see THuiRefreshMode
+ */
+ IMPORT_C void SetRefreshMode(THuiRefreshMode aMode);
+
+ /**
+ * Determines the environment's display refresh mode.
+ *
+ * @return Refresh mode.
+ */
+ IMPORT_C THuiRefreshMode RefreshMode() const;
+
+ /**
+ * Sets the maximum allowed frame rate. Specify 0.0 to use the default limit.
+ *
+ * @param aFrameRate New maximum frame rate in frames per second.
+ */
+ IMPORT_C void SetMaxFrameRate(TReal32 aFrameRate) __SOFTFP;
+
+ /**
+ * Continues normal display refreshing. If display refreshing is already
+ * being done, calling this has no effect. This is called automatically
+ * from inside the toolkit when something is done that may lead to a
+ * visible change on a display. The application may also call this if it
+ * has previously paused refresh with PauseRefresh().
+ * This does not affect any timing.
+ *
+ * @see CHuiStatic
+ */
+ IMPORT_C void ContinueRefresh();
+
+ /**
+ * Continues normal display refreshing. If display refreshing is already
+ * being done, calling this has no effect. This is called automatically
+ * from inside the toolkit when something is done that may lead to a
+ * visible change on a display. The application may also call this if it
+ * has previously paused refresh with PauseRefresh().
+ * @param aFastFirstRefresh If ETrue and refresh timer is not active,
+ * first refresh will be done as soon as possible. Otherwise first refresh
+ * will occur after refresh timer has expred.
+ *
+ * @see CHuiStatic
+ */
+ void ContinueRefresh(TBool aFastFirstRefresh);
+
+ /**
+ * Pauses display refreshing temporarily. This is called when it is clear
+ * that any displays will not be updated soon. The application may call
+ * this at times when it needs more processing time for other tasks.
+ */
+ IMPORT_C void PauseRefresh();
+
+ /**
+ * Constructs a new empty control group.
+ *
+ * @param aId (Resource) Identifier of the new group.
+ *
+ * @return Reference to the new group.
+ */
+ IMPORT_C CHuiControlGroup& NewControlGroupL(TInt aId);
+
+ /**
+ * Deletes a previously loaded control group. The controls inside the
+ * groups will also be destroyed. Note that this will also destroy the
+ * visuals of the controls, because they are owned by the controls.
+ *
+ * @param aId Identifier of the group to be deleted.
+ *
+ * @return <code>KErrNone</code>, if the deletion is successful.
+ * <code>KErrNotFound</code>, if there are no control groups
+ * with the specified identifier.
+ */
+ IMPORT_C TInt DeleteControlGroup(TInt aId);
+
+ /**
+ * Load controls and a group from a resource definition and create a
+ * HuiControlGroup out of them.
+ *
+ * @param aResourceId Resource identifier of the group.
+ *
+ * @return Control group with controls inside.
+ */
+ IMPORT_C CHuiControlGroup& LoadControlGroupL(TInt aResourceId);
+
+ /**
+ * Returns an existing control group based on its identifier.
+ * @note Will panic with THuiPanic::EInternal if the specified
+ * control group is not found.
+ */
+ IMPORT_C CHuiControlGroup& ControlGroup(TInt aResourceId);
+
+ /**
+ * "Loads" bitmaps specified in a resource. Works with all
+ * supported image formats, including BMP, PNG and JPG. The resource
+ * defines a numerical identifier for each bitmap. The bitmaps
+ * are added to the texture manager in this environment and can be
+ * accessed using the numerical identifiers.
+ * @see TextureManager()
+ *
+ * @note Does not really _load_ the bitmaps to textures. Instead, the
+ * bitmap filenames are bound to the id:s specified by the resource. The
+ * texture ids may be later used to load the texture resource (by calling
+ * CHuiTextureManager::LoadTextureL() with the id).
+ *
+ * @see CHuiTextureManager::LoadTextureL()
+ * @see CHuiTextureManager::TextureL()
+ * @see CHuiTextureManager::Texture()
+ *
+ * @todo The bitmap resource file format is not documented.
+ *
+ * @param aResourceId Resource containing a list of bitmap file names.
+ */
+ IMPORT_C void LoadBitmapsL(TInt aResourceId);
+
+ /**
+ * Returns the visual factory.
+ */
+ IMPORT_C CHuiVisualFactory& VisualFactory() const;
+
+ /**
+ * Returns the texture manager.
+ */
+ IMPORT_C CHuiTextureManager& TextureManager() const;
+
+ /**
+ * Returns the font manager object.
+ */
+ IMPORT_C THuiFontManager& FontManager() const;
+
+ /**
+ * Returns the text style manager.
+ */
+ IMPORT_C CHuiTextStyleManager& TextStyleManager() const;
+
+ /**
+ * Finds a control from the control groups of this
+ * environment.
+ * @param aId The id of the control to find.
+ * @see CHuiControl::SetId()
+ * @see CHuiControl::Id()
+ * @return The control instance, or NULL if no such control exists.
+ */
+ IMPORT_C CHuiControl* FindControl(TInt aId) const;
+
+ /**
+ * Schedule a command.
+ *
+ * @param aCommand Command to send.
+ * @param aDelayMilliSeconds Time in ms to wait before executing the command. If
+ * set to zero, the command is executed immediately. Note that the point of
+ * execution may not be exactly this amount of milliseconds.
+ *
+ * @return System-wide error code. If successful, returns <code>KErrNone</code>.
+ */
+ IMPORT_C TInt Send(const THuiCommand& aCommand, TInt aDelayMilliSeconds = 0);
+
+ /**
+ * Schedule a command. Leaves if there is a failure when posting the command
+ * to the scheduler.
+ *
+ * @param aCommand Command to send.
+ * @param aDelayMilliSeconds Time to wait before executing the command.
+ */
+ IMPORT_C void SendL(const THuiCommand& aCommand, TInt aDelayMilliSeconds = 0);
+
+ /**
+ * Cancel commands related to an object. This object may be a timed value,
+ * a visual, MHuiEventHandler, or anything you can do commands on.
+ *
+ * @param aObject Any commands owned by this object will be cancelled.
+ * Note that you must cast derived classes that are passed,
+ * otherwise the pointer will point to the base class.
+ */
+ IMPORT_C void CancelCommands(TAny* aObject);
+
+ /**
+ * Overloaded version of CancelCommands, especially for classes derived from
+ * MHuiEventHandler, so that correct pointer will be used.
+ * @see CHuiEnv::CancelCommands
+ */
+ IMPORT_C void CancelCommands(MHuiEventHandler* aObject);
+
+ /**
+ * Overloaded version of CancelCommands, especially for classes derived from
+ * MHuiEventHandler, so that correct pointer will be used.
+ * @see CHuiEnv::CancelCommands
+ */
+ IMPORT_C void CancelCommands(TAny* aObject,
+ THuiOp aCommandOperation);
+
+ /**
+ * Overloaded version of CancelCommands, especially for classes derived from
+ * MHuiEventHandler, so that correct pointer will be used.
+ * @see CHuiEnv::CancelCommands
+ */
+ IMPORT_C void CancelCommands(TAny* aObject,
+ THuiCommandType aCommandType,
+ TInt aParam);
+
+ /**
+ * Time until the given command will be executed on the given object.
+ *
+ * @param aObject The object that is waiting for a command to be executed.
+ * Note that you must cast derived classes that are passed,
+ * otherwise the pointer will point to the base class.
+ * @param aCommandType Type of command.
+ * @return Time interval in milliseconds. -1, if no commands found.
+ */
+ IMPORT_C TInt TimeUntilCommand(TAny* aObject,
+ THuiCommandType aCommandType);
+
+ /**
+ * Returns the skin that is used by the environment. Only one skin can be
+ * used at a time.
+ */
+ IMPORT_C CHuiSkin& Skin() const;
+
+ /**
+ * Starts the refresh timer with given tick interval. Can be used to
+ * control how often the toolkit updates itself.
+ *
+ * @param aMilliSeconds Milliseconds between ticks.
+ */
+ IMPORT_C void StartRefresh(TInt aMilliSeconds);
+
+ /**
+ * Starts the refresh timer with given tick interval. Can be used to
+ * control how often the toolkit updates itself.
+ *
+ * @param aMilliSeconds Milliseconds between ticks.
+ * @param aDelayInMilliSeconds Milliseconds until first refrsh.
+ */
+ void StartRefresh(TInt aIntervalInMilliSeconds, TInt aDelayInMilliSeconds);
+
+ /**
+ * Handles a key event received from CONE.
+ *
+ * @param aKeyEvent Received key event to handle.
+ * @param aType Type of event.
+ * @param aAssocDisplay Associated CHuiDisplay, if there is one.
+ * If specified, the event is handled by this display's
+ * roster only. If <code>NULL</code>, event is offered
+ * to all displays.
+ */
+ IMPORT_C TBool HandleKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType,
+ CHuiDisplay* aAssocDisplay = 0);
+
+ /**
+ * Sets the interval before an idle notification is sent. Idling
+ * begins when no input has been received after this delay.
+ *
+ * If you want to reset the idle time counter you have to actually
+ * generate a key event (for example by using TApaTask::SendKey(),
+ * or calling HandleKeyEventL() directly).
+ *
+ * @todo Add a convenience method to reset the idle time counter.
+ *
+ * @note Scheduled events keep display refresh running even
+ * when there's no input.
+ *
+ * @param aSeconds Threshold in milliseconds. However the
+ * granularity is one second, so use thousands of ms as your
+ * input value.
+ */
+ IMPORT_C void SetIdleThreshold(TInt aMilliSeconds);
+
+ /**
+ * Broadcasts an event to all controls in the environment.
+ *
+ * @param aEvent Event to broadcast.
+ */
+ IMPORT_C void BroadcastEventL(const THuiEvent& aEvent);
+
+ /**
+ * Returns the primary display, that is the display
+ * that was created first.
+ */
+ IMPORT_C CHuiDisplay& PrimaryDisplay() const;
+
+ /**
+ * Returns the requested display.
+ *
+ * @param aIndex Index of the display array.
+ */
+ IMPORT_C CHuiDisplay& CHuiEnv::Display(TInt aIndex) const;
+
+ /**
+ * Notifies everyone of a change in the environment's skin. Called by the
+ * skin instance when a change occurs in it, or when the environment
+ * switches the skin instance. Exported so that application-implemented
+ * custom skins can call this, too.
+ */
+ IMPORT_C void NotifySkinChangedL();
+
+
+ /* Static methods. */
+
+ /**
+ * Refresh callback, that is called by a refresh timer. Called periodically
+ * when there might be something to update on the display. Has the
+ * responsibility to update time for all HUI environments.
+ *
+ * @param aInstance A CHuiEnv instance.
+ * @see StartRefresh() to modify how often updates are being made.
+ * @see StopRefresh() to stop updates.
+ */
+ IMPORT_C static TInt RefreshCallBack(TAny* aInstance);
+
+ /**
+ * Releases as many resources as possible. Among the released resources
+ * may be all objects in the toolkit's ownership, for example texture
+ * images and drawing surfaces. This should be called when the Hitchcock
+ * user interface is not needed for a while, for example when the application
+ * goes to the background.
+ *
+ * At the moment the Environment releases all rendering surface and all displays,
+ * but not the rendering plugin. All textures are left unreleased.
+ *
+ * The resources need to be restored with a call to RestoreL() before
+ * the Hitchcock user interface is used again.
+ *
+ * The AppUI can call this method to release resources. The AppUI can
+ * overload HandleWsEventL() and react to KAknFullOrPartialForegroundLost
+ * window server event by calling this method.
+ *
+ * @see RestoreL()
+ */
+ IMPORT_C void Release();
+
+ /**
+ * Restores all resources that were released with a call to Release().
+ * After this the Hitchcock user interface should be in the same state
+ * in terms of resources as it was prior to the Release() call.
+ *
+ * The AppUI can call this method to Restore resources. The AppUI can
+ * overload HandleWsEventL() and react to KAknFullOrPartialForegroundGained
+ * window server event by calling this method.
+ *
+ * @see Release()
+ */
+ IMPORT_C void RestoreL();
+
+ /**
+ * Set environment scheduling to adapt on device load.
+ * Adaptive interval can only quarantee time for active objects inside
+ * the same thread, though the interval calculation balances the
+ * effect of thread priority based schedulation and context switches as well
+ *
+ * @param aPercent maximum time spent in RefreshCallBack() in percents.
+ */
+ IMPORT_C void SetMaxCpuTime(TUint aPercent);
+
+
+ /** Gets a pointer to a CHuiEnv which can be used to access CHuiEnv's functions.
+ * It allows application code to access CHuiEnv's functions even where there is
+ * no direct access to a ChuiEnv object.
+ *
+ * For example:
+ *
+ * CHuiEnv::Static()->SetMaxCpuTime(TUint aPercent);
+ *
+ * @return CHuiEnv * The pointer for accessing CHuiEnv's functions. or
+ * NULL if CHuiEnv has not been constructed yet.
+ *
+ */
+ static IMPORT_C CHuiEnv *Static();
+
+
+
+ /**
+ * Returns the theme manager.
+ */
+ IMPORT_C CHuiThemeManager& ThemeManager() const;
+
+ /**
+ * Returns the effects engine or NULL if effects are not supported
+ * by the current rendering plugin.
+ */
+ IMPORT_C CHuiFxEngine* EffectsEngine() const;
+
+ /**
+ * RnD utility, shows FPS using User::InfoPrint using sample rate
+ * given in milliseconds
+ */
+ IMPORT_C void SetFPSCounterThreshold(TUint aMilliseconds);
+
+ /**
+ * Allows application to balance rendering loop active object priority
+ * compared to other active objects running within same scheduler
+ *
+ * Default value is CActive::EPriorityStandard
+ */
+ IMPORT_C void ChangeRefreshLoopPriority(CActive::TPriority aPriority);
+
+ /**
+ * Enables or disables debug features, by setting Rnd flag bits of KUIAccelTKEffectsComplexityFactor,
+ * of central repository key.
+ *
+ * If 0x800 is set, Texturememory calculation is enabled. Calculates total memory used by texturemanager
+ * for all the textures it holds.
+ * Enabling this feature makes TextureManager to write info messages,
+ * with total memory used by total number of textures and average bit depth of textures. For debugging purpose.
+ *
+ * @param aRndFlag holds the Rnd flag.
+ */
+ IMPORT_C void EnableDebugFlag( TUint aRndFlag );
+
+ /** @endAPI */
+
+
+ /* Methods. */
+
+ /**
+ * Sets the texture manager of this environment.
+ *
+ * @param aManager
+ */
+ void SetTextureManager(CHuiTextureManager& aManager);
+
+ /**
+ * Returns a reference to the scheduler of the environment.
+ */
+ CHuiScheduler& Scheduler();
+
+ /**
+ * Removes a display from the environment.
+ *
+ * @param aDisplay The display to remove.
+ */
+ void RemoveDisplay(CHuiDisplay& aDisplay);
+
+ /**
+ * Update all displays by swapping an image drawn to a background display
+ * buffer to the foreground (visible) screen buffer. This is the last stage
+ * of display refresh.
+ */
+ void SwapBuffers(const RArray<TBool>& aDisplayRefreshed);
+
+ /**
+ * Called when input is received.
+ *
+ * @param aEvent The received input event.
+ */
+ void NotifyInputReceivedL(const THuiEvent& aEvent);
+
+ /**
+ * Notify all displays of an idle event, ie. that
+ * we are entering or leaving an idle state.
+ *
+ * @param aIdleBegins ETrue if we are entering an idle state.
+ EFalse if we are leaving the idle state.
+ */
+ void SendIdleL(TBool aIdleBegins);
+
+ /**
+ * Notifies action observers of an action command.
+ *
+ * @param aCommand Action command that is being executed.
+ *
+ * @return System-wide error code from the first obserser that leaves.
+ * If no leaves occur, returns <code>KErrNone</code>.
+ */
+ TInt ReportAction(const THuiActionCommand& aCommand);
+
+ /**
+ * Returns the array of all displays in the environment.
+ *
+ * @return Array of all displays in the environment.
+ */
+ RPointerArray<CHuiDisplay> Displays() const;
+
+ IMPORT_C TInt& GlesRefCounter();
+
+ void SetTimeFromLastUpdate(TUint aTimeFromLastUpdate);
+
+ /**
+ * Gets the active display.
+ *
+ * @return Current HuiDisplay.
+ */
+ CHuiDisplay* CurrentDisplay() const;
+
+ CHuiCanvasTextureCache& CanvasTextureCache() const;
+
+public:
+
+ /* Implementaton of MHuiTextureLoadingCompletedObserver: */
+
+ void TextureLoadingCompleted(CHuiTexture& aTexture,
+ TInt aTextureId,
+ TInt aErrorCode);
+
+ /* Implementaton of MHuiTextureManagerStateChangedObserver: */
+
+ void TextureManagerStateChanged(const CHuiTextureManager& aManager);
+
+
+private:
+
+ /* Enumerations. */
+
+ /**
+ * Environment state.
+ */
+ enum TState
+ {
+ /** Normal state, where rendering is occuring. */
+ ENormal,
+ /** Released state, where displays are released and rendering is not occuring. */
+ EReleased
+ };
+
+ /* Constructors. */
+
+ /**
+ * Constructor.
+ *
+ * @param aObserver Pointer to observer class instance that will be called
+ * to perform application specific configurations. Can be
+ * NULL to create a default CHuiEnv.
+ */
+ CHuiEnv(MHuiEnvObserver* aObserver = NULL);
+
+ /**
+ * Second-phase constructor.
+ *
+ * @param aRenderer The renderer being used by the environment.
+ */
+ void ConstructL(THuiRenderer aRenderer);
+
+
+ /* Private methods. */
+
+ /**
+ * Create a resource reader.
+ *
+ * @param aReader Resource reader.
+ * @param aResourceId Identifier of the resource to read.
+ */
+ void CreateResourceReaderLC(TResourceReader& aReader, TInt aResourceId) const;
+
+ /**
+ * Stops the refresh timer.
+ * This does not affect animation timers.
+ *
+ * @see CHuiStatic
+ */
+ void StopRefresh();
+
+ /**
+ * Called when time has passed. The amount of elapsed time is passed
+ * to the scheduler and the displays are checked for refresh.
+ *
+ * @param aElapsedTime Number of seconds elapsed.
+ */
+ void AdvanceTime(TReal32 aElapsedTime);
+
+ /**
+ * Makes the render surface of the display active.
+ *
+ * @param aDisplay HuiDisplay to make current.
+ */
+ void MakeCurrent(const CHuiDisplay& aDisplay) const;
+
+ /**
+ * Checks if device supports thread CPU time measurements.
+ */
+ TBool CPUTimeSupported();
+
+ /**
+ * Opens handle to null thread.
+ */
+ TBool OpenHandleToIdleCPUValueThread();
+
+ /**
+ * Closes handle to null thread.
+ */
+ void CloseHandleToIdleCPUValueThread();
+
+public:
+
+ /** Action observers. */
+ RHuiObserverArray<MHuiActionObserver> iActionObservers;
+
+
+private:
+
+ /** Current environment state. */
+ TState iState;
+
+ /** Renderer instance. */
+ CHuiRenderPlugin* iRenderer;
+
+ /** Public identifier of the renderer selected at construction time. */
+ THuiRenderer iRendererIdentifier;
+
+ /** Current refresh mode. */
+ THuiRefreshMode iRefreshMode;
+
+ /** Refresh interval in milliseconds. */
+ TInt iRefreshInterval;
+ TInt iRefreshIntervalTarget;
+
+ /** Instance of the static data area. */
+ CHuiStatic* iStatic;
+
+ /** Array of all displays in the environment. Owned. */
+ RPointerArray<CHuiDisplay> iDisplays;
+
+ /** Array of all overlaid displays in the environment. Points to the
+ displays in iDisplays. */
+ RPointerArray<CHuiDisplay> iOverlaidDisplays;
+
+ /** The roster used by all overlaid displays. */
+ CHuiRosterImpl* iSharedRoster;
+
+ /** Refresh timer. */
+ CHighResTimer* iPeriodic;
+ //CPeriodic* iPeriodic;
+
+ /** Number of refreshes that had no effect on anything. */
+ TInt iIdleRefreshCount;
+
+ /** The scheduler. */
+ CHuiScheduler* iScheduler;
+
+ /** All the loaded control groups are owned by the environment. */
+ RPointerArray<CHuiControlGroup> iLoadedGroups;
+
+ /** Texture manager. */
+ CHuiTextureManager* iTextureManager;
+ /** Theme Interface */
+ CHuiThemeManager* iThemeManager;
+
+ /** Font manager. */
+ THuiFontManager* iFontManager;
+
+ /** Text Style manager. */
+ CHuiTextStyleManager* iTextStyleManager;
+
+ /** Effects engine */
+ CHuiFxEngine* iEffectsEngine;
+
+ /** Skin. */
+ CHuiSkin* iSkin;
+
+ /** Visual factory. */
+ CHuiVisualFactory* iVisualFactory;
+
+ /** Environment observer object */
+ MHuiEnvObserver* iEnvObserver;
+
+ /** Time when input was last received. */
+ TTime iLastInputTime;
+
+ /** If ETrue, the input idle has been activated, so we are in idle state. */
+ TBool iInputIdleIsActive;
+
+ /** Number of seconds before sending an idle input notification. */
+ TInt iIdleThreshold;
+
+ TReal32 iPreviousFpsTime;
+
+ TUint iMaxCPUUtilization;
+
+ TInt iGlesRefCounter;
+
+ // FPS counter data
+ TUint iFrames;
+ TUint iMillisecondFromFPSUpdate;
+ TUint iRefreshIntervalReal;
+ TUint iFpsCounterThreshold;
+
+ mutable CHuiDisplay* iCurrentDisplay;
+
+ CActive::TPriority iRefreshLoopPriority;
+
+ TBool iRefreshLoopActive;
+
+
+ /** For measuring idle between frames */
+ TBool iIdleCPUValueMonitored;
+ TInt64 iIdleCPUValuePreviousTime;
+ TInt64 iIdleCPUValue;
+ RThread iIdleCPUValueThread;
+
+ CHuiCanvasTextureCache* iCanvasTextureCache;
+
+ RPointerArray<MHuiLowMemoryObserver> iLowMemoryObservers;
+ RPointerArray<MHuiMemoryLevelObserver> iMemoryLevelObservers;
+ THuiMemoryLevel iMemoryLevel;
+
+public:
+ class MHuiSwapObserver
+ {
+ public:
+ virtual void PrepareSwap()=0;
+ virtual void SwapComplete()=0;
+ virtual void ReleaseWindowServer(TBool aRelease = ETrue) = 0;
+ virtual void SetWgIdArray(TInt* aArray) =0;
+ };
+
+ MHuiSwapObserver* iSwapObserver;
+
+ IMPORT_C void AddLowMemoryObserver(MHuiLowMemoryObserver * aObserver);
+ IMPORT_C void RemoveLowMemoryObserver(MHuiLowMemoryObserver * aObserver);
+ IMPORT_C void NotifyLowMemory(TBool aEnable);
+
+ IMPORT_C void AddMemoryLevelObserver(MHuiMemoryLevelObserver * aObserver);
+ IMPORT_C void RemoveMemoryLevelObserver(MHuiMemoryLevelObserver * aObserver);
+ IMPORT_C void NotifyMemoryLevel(THuiMemoryLevel aMemoryLevel);
+ IMPORT_C THuiMemoryLevel MemoryLevel();
+
+ };
+
+#endif // __HUIENV_H__