svgtviewer/SvgtViewerPlugin/UIControlSrc/SVGTUIDialog.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 25 May 2010 12:28:38 +0300
branchRCL_3
changeset 14 1882882c7f9c
parent 0 632761c941a7
permissions -rw-r--r--
Revision: 201019 Kit: 2010121

/*
* Copyright (c) 2004,2005 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:  This file implements the SVGT Dialog which
*                is used to display SVGT content
*
*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <uikon/eikctrlstatus.h>
#endif

#include <e32std.h>
#include <AknDialog.h>
#include <coeaui.h>
#include <eikenv.h>
#include <bautils.h>
#include <eikdialg.h>
#include <eikmenup.h>
#include <eikspane.h>

#ifdef __SERIES60_HELP
#include <hlplch.h>
#endif // __SERIES60_HELP

#include <coeaui.h>
#include <aknnavi.h> 
#include <aknnavide.h> 
#include <AknWaitNoteWrapper.h>
#include <SVGRequestObserver.h>
#include <aknnotewrappers.h>
#include <akntitle.h>
#include <data_caging_path_literals.hrh>
#include <StringLoader.h>
#include <svgtuicontrol.rsg>
#include <csxhelp/svgt.hlp.hrh>
//-----------

// User Includes
#include "SVGTAppObserver.h"
#include "SVGTCustControl.h"
#include "SVGTUIDialog.h"
#include "svgtfileviewdetails.h"

#include "SVGTUIDialog.hrh"
#include "SvgtDecoratorControl.h"

const TInt KButtonContainerDisplayTime = 5000000;

// Constants

// The Middle softkey has position 3 at button group's stack
const TInt KMiddleSKId=3;
_LIT( KResourceFileName, "Z:SVGTUIControl.rsc" );
#ifdef _DEBUG
//_LIT( KUnknownCommandStr, "Unknown Command" );
#endif

#ifdef __SERIES60_HELP
// Help Context UID = DLL UID3
const TUid KSvgtHelpContextUid = { 0x101F8749 };
#endif // __SERIES60_HELP

// Times longer than this many seconds are shown using the long format
const TInt KShortTimeLimit = 59*60 + 59; 

// Maximum number of seconds shown in the time duration field
const TInt KMaxTotalTimeSeconds = 9*60*60 + 59*60 + 59; // 59:59

// Maximum length for both the time elapsed/remaining string "mm:ss/mm:ss"
// and post-recording text "Length: mm:ss"
const TInt KMaxTimeTextLength = 40;

// This many microseconds in a second
const TInt KMicro = 1000000;  

// Key Constant for toggling between Full/Normal Screen
const TInt KSvgScreenToggleKey = '*';
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CSVGTUIDialog::CSVGTUIDialog
// Default Constructor. Initialises Dialog State Variables.
// -----------------------------------------------------------------------------
//
CSVGTUIDialog::CSVGTUIDialog()
    {
    // SVGT Viewer State Variables
    iSaveEnable = EFalse;
    iPreview = EFalse;
    iCustControl = NULL;
    iAppObserver = NULL;
    iIsVolumeMuted = EFalse;
    iLastCommandID = EAknSoftkeyOptions;
    iIsButtonContainerVisible = ETrue;
    iQuietExitWhenOrientationChange = EFalse;
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::ConstructL
// Second Phase Constructor for CSVGTUIDialog. Opens resource file, reads the
// dialog menu resource and calls CAknDialog::ConstructL with the resource as
// param.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::ConstructL()
    {
    // Find which drive this DLL is installed.
    TFileName fileName;

    // Get the full resource file
    TParse lParse;

    // Add the resource dir
    lParse.Set( KResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL);

    // Get the filename with full path
    fileName = lParse.FullName();

    BaflUtils::NearestLanguageFile( iEikonEnv->FsSession(), fileName ); //for
                                                               // localization
    iResourceOffset = iEikonEnv->AddResourceFileL( fileName );

    // Read time format strings from AVKON resource
    iTimeFormatShort = 
        iEikonEnv->AllocReadResourceL( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );
    iTimeFormatLong =
        iEikonEnv->AllocReadResourceL( R_QTN_TIME_DURAT_LONG );

    iBtnCntrTimer = CPeriodic::NewL( CActive::EPriorityStandard);
    CAknDialog::ConstructL( R_SVGT_DIALOG_MENUBAR );

    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::NewL
// Factory function for creating CSVGTUIDialog objects.
// Returns: CSVGTUIDialog* ; Pointer to the created object.
//          Leaves if error occurs during creation.
// -----------------------------------------------------------------------------
//
EXPORT_C CSVGTUIDialog* CSVGTUIDialog::NewL()
    {
    CSVGTUIDialog* self = CSVGTUIDialog::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::NewLC
// Factory function for creating CSVGTUIDialog objects. It also pushes the
// created dialog object onto the cleanup stack.
// Returns: CSVGTUIDialog* ; Pointer to the created object.
//          Leaves if error occurs during creation.
// -----------------------------------------------------------------------------
//
EXPORT_C CSVGTUIDialog* CSVGTUIDialog::NewLC()
    {
    CSVGTUIDialog* self = new ( ELeave ) CSVGTUIDialog();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// Destructor
CSVGTUIDialog::~CSVGTUIDialog()
    {
    if ( iResourceOffset != 0 )
        {
        iEikonEnv->DeleteResourceFile( iResourceOffset );
        }
    // Custom Control will be automatically destroyed by dialog framework
    iCustControl = NULL;
    // App Observer is reset.
    iAppObserver = NULL;

    // Set the text in status pane to the stored one            
    if (iAppTitleText)
        {
        // Get the Status Pane Control
        CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();
        // Get the title pane 
        CAknTitlePane* tp = NULL;
        TRAPD( errGetControl, 
            tp = static_cast< CAknTitlePane* >( sp->ControlL( 
            TUid::Uid( EEikStatusPaneUidTitle ) ) ) );
        if ( errGetControl == KErrNone && tp )
            {
            //set application name in the title pane
            TRAPD( errSetText, 
                tp->SetTextL(*iAppTitleText) );
            if ( errSetText != KErrNone )
                {
                // No error handling here
                }
            }
        
        delete iAppTitleText;
        iAppTitleText = NULL;

        delete iProgressText;
        iProgressText = NULL;
        }
    
    // Clear the Navi-Pane Decorator    
    if ( iNaviDecorator )
        {
        // Restore the old navi-pane
        CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();
        
        CAknNavigationControlContainer* np = NULL;
        TRAPD( errGetNaviControl, 
            np = static_cast< CAknNavigationControlContainer* >
            ( sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) ) );
        if ( errGetNaviControl == KErrNone && np )
            {
            TRAPD( errPushDefNaviControl, 
                np->PushDefaultL ()); // Set default.    
            if ( errPushDefNaviControl != KErrNone )
                {
                // No error handling here.
                }
            }
        delete iNaviDecorator;
        }    
    iCbaGroup=NULL;
    // Callers responsibility of closing the file handle.
    iFileHandlePtr = NULL;
    // Delete the format strings
    delete iTimeFormatShort;
    delete iTimeFormatLong;
    
    delete iBtnCntrTimer;
    }

TInt CSVGTUIDialog::ButtonContainerTimerCallBack(TAny* aAny)
    {
    CSVGTUIDialog* dlg = (CSVGTUIDialog*)(aAny);
    dlg->iBtnCntrTimer->Cancel();
    dlg->iIsButtonContainerVisible = EFalse;
    TRAP_IGNORE(dlg->SwitchDialogLayoutL( ETrue ));
    
    return KErrNone;
    }

TBool CSVGTUIDialog::HandleCustControlPointerEventL(const TPointerEvent& /* aPointerEvent */)
    {
	TBool fullScreenStatus;
	TBool isEventHandled = EFalse;
    TCallBack callBack(CSVGTUIDialog::ButtonContainerTimerCallBack, this);

    iBtnCntrTimer->Cancel();
    
    if(iIsButtonContainerVisible)
        {
        return isEventHandled;
        }
    
	iCustControl->GetCurrentFullScreenStatus(fullScreenStatus);
    if(fullScreenStatus)
        {
        TRect appRect = iEikonEnv->EikAppUi()->ApplicationRect();
        
        if(iBtnGrpPos.iX && iBtnGrpPos.iY)
            SetSize(TSize(appRect.Width() - iBtnGrpSize.iWidth, appRect.Height() - iBtnGrpSize.iHeight));
        if(iBtnGrpPos.iX)
            SetSize(TSize(appRect.Width() - iBtnGrpSize.iWidth, appRect.Height()));
        else if(iBtnGrpPos.iY)
            SetSize(TSize(appRect.Width(), appRect.Height() - iBtnGrpSize.iHeight));
        
        CEikButtonGroupContainer& bgc = ButtonGroupContainer();
        //bgc.MakeVisible(ETrue);
        //bgc.SetSize(iBtnGrpSize);
        //bgc.SetExtent(iBtnGrpPos, iBtnGrpSize);
        //bgc.DrawDeferred();
        iIsButtonContainerVisible = ETrue;
        isEventHandled = ETrue;
        iBtnCntrTimer->Start(KButtonContainerDisplayTime, 0, callBack);
        }
        
    return isEventHandled;
    }
    
// -----------------------------------------------------------------------------
// CSVGTUIDialog::ExecuteLD
// Reimplements CAknDialog::ExecuteLD. It initialises the member variables of
// the class and calls CAknDialog::ExecuteLD() with the dialog resource.
// -----------------------------------------------------------------------------
//
TInt CSVGTUIDialog::ExecuteLD(
    RFile& aFileHandle,         // Filename of SVGT Content
    MSvgtAppObserver* ptr )     // Applications Implementation of callbacks
    {
    // Save this pointer since there are leaving functions in the flow
    CleanupStack::PushL( this );    

    iFileHandlePtr = &aFileHandle;
    iIsFileHandleValid = ETrue;
    iAppObserver = ptr;
    iQuietExitWhenOrientationChange = iAppObserver->ExitWhenOrientationChange();

    // Get the Status Pane Control
    CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();
    
    // Get the Title Pane Control
    CAknTitlePane* tp = static_cast< CAknTitlePane* >( sp->ControlL(
            TUid::Uid( EEikStatusPaneUidTitle ) ) );

    // Store the Application's title text
    iAppTitleText = HBufC::NewL(tp->Text()->Length());
    *iAppTitleText = *tp->Text();
    
    // Display the filename in the title pane of application
    
    TFileName lFileName;
    // Get the file name from the file handle
    if ( !aFileHandle.Name( lFileName ) )
        {
        TParse p;
        p.Set( lFileName, NULL, NULL);

        // SetTextL also ensures that if the length exceeds the layout space
        // available the text is truncated from the end.
        tp->SetTextL( p.NameAndExt() ); // p.NameAndExt() gives "Filename.ext"
        
        }

    CSVGTDrmHelper *drmHelper = CSVGTDrmHelper::NewLC();
    // Check if the "Save" Option should be shown or not.
    // The calling application of the dialog decides this.
    if ( iAppObserver )
        {
        iSaveEnable = iAppObserver->CanShowSave();
        }       
     
    // Check Rights Status
    iPreview = drmHelper->IsPreviewL( aFileHandle );
    
    CleanupStack::PopAndDestroy( drmHelper );
    
    // ExecuteLD will delete this, so we have to Pop it...
    CleanupStack::Pop( this );
    
    if ( iPreview )
        {              
        return  CAknDialog::ExecuteLD( R_SVGT_VIEWER_PREVIEW_DIALOG );  
        }
    else
        {
        return CAknDialog::ExecuteLD( R_SVGT_VIEWER_DIALOG );       
        }
    
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::FormatTimeL
// Convert a time given in seconds to a descriptor.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::FormatTimeL( 
                              const TUint& aDuration, // duration in 
                                                      // seconds
                              TDes& aBuf   // Buffer holding formatted 
                                           // string
                               ) const
                                           
    {
    TTime time( TInt64( aDuration ) * KMicro );

    if ( time.Int64() > TInt64( KMaxTotalTimeSeconds ) * KMicro )
        {
        time = TInt64( KMaxTotalTimeSeconds ) * KMicro;
        }

    if ( time.Int64() < TInt64( KShortTimeLimit ) * KMicro )
        {
        time.FormatL( aBuf, *iTimeFormatShort );
        }
    else
        {
        time.FormatL( aBuf, *iTimeFormatLong );
        }

    // Arabic number conversion
    AknTextUtils::LanguageSpecificNumberConversion( aBuf );
    }
    
// -----------------------------------------------------------------------------
// CSVGTUIDialog::SaveNeededL
// This function checks if Save is displayed and saving is already done
// and prompts a confirmation query to the user and then calls DoSaveL
// -----------------------------------------------------------------------------
//
TBool CSVGTUIDialog::SaveNeededL( TInt aButtonId )
    {
    if ( ( iAppObserver->CanShowSave() || 
           iCustControl->IsTextContentChanged()) &&
         !iAppObserver->IsSavingDone() && 
         !iPreview &&            
         LaunchSaveQueryDialogL() )
        {
        iAppObserver->DoSaveL( aButtonId );
        return ETrue;       
        }
    else
        {
        return EFalse;
        }          
    }
// -----------------------------------------------------------------------------
// CSVGTUIDialog::LaunchSaveQueryDialogL
// -----------------------------------------------------------------------------
//
TBool CSVGTUIDialog::LaunchSaveQueryDialogL() const
    {
    HBufC* titleText = NULL;

    TFileName lFileName;
    if ( iFileHandlePtr )
        {
        iFileHandlePtr->Name( lFileName );
        }
    else
        {
        return EFalse;
        }
    titleText = StringLoader::LoadLC( R_QTN_SVGT_QUERY_CONF_SAVE_DOWNLOADED, 
                              lFileName );

    CAknQueryDialog* query = CAknQueryDialog::NewL( );
    TBool retVal = query->ExecuteLD( R_SVGT_CONFIRMATION_QUERY_YES_NO, 
                                                   *titleText );
    CleanupStack::PopAndDestroy( titleText );
    
    if ( retVal == EAknSoftkeyOk || retVal == EAknSoftkeyYes )
        {
        return ETrue;
        }
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::SwitchDialogLayoutL
// This function changes the layout of the dialog
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::SwitchDialogLayoutL( TBool aIsFullScreen )
    {
    if ( aIsFullScreen )
        {
        // Full Screen Mode
        // Expand Dialog Window to occupy full screen
        SetExtentToWholeScreen();
        // Hide the Status Pane
        CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();
        sp->MakeVisible( EFalse );
        
        // Hide the CBA
        CEikButtonGroupContainer* cp = &( ButtonGroupContainer() );
        //cp->SetExtent( TPoint( 0, 0 ), TSize( 0, 0) );
        cp->SetSize( TSize( 0, 0) );
        
        }
    else
        {
        // Normal Screen Mode
        // Show the Status Pane
        CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();
        sp->MakeVisible( ETrue );
        
        // Restore the size and position of the dialog
        // to normal screen size(Client Rectangle)
        TRect lRect;
        iCustControl->GetNormalScreenLayoutRect( lRect );
        SetSizeAndPosition( lRect.Size() );
        // Restore original layout
        Layout();
        iBtnCntrTimer->Cancel();
        }
    
    iIsButtonContainerVisible = !aIsFullScreen;
    
    }
    
// -----------------------------------------------------------------------------
// CSVGTUIDialog::DynInitMenuPaneL
// Reimplements CAknDialog::DynInitMenuPaneL inorder to support dynamic hiding
// of menu items based on current state of the viewer.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::DynInitMenuPaneL(
    TInt aResourceId,           // Resource Id for which this func is called
    CEikMenuPane* aMenuPane )   // Menupane object pointer for manipulation
    {
    iBtnCntrTimer->Cancel();
   
if(
  (aResourceId==R_SVGT_DIALOG_MENU)
  &&iCustControl->GetMSKLabelFlag(EAknSoftkeyContextOptions)
  &&(aMenuPane)
  )
    	{
    	iCustControl->ChangeMSKLabelFlag(EAknSoftkeyContextOptions);
    	if ( iAppObserver )
    		{
    		iSaveEnable = iAppObserver->CanShowSave();
    		}
    	aMenuPane->SetItemDimmed(ESvgtDlgSaveCommand,
    	                        !( iSaveEnable||
    	                        iCustControl->IsTextContentChanged() ) );
          
        TSvgtViewerAnimStatus lAnimState;
        iCustControl->GetCurrentAnimState( lAnimState );
        TBool isLoadingDone = iCustControl->IsProcessDone();
        aMenuPane->SetItemDimmed(ESvgtDlgPlayCommand,
        						!isLoadingDone ||
        						(lAnimState == ESvgAnimPlayingState ));
        aMenuPane->SetItemDimmed(ESvgtDlgPauseCommand,
                                !isLoadingDone ||
                                (lAnimState != ESvgAnimPlayingState ));                                                
        aMenuPane->SetItemDimmed(ESvgtDlgStopCommand,
                                !isLoadingDone ||
                                (lAnimState ==ESvgAnimStoppedState));                                
                                         
          
        //All the other menu items are dimmed since they are not the part of
        // context menu
        aMenuPane->SetItemDimmed(ESvgtDlgZoomInCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgZoomOutCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgSelectTextCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgEditTextCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgLoopCascadeCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgFindTextCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgFullScreenCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgNormalScreenCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgListRotateCascadeCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgViewDetailsCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgListDownloadCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgHelpCommand,ETrue);
        aMenuPane->SetItemDimmed(EAknCmdExit,ETrue);           
        #ifdef RD_SVGT_AUDIO_SUPPORT
        aMenuPane->SetItemDimmed( ESvgtDlgMuteCommand,ETrue);
        aMenuPane->SetItemDimmed( ESvgtDlgUnmuteCommand,ETrue);
        aMenuPane->SetItemDimmed(ESvgtDlgSetVolumeCommand,ETrue);
        #endif //RD_SVGT_AUDIO_SUPPORT         
        }
    
    else if ( ( aResourceId == R_SVGT_DIALOG_MENU ) && ( aMenuPane ) )
        {
        if ( iAppObserver )
            {
            iSaveEnable = iAppObserver->CanShowSave();
            }
        aMenuPane->SetItemDimmed(
                        ESvgtDlgSaveCommand,
                        !( iSaveEnable || 
                        iCustControl->IsTextContentChanged() ) );
        TInt zoomLvl = 0;
        iCustControl->GetCurrentZoomLevel( zoomLvl );
        aMenuPane->SetItemDimmed(
                        ESvgtDlgZoomOutCommand,
                        ( zoomLvl == 0 ) );
        
        // Select Text Option
        aMenuPane->SetItemDimmed( ESvgtDlgSelectTextCommand, 
            !iCustControl->IsTextSelectOn() );
        
        // Edit Text Option
        aMenuPane->SetItemDimmed( ESvgtDlgEditTextCommand, 
            !iCustControl->IsTextEditOn() );
            
        if ( !iCustControl->IsAnimationPresent() )
            {
            // No Animations case - dim the Play/Pause/Stop buttons
            aMenuPane->SetItemDimmed(
                        ESvgtDlgPlayCommand,
                        ETrue );

            aMenuPane->SetItemDimmed(
                        ESvgtDlgPauseCommand,
                        ETrue );
            
            aMenuPane->SetItemDimmed(
                        ESvgtDlgStopCommand,
                        ETrue );
            aMenuPane->SetItemDimmed(
                        ESvgtDlgLoopCascadeCommand,
                        ETrue );                            
            }
            else
                {
                // Animations case - normal behaviour
                // Play/Pause Options
                TSvgtViewerAnimStatus lAnimState;
                iCustControl->GetCurrentAnimState( lAnimState );
                TBool isLoadingDone = iCustControl->IsProcessDone();
                
                aMenuPane->SetItemDimmed(
                                ESvgtDlgPlayCommand,
                                !isLoadingDone || 
                                 ( lAnimState == ESvgAnimPlayingState ) );

                aMenuPane->SetItemDimmed(
                                ESvgtDlgPauseCommand,
                                !isLoadingDone || 
                                 ( lAnimState != ESvgAnimPlayingState ) );
                
                aMenuPane->SetItemDimmed(
                                ESvgtDlgStopCommand,
                                !isLoadingDone || 
                                 ( lAnimState == ESvgAnimStoppedState ) );
                // Loop Option 
                aMenuPane->SetItemDimmed(
                                ESvgtDlgLoopCascadeCommand,
                                !isLoadingDone || 
                                !iCustControl->IsLoopAllowed() );
                }
#ifdef RD_SVGT_AUDIO_SUPPORT            
        aMenuPane->SetItemDimmed( ESvgtDlgMuteCommand, iIsVolumeMuted );

        aMenuPane->SetItemDimmed( ESvgtDlgUnmuteCommand, !iIsVolumeMuted );
#endif //RD_SVGT_AUDIO_SUPPORT
        TBool isFullScreenOn;
        iCustControl->GetCurrentFullScreenStatus( isFullScreenOn );
        aMenuPane->SetItemDimmed(
                        ESvgtDlgFullScreenCommand,
                        isFullScreenOn );

        aMenuPane->SetItemDimmed(
                        ESvgtDlgNormalScreenCommand,
                        !isFullScreenOn );

        aMenuPane->SetItemDimmed(
                        ESvgtDlgFindTextCommand,
                        EFalse );

        aMenuPane->SetItemDimmed(
                        ESvgtDlgViewDetailsCommand,
                        !iIsFileHandleValid);
        aMenuPane->SetItemDimmed(
                        ESvgtDlgListDownloadCommand,
                         !iAppObserver->CanShowDownload() );
        }
        else 
            {
            if ( ( aResourceId == R_SVGT_LOOP_SUBMENU ) && ( aMenuPane ) )
                {
                // Loop On/Off Submenu option
                TBool isLoopOn = ETrue;
                iCustControl->GetCurrentLoopStatus( isLoopOn );
                if ( isLoopOn )
                    {
                    aMenuPane->SetItemButtonState( ESvgtDlgLoopOnCommand, 
                                                   EEikMenuItemSymbolOn );
                    aMenuPane->SetItemButtonState( ESvgtDlgLoopOffCommand,
                                             EEikMenuItemSymbolIndeterminate );
                    }
                    else
                        {
                        aMenuPane->SetItemButtonState( ESvgtDlgLoopOffCommand, 
                                                       EEikMenuItemSymbolOn );
                        aMenuPane->SetItemButtonState( ESvgtDlgLoopOnCommand, 
                                             EEikMenuItemSymbolIndeterminate );
                        }
                }
            }
    }
// -----------------------------------------------------------------------------
// CSVGTUIDialog::DrawMSKLabelL
// Reimplements MSVGTMSKImplL::DrawMSKLabelL.This function is called by the
// CSVGTCustControl whenever MSK label needs to be updated.
// -----------------------------------------------------------------------------
// 
void CSVGTUIDialog::DrawMSKLabelL(TInt aResourceID,TInt aCommandID)
{
    iLastCommandID = aCommandID;
	iCbaGroup= &( ButtonGroupContainer() );
  	HBufC* middleSKText = StringLoader::LoadLC(aResourceID );
    iCbaGroup->AddCommandToStackL(KMiddleSKId, aCommandID,*middleSKText );
    iCbaGroup->MakeCommandVisible(aCommandID, ETrue);
	CleanupStack::PopAndDestroy( middleSKText );
	iCbaGroup->DrawDeferred();		
}

// ----------------------------------------------------------------------------
// CSVGTUIDialog::RemoveMSKLabel
// Reimplements MSVGTMSKImplL::RemoveMSKLabel.This function is called by the 
// CSVGTCustControl before adding new MSK label to button group stack.   
// ----------------------------------------------------------------------------
//
void CSVGTUIDialog::RemoveMSKLabel()
{
	iCbaGroup= &( ButtonGroupContainer() );
	MEikButtonGroup* lButtonGroup=iCbaGroup->ButtonGroup();
	TInt lCmdID=lButtonGroup->CommandId(KMiddleSKId);
	iCbaGroup->RemoveCommandFromStack(KMiddleSKId,lCmdID);
	iCbaGroup->DrawDeferred();

}

// -----------------------------------------------------------------------------
// CSVGTUIDialog::OkToExitL
// Reimplements CAknDialog::OkToExitL inorder to display custom menu and
// trap the back softkey to provide restore view functionality/exit.
// -----------------------------------------------------------------------------
//
TBool CSVGTUIDialog::OkToExitL( TInt aButtonId ) // ButtonId of button pressed
    {
    if ( aButtonId == EAknSoftkeyOptions )
        {
        DisplayMenuL();
        return EFalse;
        }
    else if(aButtonId==EAknSoftkeyContextOptions)
   		{
        //Flag to differentiate context menu from normal options menu
       	iCustControl->ChangeMSKLabelFlag(aButtonId);
         		
       	//Display context menu 
       	iMenuBar->SetContextMenuTitleResourceId( R_SVGT_DIALOG_MENUBAR );
  		iMenuBar-> TryDisplayContextMenuBarL();
    		    
    	//No task swapper for context menu
   	    iMenuBar->SetMenuType(CEikMenuBar::EMenuOptionsNoTaskSwapper);
      			
     	//Restore the options menu
   		iMenuBar->SetMenuTitleResourceId( R_SVGT_DIALOG_MENUBAR );
   		iMenuBar->SetMenuType(CEikMenuBar::EMenuOptions);
          
       	return EFalse;
        }
    else if(aButtonId ==EAknSoftkeySave)
    	{
    	//Save the content
    	ProcessCommandL(ESvgtDlgSaveCommand);   
    	return EFalse;
    	}
  
    else
        {
        if ( aButtonId == EAknSoftkeyBack )
            {
            // Check whether full screen is active
            TBool isFullScreenActive;
            iCustControl->GetCurrentFullScreenStatus( isFullScreenActive );

            if ( isFullScreenActive )
                {
                //  Yes[FullScreen]: revert back to normal screen
                ProcessCommandL( ESvgtDlgNormalScreenCommand );
                return EFalse;
                }

            // Check whether content is zoomed in
            TInt zoomLvl = 0;
            iCustControl->GetCurrentZoomLevel( zoomLvl );

            if ( zoomLvl > 0 )
                {
                //  Yes[ZoomedIn]: restore to original view
                iCustControl->ProcessViewerCommandL(
                    ESvgtDlgZoomOptimalCommand );
                return EFalse;
                }
            return !SaveNeededL( aButtonId );            
            }
            else
                {
                // Ignore Select Key..
                if ( aButtonId == EAknSoftkeySelect || aButtonId == EEikBidOk )
                    {
					//If animation on mousedown/mouseup is present trigger it
					if(iCustControl->GetMSKLabelFlag(aButtonId))
						{
						TKeyEvent lKeyEvent;
						lKeyEvent.iScanCode=EStdKeyDevice3;
						iCustControl->OfferKeyEventL(lKeyEvent,EEventKey);	
						iCustControl->ChangeMSKLabelFlag(aButtonId);
						TRAP_IGNORE(iCustControl->SetMSKLabelL());
						}
					
						
				
                    // Select button pressed, ignore.
                    return EFalse;
                    }
                if ( aButtonId == EEikCmdExit )
                    {
                    return !SaveNeededL( aButtonId ); 
                    }
                }
            
        }
        
    return ETrue;
    }


// -----------------------------------------------------------------------------
// CSVGTUIDialog::IsLoadingDone
// This function is called by the application to check whether the
// loading of the svg content is done.
// -----------------------------------------------------------------------------
//
TBool CSVGTUIDialog::IsLoadingDone()
    {
    return iCustControl->IsProcessDone();
    }   

// -----------------------------------------------------------------------------
// CSVGTUIDialog::HandleApplicationForegroundEvent
// This API is used by the application to give background/foreground events
// to the Dialog. The dialog inturn passes the events to custom control.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::HandleApplicationForegroundEvent( TBool aForeground )
    {
    if ( iCustControl )
        {
        iCustControl->HandleApplicationForegroundEvent( aForeground );
        }
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::StopUsingContentFileHandle
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::StopUsingContentFileHandle()
    {
    // NOTE: Currently the custom control and the engine are
    // not actively using the File handle. e.g. Engine uses
    // the file handle only during loading of content. And custom
    // control uses it when File Details are shown. 
    // If required, in future need to pass this event to custom control.
    // Block the filedetails option now.
    iIsFileHandleValid = EFalse;
    }
    
// -----------------------------------------------------------------------------
// CSVGTUIDialog::StartUsingContentFileHandle
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::StartUsingContentFileHandle()
    {
    iIsFileHandleValid = ETrue;
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::IsTextContentChanged
// Function used by the client to check if text in the content was modified, 
// to check if save is needed.
// -----------------------------------------------------------------------------
//
TBool CSVGTUIDialog::IsTextContentChanged()
    {
    return (iCustControl->IsTextContentChanged());    
    }
        
// -----------------------------------------------------------------------------
// CSVGTUIDialog::SaveSvgDom
// Function used by the client to save the modified svg content
// -----------------------------------------------------------------------------
//
TInt CSVGTUIDialog::SaveSvgDom( const TDesC& aFileName )
    {
    if ( iCustControl )
        {
        return ( iCustControl->SaveSvgDom( aFileName ) );
        }
        else 
            {
            return KErrGeneral;            
            }
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::SaveComplete
// Function used by the client to indicate saving is complete
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::SaveComplete( const TInt aError )
    {
    if ( !aError )
        {
        // Indicate to Custom Control to perform any cleanup
        // once save is complete
        iCustControl->SaveComplete( aError );
        }
    }
    
// -----------------------------------------------------------------------------
// CSVGTUIDialog::ProcessCommandL
// Reimplements CAknDialog::ProcessCommandL inorder to handle dialog menu
// commands.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::ProcessCommandL( TInt aCommandId )  // Command Id
    {
    // The Commands are handled by the custom CCoe Control and
    // a boolean varialble is used inorder to keep track whether
    // the control command processing needs to be invoked or not.
    TBool procCmdReqd = ETrue;
    CAknDialog::ProcessCommandL( aCommandId );
    switch ( aCommandId )
        {
        case ESvgtDlgSaveCommand: 
            if ( iAppObserver )
                {
                iAppObserver->DoSaveL( ESvgtDlgCommand1 );
                }
            break;
        case ESvgtDlgHelpCommand:
#ifdef __SERIES60_HELP            
            procCmdReqd = EFalse;
            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(),
                iEikonEnv->EikAppUi()->AppHelpContextL() );
#endif // __SERIES60_HELP           
            break;
        case ESvgtDlgFindTextCommand:
            break;
        case ESvgtDlgViewDetailsCommand:
            break;
        case ESvgtDlgListDownloadCommand:    
            {          
            if ( iAppObserver )
                {
                iAppObserver->DisplayDownloadMenuL();
                }                           
            break;              
            }
        case ESvgtDlgFullScreenCommand:
            {
            if ( iCustControl )
                {
                iCustControl->SetCurrentFullScreenStatus( ETrue );
                SwitchDialogLayoutL( ETrue ); // ETrue = Full Screen Mode
                // Redraw Status Pane and CBA by doing a draw on dialog
                DrawNow();
                }
            break;
            }
        case ESvgtDlgNormalScreenCommand:
            {
            if ( iCustControl )
                {
                iCustControl->SetCurrentFullScreenStatus( EFalse );            
                SwitchDialogLayoutL( EFalse ); // EFalse = Normal Screen Mode
                // Redraw Status Pane and CBA by doing a draw on dialog
                DrawNow();                
                }
            break;
            }
//@@ Touch support
#ifdef RD_SVGT_AUDIO_SUPPORT
        case ESvgtDlgMuteCommand:
            iIsVolumeMuted = !iIsVolumeMuted;
            iCustControl->SetPresentationVolume(0);

            if(iCustControl->IsContentFinite())
                SetNaviPaneInfoL(iIsVolumeMuted, *iProgressText);
            else
                SetNaviPaneInfoL(iIsVolumeMuted, KNullDesC);
            break;
            
        case ESvgtDlgUnmuteCommand:
            iIsVolumeMuted = !iIsVolumeMuted;
            // Set the volume level to the value it was before muting
            iCustControl->SetPresentationVolume(iCustControl->GetPrevVolume());
            
            if(iCustControl->IsContentFinite())
                SetNaviPaneInfoL(iIsVolumeMuted, *iProgressText);
            else
                SetNaviPaneInfoL(iIsVolumeMuted, KNullDesC);
            break;            
        case ESvgtDlgSetVolumeCommand:       // Fall Through
#endif //RD_SVGT_AUDIO_SUPPORT        
//@@ Touch support
        case ESvgtDlgLoopOnCommand:     // Fall Through
        case ESvgtDlgLoopOffCommand:    // Fall Through
        case ESvgtDlgPlayCommand:       // Fall Through
        case ESvgtDlgPauseCommand:      // Fall Through
        case ESvgtDlgStopCommand:       // Fall Through
        case ESvgtDlgZoomInCommand:     // Fall Through
        case ESvgtDlgZoomOutCommand:    // Fall Through
        case ESvgtDlgAngle90:           // Fall Through
        case ESvgtDlgAngle180:          // Fall Through
        case ESvgtDlgAngle270:          // Fall Through
        case ESvgtDlgSelectTextCommand: // Fall Through
        case ESvgtDlgEditTextCommand:   // Fall Through
            break;
        case EAknSoftkeyBack: // Fall Through
        case EEikCmdExit:
            // Close this dialog
            procCmdReqd = EFalse; // No Further Processing required.
            TryExitL( aCommandId );
            break;
        case EAknCmdExit:          
            // Close this dialog
            procCmdReqd = EFalse; // No Further Processing required.
            if ( !SaveNeededL( aCommandId ) )
                {
                TryExitL( aCommandId );  
                iAvkonAppUi->ProcessCommandL( EAknCmdExit );                
                }
            break;
        default:
            procCmdReqd = EFalse;
            break;
        }
    // If custom control has been created and control needs
    // to process the command invoke the control's ProcessViewerCommandL()
    // function
    if ( procCmdReqd && iCustControl )
        {
        iCustControl->ProcessViewerCommandL( aCommandId );
        }
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::CreateCustomControlL
// Reimplements CAknDialog::CreateCustomControlL inorder to add the SVGT
// custom control as part of the dialog in the UI framework.
// Returns: SEikControlInfo which contains the SVGT Cust Control, if
//                          aControlType == ESVGTCustControl
//                     else,
//                           the structure does not contain any control.
// -----------------------------------------------------------------------------
//
SEikControlInfo CSVGTUIDialog::CreateCustomControlL(
        TInt aControlType ) // Control Type
    {
    SEikControlInfo controlInfo;
    controlInfo.iControl = NULL;
    controlInfo.iTrailerTextId = 0;
    controlInfo.iFlags = EEikControlHasEars;//EEikControlIsNonFocusing;

    switch ( aControlType )
        {
        case ESVGTCustControl:
            iCustControl = CSVGTCustControl::NewL(
                            *iFileHandlePtr,
                            iAppObserver,
                            this,
                            this, 
                            this, 
                            ETrue,    // Progressive rendering enabled.
                                      // To enable it pass ETrue 
                                      // otherwise EFalse.
                            NULL,
                            ESvgDisplayIcons|
                            ESvgDrawPanIndicator|
                            ESvgDrawPointer |
                            ESvgDisplayErrorNotes |
                            ESvgDrawPauseIndicator | 
                            ESvgUseBackLight
                            ); 
            iCustControl->AddListener(this,EAudioListener);
            controlInfo.iControl = iCustControl;
            controlInfo.iControl->SetContainerWindowL(*this);                
            iCustControl->SetPointerObserver(this);
            break;
        default:
			return CAknDialog::CreateCustomControlL(aControlType);
        }
    return controlInfo;
    }


// -----------------------------------------------------------------------------
// CSVGTUIDialog::SizeChanged
// Reimplements CAknDialog::SizeChanged inorder to support the resize of the
// dialog when functions such as SetRect, SetExtent are called on the dialog.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::SizeChanged()
    {
    CAknDialog::SizeChanged();
    iCustControl->SetExtent( Rect().iTl, Rect().Size() );
    AknLayoutUtils::LayoutMetricsPosition(AknLayoutUtils::EControlPane, iBtnGrpPos);
    AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EControlPane, iBtnGrpSize);
    DrawNow();
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::OfferKeyEventL
// Handles Key events by reimplementing CCoeControl::OfferKeyEventL.
// Returns:
//      EKeyWasConsumed: If this control uses this key.
//      EKeyWasNotConsumed: Otherwise.
// -----------------------------------------------------------------------------
//
TKeyResponse CSVGTUIDialog::OfferKeyEventL(
    const TKeyEvent& aKeyEvent, // Key Event
    TEventCode aType)           // Event Code
    {
    if ( iCustControl )
        {
        if ( aType == EEventKey )
            {
            if ( aKeyEvent.iScanCode == EStdKeyEnter  )
                {
                TryExitL( iLastCommandID );
                
                return iCustControl->OfferKeyEventL( aKeyEvent, aType );
                }
            
            if ( aKeyEvent.iCode == KSvgScreenToggleKey && 
                 aKeyEvent.iRepeats == 0 ) // Ignore Repeat Events
                {
                // Screen Mode Change Handling
                TBool isFullScreenOn;
                iCustControl->GetCurrentFullScreenStatus( isFullScreenOn );
                if ( isFullScreenOn )
                    {
                    // Toggle to Normal Screen
                    ProcessCommandL( ESvgtDlgNormalScreenCommand );
                    }
                    else
                        {
                        // Toggle to Full Screen
                        ProcessCommandL( ESvgtDlgFullScreenCommand );
                        }
                // No further processing required.
                return EKeyWasConsumed;
                }
            }
        // Pass the key to the custom control
        TKeyResponse lCcRetVal = iCustControl->OfferKeyEventL( aKeyEvent, 
                                                               aType );
        if ( lCcRetVal == EKeyWasConsumed )
            {
            return EKeyWasConsumed;
            }
        }
    return CAknDialog::OfferKeyEventL( aKeyEvent, aType );        
    }

#ifdef __SERIES60_HELP
// -----------------------------------------------------------------------------
// CSVGTUIDialog::OfferKeyEventL
// Handles Key events by reimplementing CCoeControl::OfferKeyEventL.
// Returns:
//      EKeyWasConsumed: If this control uses this key.
//      EKeyWasNotConsumed: Otherwise.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::GetHelpContext( TCoeHelpContext& aContext ) const
    {
    aContext.iMajor = KSvgtHelpContextUid;    
    aContext.iContext = KSVGT_HLP_VIEWER;
    }
#endif // __SERIES60_HELP

// -----------------------------------------------------------------------------
// CSVGTUIDialog::HandleResourceChange
// Handles change of skin/Layout
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::HandleResourceChange( TInt aType )
    {
    CAknDialog::HandleResourceChange( aType );

    
    if ( aType == KAknsMessageSkinChange )
        {
        // No skin related action performed.
        }
        else if ( aType == KEikDynamicLayoutVariantSwitch )
            {
        
            if( iQuietExitWhenOrientationChange )
                {
                   TryExitL( EAknCmdExit );  
                   return;
                }
            
            if ( iCustControl )
                {
                TBool isFullScreenOn;
                // Check whether the custom control is using full-screen or
                // normal screen
                iCustControl->GetCurrentFullScreenStatus( isFullScreenOn );                
                // Change the layout to reflect layout switch
                TRAP_IGNORE( SwitchDialogLayoutL( isFullScreenOn ) );
                }
            
            // If it is a Layout switch, need to do a redraw
            if ( aType == KEikDynamicLayoutVariantSwitch )
                {
                // Redraw the dialog
                DrawDeferred();
                }
            
            }

    }
// -----------------------------------------------------------------------------
// CSVGTUIDialog::DrawProgressBarL
// This function updates the progress bar in the navi pane. It is called back 
// by the custom control.
// -----------------------------------------------------------------------------
//
void CSVGTUIDialog::DrawProgressBarL( TUint aTimeElapsed, // Time Elapsed in 
                                                          // Seconds
    TUint aTimeTotal ) // Total time in seconds
    {
        
    TBuf<KMaxTimeTextLength> timeElapsedBuf; // Time Elapsed, e.g. "00:12"
    TBuf<KMaxTimeTextLength> totalTimeBuf; // Total duration, e.g. "00:55"
    
    // Format the time to user readable format. The format is locale dependent
    FormatTimeL( aTimeElapsed, timeElapsedBuf );  
    FormatTimeL( aTimeTotal, totalTimeBuf );  

    // Format label text based on resource
    CDesCArrayFlat* strings = new (ELeave) CDesCArrayFlat( 2 ); // Allocate 2 
                                                                // strings for
                                                                // elapsed time
                                                                // and total 
                                                                // time strings
    CleanupStack::PushL( strings );
    strings->AppendL( timeElapsedBuf );
    strings->AppendL( totalTimeBuf );

    delete iProgressText;
    iProgressText = NULL;
    iProgressText = StringLoader::LoadL( R_QTN_SVGT_TIME_INDIC, 
                                      *strings, 
                                      iEikonEnv );
    // Destroy the array of strings
    CleanupStack::PopAndDestroy( strings );
    
    SetNaviPaneInfoL( iIsVolumeMuted, *iProgressText);
    }    

void CSVGTUIDialog::HandleApplicationExitL( TInt aExitCommand )
    {
    if((aExitCommand == EAknSoftkeyBack) || ( aExitCommand == EEikCmdExit))
        {
        this->TryExitL(aExitCommand);
        }
    else
        {
        User::LeaveIfError(KErrArgument);
        }
    }

EXPORT_C void CSVGTUIDialog::AssignImageData( const TDesC& aUri, HBufC8* aData )
    {
    iCustControl->AssignImageData(aUri, aData);
    }

// -----------------------------------------------------------------------------
// CSVGTUIDialog::SetNaviPaneInfoL
// Sets the mute icon & text to the navi pane.
// -----------------------------------------------------------------------------
void CSVGTUIDialog::SetNaviPaneInfoL(TBool aIsVolumeMuted, const TDesC& aText)
    {
    CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();
    CAknNavigationControlContainer* np = 
            static_cast<CAknNavigationControlContainer*>
            ( sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );
    // Save the old Navi Decorator so that it can be deleted after 
    // creating the new navi decorator 
    CAknNavigationDecorator* lOldNaviDecorator = iNaviDecorator;
            
    iNaviDecorator = NULL;

    CSvgtDecoratorControl* decoControl = new (ELeave) CSvgtDecoratorControl;
    CleanupStack::PushL(decoControl);
    decoControl->ConstructL();
    decoControl->ShowVolumeMutedIcon(aIsVolumeMuted);
    decoControl->SetTextL(aText);
    iNaviDecorator = CAknNavigationDecorator::NewL(np, decoControl);
    iNaviDecorator->SetContainerWindowL(*this);
    CleanupStack::Pop(decoControl);
        
    // Clear the old Navi-Pane Decorator
    if ( lOldNaviDecorator )
        {
        delete lOldNaviDecorator ;
        lOldNaviDecorator = NULL;
        }
    // Push the new Navi decorator in the Navigation Pane
    np->PushL( *iNaviDecorator );
    }    
    
void CSVGTUIDialog::VolumeMuted(TBool aVolumeMuted)
    {
    if(iCustControl->IsContentFinite())
        {
        TRAP_IGNORE( SetNaviPaneInfoL(aVolumeMuted, *iProgressText));
        }
    else
        {
        TRAP_IGNORE(SetNaviPaneInfoL(aVolumeMuted, KNullDesC));
        }
    iIsVolumeMuted = aVolumeMuted;
    }
// End of File