/*

* Copyright (c) 2002 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 __AKNDIALOG_H__

#define __AKNDIALOG_H__

#include <eikdialg.h>

#include <eikmobs.h>

class CAknDialogAttributes;

/**

 * Base class for different types of @c AknDialogs

 *

 * Instances of the @c CAikDialog class may be created, and it is possible to

 * add controls directly to them. However it is more normal to create a 

 * subclass, and to handle the controls appearing on the dialog dynamically.

 */

class CAknDialog : public CEikDialog, public MEikMenuObserver

    {

    public :

        /** 

         * C++ default constructor. 

         */ 

        IMPORT_C CAknDialog() ;

        /** 

         * Handles Symbian 2nd phase construction.

         *

         * A menu resource MUST be specified - this function will Panic 

         * otherwise. If a menu is not required use @c CEikDialog!

         * 

         * @param aMenuTitleResourceId Title of the menu.

         */

        IMPORT_C void ConstructL( TInt aMenuTitleResourceId ) ;

        /**

         * Destructor. 

         */ 

        IMPORT_C ~CAknDialog() ;

        /**

         * From @c CEikDialog.

         *

         * Loads, displays, and destroys the dialog.

         * 

         * This function loads the specified dialog from a resource and 

         * displays it. The method then destroys the dialog when it exits,

         * therefore there is no need for the application program to 

         * destroy the dialog.

         *

         * @param aResourceId The resource ID of the dialog to load.

         * @return Zero, unless it is a waiting dialog. For a waiting dialog,

         *         the return value is the ID of the button that closed the

         *         dialog, or zero if it was the cancel button 

         *         (@c EEikBidCancel).

         */

		IMPORT_C TInt ExecuteLD( TInt aResourceId ) ;

        /**

         * From @c CEikDialog.

         *

         * Prepares the dialog, by constructing it from the specified resource.

         *

         * @param aResourceId The resource ID of the dialog.

         */

        IMPORT_C  void PrepareLC(TInt aResourceId);

        /**

         * From @c CEikDialog.

         *

         * Runs the dialog and returns the ID of the button used to dismiss it.

         *

         * The dialog is destroyed on exit.

         * 

         * This function is called by the dialog framework (@c ExecuteLD()) to

         * perform dynamic construction (layout) and to display/destroy the 

         * dialog. Static construction of the dialog must already be complete 

         * before this function is called, e.g. using @c PrepareLC().

         *

         * The function returns immediately unless @c EEikDialogFlagWait has 

         * been specified in the @c DIALOG resource. If @c EEikDialogFlagWait 

         * is specified, it returns when the dialog exits.

         *

         * @return The ID of the button used to dismiss the dialog.

         */

        IMPORT_C TInt RunLD();

		// From MEikMenuObserver

        /**

         * From @c MEikMenuObserver.

         *

         * Called by the Uikon framework to handle the emphasising or 

         * de-emphasising of a menu window.

         *

         * @c CEikMenuBar objects call this on their observer to emphasise

         * themselves when they are displayed, and de-emphasise themselves when

         * they stop displaying.

         *

         * @param aMenuControl The menu control. 

         * @param aEmphasis @c ETrue to emphasize the menu, 

         *        @c EFalse otherwise. 

         */ 

        IMPORT_C virtual void SetEmphasis( CCoeControl* aMenuControl,

                                           TBool aEmphasis ) ;

        /**

         * Not implemented.

         *

         * @param aResourceId Not used.

         * @param aMenuPane Not used.

         */ 

        IMPORT_C virtual void DynInitMenuPaneL( TInt aResourceId, 

                                                CEikMenuPane* aMenuPane ) ;

        /**

         * From @c MEikMenuObserver.

         *

         * Hides the menu.

         *

         * @param aCommandId Not used.

         */ 

		IMPORT_C virtual void ProcessCommandL( TInt aCommandId ) ;

		// From CCoeControl

        /** 

         * From @c CCoeControl.

         *

         * Handles key events.

         *

         * If a control wishes to process key events, it should implement this

         * function. The implementation must ensure that the function returns

         * @c 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 @c 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 @c EKeyWasConsumed).

         *

         * Each keyboard key press results in three separate events: 

         * @c EEventKeyDown, @c EEventKey, and @c EEventKeyUp, in that order.

         *

         * To receive key events, which can be processed by this function, 

         * the application should call @c 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.

         *

         * @param aKeyEvent The key event. 

         * @param aType The type of key event: @c EEventKey, @c EEventKeyUp or 

         *        @c EEventKeyDown. 

         * @return Indicates whether or not the key event was used by 

         *         this control. 

         */ 

		IMPORT_C TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,

                                             TEventCode aType) ;

        /** 

         * From @c CCoeControl.

         *

         * Responds to a change in focus.

         *

         * This is called whenever the control gains or loses focus, as a 

         * result of a call to @c SetFocus(). A typical use of 

         * @c FocusChanged() is to change the appearance of the control, 

         * for example by drawing a focus rectangle around it.

         *

         * @param aDrawNow Contains the value that was passed to it by 

         *        @c SetFocus(). 

         */ 

        IMPORT_C void FocusChanged(TDrawNow aDrawNow); 

        /** 

         * From @c CCoeControl.

         *

         * 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 @c EButton1Down are processed before 

         * @c HandlePointerEventL() is called, in order to transfer keyboard

         * focus to the control in which the @c EButton1Down event occurred.

         *

         * @param aPointerEvent The pointer event

         */ 

        IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);

	private: // formerly from MTopSetMember<CEikMenuBar>, now reserved

        IMPORT_C virtual void Reserved_MtsmPosition();

        IMPORT_C virtual void Reserved_MtsmObject();

    private:

        /**

        * From CAknControl

        */

        IMPORT_C void* ExtensionInterface( TUid aInterface );

    protected:

        /**

         * From @c CEikDialog.

         *

         * Handles a dialog button press for the specified button. 

         *

         * This function is invoked when the user presses a button in the

         * button panel. It is not called if the Cancel button is activated 

         * unless the @c EEikDialogFlagNotifyEsc flag has been set.

         *

         * If there is an Options key then pops up menu, otherwise exits.

         *

         * The function should be overridden by the derived class, and is 

         * usually used to validate the values of the dialog's controls. 

         * The function should return @c ETrue if it is OK to exit, and 

         * @c EFalse to keep the dialog active. It should always return

         * @c ETrue if the button with ID @c EEikBidOK was activated.

         *

         * @param aButtonId The ID of the button that was activated.

         * @return @c ETrue to validate and exit the dialog, 

         *         @c EFalse to keep the dialog active. If @c ETrue, the 

         *         dialog will be destroyed automatically by @c ExecuteLD(). 

         *         The default implementation returns @c ETrue no matter which

         *         button is pressed.

         */

		IMPORT_C virtual TBool OkToExitL( TInt aButtonId ) ;

        /**

         * From @c CEikDialog.

         *

         * Displays menu bar.

         */

		IMPORT_C void DisplayMenuL() ;

        /**

         * From @c CEikDialog.

         *

         * Hides menu bar.

         */

        IMPORT_C void HideMenu() ;

        /**

         * From @c CEikDialog.

         *

         * Checks if menu is displayed.

         * 

         * @return @c ETrue if menu is displayed,

         *         @c EFalse otherwise.

         */

        IMPORT_C TBool MenuShowing() const ;

        /**

         * From @c CEikDialog.

         *

         * Lays out the dialog's components when the size of the dialog 

         * is changed.

         */

		IMPORT_C virtual void SizeChanged();

        /**

         * From @c CEikDialog.

         *

         * Draws the control.

         * 

         * @param aRect Area to be drawn.

         */

        IMPORT_C virtual void Draw(const TRect &aRect) const;

	protected: // from MObjectProvider

        /** 

         * From @c MObjectProvider. 

         *

         * Gets Mop supply object of the given type.  

         *

         * @param aId Identifier for the supply object.

         * @return Pointer to the supply object type ID.

         */

        IMPORT_C TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

    private: 

		IMPORT_C virtual void CEikDialog_Reserved_1();

        IMPORT_C virtual void CEikDialog_Reserved_2();	

    private: // new function 

		IMPORT_C virtual void CAknDialog_Reserved();

    protected: // new function 

        /** 

         * Creates or replaces dialog's menu bar.

         *

         * @param aMenuTitleResourceId Title of the menu bar. 

         */ 

        void CreateMenuBarL(TInt aMenuTitleResourceId);

    protected:

        /**

         * Dialog's menu bar. 

         * Not owned.

         */

		CEikMenuBar* iMenuBar;

private:

	enum TAknDialogFlag

	    {

	    EAknDialogFlagDialogDeleted = 1,

        EAknDialogFlagDefaultSounds = 2,

		EAknDialogFlagNotConstructed = 4

	    };

    CAknDialogAttributes* iAttributes;  // Was TInt iSpare;

	CAknDialogAttributes* AttributesL();

	} ;

#endif // __AKNDIALOG_H__

// End of file