/*
* 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
