Empty default constructor.

Destructor.

Deletes any resources allocated by this CEikAppUi during its construction.

Gets a pointer to the application associated with this app UI.

Determines the current language the application is using to display its user interface.

Gets the total area of the screen available to the application.

This includes the space available for UI components like the menu bar.

Initialises this app UI with standard values.

The application's standard resource file will be read unless either the ENoAppResourceFile or ENonStandardResourceFile flag is specified.

Gets the area of the screen available to the application for drawing.

This does not include the space available for UI components like the menu bar.

The co-ordinates of the rectangle are relative to the whole screen area so, for example, the co-ordinate for the top, left point of the area available for drawing may be (0, 45).

Closes any currently visible popup menu.

Completes construction.

This simply calls BaseConstructL().

Returns the app UI inside which this app UI is embedded. Embedded app UIs are used for editing embedded documents.

Creates and opens a file with the given name.

The default implementation is empty.

CEikAppUi::ProcessMessageL()

Creates a hotkey control.

Constructs a CEikHotKeyControl whose CEikHotKeyTable is specified by a resource ID, and adds it to the control stack.

Wrapper for MEikAppUiFactory::CreateResourceIndependentFurnitureL MEikAppUiFactory::CreateResourceIndependentFurnitureL(CEikAppUi* aAppUi)

Gets a pointer to the app UI's associated document.

Closes the app UI.

Tests whether the application is set to fade when in the background.

Handles an application-specific event.

This implementation handles a change to the environment's colour scheme and informs everything on the control stack of the change.

CCoeAppUi::HandleApplicationSpecificEventL KUidValueEikColorSchemeChangeEvent

Handles user commands.

This is overridden by subclasses to handle commands passed on by the application framework. This function is called by CEikAppUi::ProcessCommandL(), and has an empty implementation. Commands can be invoked using a menu item, a hotkey, or a button (for instance in a toolbar or dialog).

Handles errors.

The default implementation of this function returns EErrorNotHandled.

Handles changes to the application when it switches to or from the foreground.

For instance it handles changes to the cursor visibility and to the fade state.

This function is called from HandleWsEventL() when an event occurs of type EEventFocusLost or EEventFocusGained.

Any application overriding this should first call this base implementation.

MCoeMessageObserver::TMessageResponse HandleMessageL(TUint32 aClientHandleOfTargetWindowGroup, TUid aMessageUid, const TDesC8& aMessageParameters)

Handles changes to the model associated with this CEikAppUi's application.

The implementation is empty in CEikAppUi.

Handles a change to the application's resources which are shared across the environment, for instance colours or fonts.

Handles sidebar menu commands.

This is called by the Uikon framework to handle invocation of a sidebar menu. See also MEikMenuObserver::HandleSideBarMenuL().

Note that not all UIs support a sidebar.

CCoeAppUi::HandleSystemEventL( const TWsEvent& aEvent ) CCoeAppUi::HandleSystemEventL

Handles window server events. CCoeAppUi::HandleWsEventL

Launches a popup menu.

This function is called by CEikAppUI::HandleSideBarMenuL().

Retrieves the parent.

Retrieves an object of the same type as that encapsulated in aId.

This function is used to allow to ask 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.

Opens the specified file.

The default implementation is empty.

CEikAppUi::ProcessMessageL()

Performs pre-exit processing to ensure the application will exit cleanly.

Checks for, and closes, popups and menubars before calling HandleCommandL() MEikCommandObserver::ProcessCommandL( TInt aCommand ) CEikAppUi::HandleCommandL( TInt aCommand )

Processes shell commands.

The Uikon application framework calls this overload when an application is launched by the user opening a file from the shell or when a Create new file command is issued.

This overload simply returns whether or not the file aDocumentName exists.

Many document based applications will override this function to invoke the 2-parameter utility version of this methid.

CEikAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName& aDocumentName)

Processes shell commands.

This is the ProcessCommandParametersL() method that the Uikon application framework will call at application startup. The implementation will extract the command, document file name, and tail parameteres from the command line and call the 3-parameter version of this method.

The default implementation will simply returns whether or not the file aDocumentName exists.

CEikAppUi::ProcessCommandParametersL(TApaCommand aCommand ,TFileName& aDocumentName, const TDesC8& aTail)

This is a convinience utility method that an application can call from an overriden version of the virtual ProcessCommandParametersL() taking three arguments. This method will not be called unless explicitly used by the application in this way.

This method is useful for applications that are used to view or edit document files, such as text documents or spreadsheets.

This method will make an application automatically open the document file that was last open in the application, unless a document file is explicitly defined as part of the command line, and the Open or Create commands are specified.

This method will call CEikAppUi::ValidFileType() to find out if the specified document file can be opened by this application.

In detail: If aCommand is EApaCommandCreate, the function simply returns EFalse as the file does not yet exist.

If aCommand is EApaCommandOpen, the function tests whether the specified document is valid and exists. If not, the function attempts to generate a valid default filename and returns that in aDocumentName provided the file name portion of the specified full path name has valid format.

If aCommand is any other value, the function tests whether the most recently open document that is valid for the application exists, and returns that in aDocumentName.

The file must be a valid document file, as indicated by the UID value(s),otherwise the function generates a new filename. An application may handle the request by overriding CEikAppUi::ValidFileType() if required.

CEikAppUi::ValidFileType()

Processes Application Architecture messages.

This is overridden by subclasses to handle messages sent from the Application Architecture framework. This implementation only recognises the message UIDs KUidApaMessageSwitchOpenFileValue and KUidApaMessageSwitchCreateFileValue. It performs no action if the message contains other values.

CCoeAppUi::HandleMessageReadyL() CApaTask::SendMessage()

Reads the application UI information at the specified offset in the app's standard resource file.

This function is called by BaseConstructL(), unless either of the ENoAppResourceFile or ENonStandardResourceFile flags was specified.

Reports a resource change to the application.

Calls ReportResourceChangedToAppL( aEventId ) on recursively on each ContainerAppUi. For use with embedded applications (where iContanerAppUI != NULL) CEikAppUi::ReportResourceChangedToAppL(TInt aType)

Saves any changes made to the app UI's associated document, if the document is marked as having changed.

Saves the app UI's associated document, or sets the document as changed, if the app UI is embedded.

Marks the app UI's associated document as having changed.

Sets this app UI's document.

The document associated with the app UI is initially owned by CEikProcess, and there is usually no reason to change it with this function.

Sets the embedded document's observer and read only state.

MEikMenuObserver::SetEmphasis(CCoeControl* aMenuWindow,TBool aEmphasis)

This is a virtual function. The base class implemenatiation causes the root window and all of its children to change to the desired faded state.

Stops displaying the application's menu bar.

If the application has no menu bar, or if the menu bar is not visible, this function has no effect.

A valid file has fileType which matches the applications Uid.

This method is used in combination with CEikAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName& aDocumentName).

Override this method to return ETure if the application can handle documents associated with the UID aFileUid. If not, return EFalse (default).

CEikAppUi::ProcessCommandParametersL(TApaCommand aCommand, TFileName& aDocumentName)

Application resource file and screen furniture flags, passed to BaseConstructL().

A pointer to the containing app UI. This is NULL for non-embedded apps.

A pointer to the application's document.

Embedded document observer.

Indicates whether or not this is the app UI for an embedded, read-only document.