/*

* Copyright (c) 2009 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:  

*

*/

#include "SGModel.h"

#include "SGApp.h"

#include "SG.hrh"

#include "SGGifAnimator.h"

#include <w32std.h>

#include <e32keys.h>

#include <imageconversion.h>

#include <pathinfo.h>

#include <AknGlobalConfirmationQuery.h>

#include <aknnotewrappers.h>

#include <textresolver.h>

#include <bautils.h>

#include <coeutils.h>

#include <s32file.h>

#include <AknGlobalNote.h>

_LIT(KSingleShotSaved, "Screen shot saved to Media Gallery");

_LIT(KMultipleShotsSaved, "%u screen shots saved to Media Gallery");

_LIT(KVideoSaved, "Video saved to Media Gallery");

_LIT(KErrorOccured, "Grabber error: ");

_LIT(KDefaultImageFileName, "Shot");

_LIT(KDefaultVideoFileName, "Video");

_LIT(KScreenShotsSubDirectory, "Screen Shots\\");

_LIT(KSGTemporaryDirectory, "\\system\\temp\\screengrabber\\");

#define HIGH_QUALITY_JPEG 97

#define LOW_QUALITY_JPEG 60

#define DEFAULT_SEQ_CAPTURE_DELAY_MS 5000   // 5.000 secs

#define VIDEO_CAPTURE_DELAY 250             // 0.25 secs

#define VIDEO_CAPTURE_MINIMUM_DELAY 200     // 0.20 secs

#define KEY_CAPTURE_PRIORITY 100            // do not change, this is for window server

const TInt KSettingsDrive = EDriveC;

_LIT(KSettingsFileName, "screengrabber_settings.ini");

// ---------------------------------------------------------------------------

CScreenGrabberModel* CScreenGrabberModel::NewL()

	{

	CScreenGrabberModel* self = new(ELeave) CScreenGrabberModel;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

// ---------------------------------------------------------------------------

CScreenGrabberModel::CScreenGrabberModel() : CActive(EPriorityStandard)

	{

	}

// ---------------------------------------------------------------------------

void CScreenGrabberModel::ConstructL()

	{

    User::LeaveIfError(iTimer.CreateLocal());

    // init audio utility

  	iMdaAudioToneUtility = CMdaAudioToneUtility::NewL(*this);

    iSavedQuery = CSavedQuery::NewL();

    iVideoFrameArray = new(ELeave) CVideoFrameArray(10000);

	iPreviouslyCapturedBitmap = new(ELeave) CFbsBitmap;

    iEnv = CEikonEnv::Static();

  	iRootWin = iEnv->RootWin();

  	iCapturingInProgress = EFalse;

  	iStopCapturing = EFalse;

  	iNumberOfTakenShots = 0;

  	iCurrentFrameNumber = 0;

  	iHashKeyCapturingActivated = EFalse;

  	iHashKeyDown = EFalse;

  	iGalleryUpdaterSupported = ETrue;

  	iGalleryUpdaterInitialized = EFalse;

	CActiveScheduler::Add(this);

	}

// ---------------------------------------------------------------------------

void CScreenGrabberModel::ActivateModelL()

	{

    // clean temporary files

    TRAP_IGNORE( CleanTemporaryFilesL() );

    // load settings

    TRAP_IGNORE( LoadSettingsL() );

    // start capturing

    ActivateCaptureKeysL();

	}

// ---------------------------------------------------------------------------

void CScreenGrabberModel::DeActivateModelL()

	{

    CancelCapturing();

    // for a faster exit, send the application to background

    TApaTask selfTask(iEnv->WsSession());

    selfTask.SetWgId(iEnv->RootWin().Identifier());

    selfTask.SendToBackground();

	}

// ---------------------------------------------------------------------------

CScreenGrabberModel::~CScreenGrabberModel()

	{

	Cancel();

    // deactivate Media Gallery DLL

    if (iGalleryUpdaterInitialized)

        {

        if (iMGXFileManager)

            delete iMGXFileManager;

        iGalleryUpdaterDLL.Close();

        }

	TRAP_IGNORE( CleanTemporaryFilesL() );

    iTimer.Close();

    if (iFrameImageData)

        delete iFrameImageData;

    if (iPreviouslyCapturedBitmap)

        delete iPreviouslyCapturedBitmap;

    if (iImageEncoder)

        delete iImageEncoder;

    delete iVideoFrameArray;

    delete iSavedQuery;

    delete iMdaAudioToneUtility;

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::LoadDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, TInt& aValue)

    {

    if (aDicFS->IsPresentL(aUid))

        {

        RDictionaryReadStream in;

        in.OpenLC(*aDicFS, aUid);

        aValue = in.ReadInt16L();

        CleanupStack::PopAndDestroy(); // in        

        }

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::LoadDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, TDes& aValue)

    {

    if (aDicFS->IsPresentL(aUid))

        {

        RDictionaryReadStream in;

        in.OpenLC(*aDicFS, aUid);

        TInt bufLength = in.ReadInt16L();   // get length of descriptor

        in.ReadL(aValue, bufLength);        // get the descriptor itself

        CleanupStack::PopAndDestroy(); // in

        }

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::SaveDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, const TInt& aValue)

    {

    RDictionaryWriteStream out;

    out.AssignLC(*aDicFS, aUid);

    out.WriteInt16L(aValue);

    out.CommitL(); 	

    CleanupStack::PopAndDestroy(1);// out

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::SaveDFSValueL(CDictionaryFileStore* aDicFS, const TUid& aUid, const TDes& aValue)

    {

    RDictionaryWriteStream out;

    out.AssignLC(*aDicFS, aUid);

    out.WriteInt16L(aValue.Length());       // write length of the descriptor

    out.WriteL(aValue, aValue.Length());    // write the descriptor itself

    out.CommitL(); 	

    CleanupStack::PopAndDestroy(1);// out

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::LoadSettingsL()

    {

    // set defaults

    iGrabSettings.iCaptureMode = ECaptureModeSingleCapture;

    iGrabSettings.iSingleCaptureHotkey = EHotkeySendKey;

    iGrabSettings.iSingleCaptureImageFormat = EImageFormatPNG;

    iGrabSettings.iSingleCaptureMemoryInUse = CAknMemorySelectionSettingPage::EPhoneMemory; 

    iGrabSettings.iSingleCaptureMemoryInUseMultiDrive = EDriveC;

    iGrabSettings.iSingleCaptureFileName.Copy( KDefaultImageFileName );

    iGrabSettings.iSequantialCaptureHotkey = EHotkeySendKey;

    iGrabSettings.iSequantialCaptureImageFormat = EImageFormatPNG;

    iGrabSettings.iSequantialCaptureDelay = DEFAULT_SEQ_CAPTURE_DELAY_MS;

    iGrabSettings.iSequantialCaptureMemoryInUse = CAknMemorySelectionSettingPage::EPhoneMemory; 

    iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive = EDriveC;

    iGrabSettings.iSequantialCaptureFileName.Copy( KDefaultImageFileName );

    iGrabSettings.iVideoCaptureHotkey = EHotkeySendKey;

    iGrabSettings.iVideoCaptureVideoFormat = EVideoFormatAnimatedGIF;

    iGrabSettings.iVideoCaptureMemoryInUse = CAknMemorySelectionSettingPage::EPhoneMemory; 

    iGrabSettings.iVideoCaptureMemoryInUseMultiDrive = EDriveC;

    iGrabSettings.iVideoCaptureFileName.Copy( KDefaultVideoFileName );

    // make sure that the private path of this app in c-drive exists

    iEnv->FsSession().CreatePrivatePath( KSettingsDrive ); // c:\\private\\101fb751\\

    // handle settings always in the private directory 

    if (iEnv->FsSession().SetSessionToPrivate( KSettingsDrive ) == KErrNone)

        {

        // open or create a dictionary file store

        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(iEnv->FsSession(), KSettingsFileName, KUidScreenGrabber);

        LoadDFSValueL(settingsStore, KSGSettingCaptureMode,                             iGrabSettings.iCaptureMode);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureHotkey,                     iGrabSettings.iSingleCaptureHotkey);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureImageFormat,                iGrabSettings.iSingleCaptureImageFormat);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureMemoryInUse,                (TInt&)iGrabSettings.iSingleCaptureMemoryInUse);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureMemoryInUseMultiDrive,      (TInt&)iGrabSettings.iSingleCaptureMemoryInUseMultiDrive);

        LoadDFSValueL(settingsStore, KSGSettingSingleCaptureFileName,                   iGrabSettings.iSingleCaptureFileName);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureHotkey,                 iGrabSettings.iSequantialCaptureHotkey);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureImageFormat,            iGrabSettings.iSequantialCaptureImageFormat);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureDelay,                  iGrabSettings.iSequantialCaptureDelay);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureMemoryInUse,            (TInt&)iGrabSettings.iSequantialCaptureMemoryInUse);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureMemoryInUseMultiDrive,  (TInt&)iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive);

        LoadDFSValueL(settingsStore, KSGSettingSequantialCaptureFileName,               iGrabSettings.iSequantialCaptureFileName);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureHotkey,                      iGrabSettings.iVideoCaptureHotkey);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureVideoFormat,                 iGrabSettings.iVideoCaptureVideoFormat);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureMemoryInUse,                 (TInt&)iGrabSettings.iVideoCaptureMemoryInUse);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureMemoryInUseMultiDrive,       (TInt&)iGrabSettings.iVideoCaptureMemoryInUseMultiDrive);

        LoadDFSValueL(settingsStore, KSGSettingVideoCaptureFileName,                    iGrabSettings.iVideoCaptureFileName);

        CleanupStack::PopAndDestroy(); // settingsStore         

        }

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::SaveSettingsL(TGrabSettings aGrabSettings)

    {

    // set the new settings

    iGrabSettings = aGrabSettings;

    // handle settings always in c:\\private\\101fb751\\

    if (iEnv->FsSession().SetSessionToPrivate( KSettingsDrive ) == KErrNone)

        {

        // delete existing store to make sure that it is clean and not eg corrupted

        if (BaflUtils::FileExists(iEnv->FsSession(), KSettingsFileName))

            {

            iEnv->FsSession().Delete(KSettingsFileName);

            }

        // create a dictionary file store

        CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(iEnv->FsSession(), KSettingsFileName, KUidScreenGrabber);

        SaveDFSValueL(settingsStore, KSGSettingCaptureMode,                             iGrabSettings.iCaptureMode);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureHotkey,                     iGrabSettings.iSingleCaptureHotkey);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureImageFormat,                iGrabSettings.iSingleCaptureImageFormat);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureMemoryInUse,                (TInt&)iGrabSettings.iSingleCaptureMemoryInUse);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureMemoryInUseMultiDrive,      (TInt&)iGrabSettings.iSingleCaptureMemoryInUseMultiDrive);

        SaveDFSValueL(settingsStore, KSGSettingSingleCaptureFileName,                   iGrabSettings.iSingleCaptureFileName);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureHotkey,                 iGrabSettings.iSequantialCaptureHotkey);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureImageFormat,            iGrabSettings.iSequantialCaptureImageFormat);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureDelay,                  iGrabSettings.iSequantialCaptureDelay);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureMemoryInUse,            (TInt&)iGrabSettings.iSequantialCaptureMemoryInUse);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureMemoryInUseMultiDrive,  (TInt&)iGrabSettings.iSequantialCaptureMemoryInUseMultiDrive);

        SaveDFSValueL(settingsStore, KSGSettingSequantialCaptureFileName,               iGrabSettings.iSequantialCaptureFileName);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureHotkey,                      iGrabSettings.iVideoCaptureHotkey);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureVideoFormat,                 iGrabSettings.iVideoCaptureVideoFormat);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureMemoryInUse,                 (TInt&)iGrabSettings.iVideoCaptureMemoryInUse);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureMemoryInUseMultiDrive,       (TInt&)iGrabSettings.iVideoCaptureMemoryInUseMultiDrive);

        SaveDFSValueL(settingsStore, KSGSettingVideoCaptureFileName,                    iGrabSettings.iVideoCaptureFileName);

        settingsStore->CommitL();

        CleanupStack::PopAndDestroy(); // settingsStore             

        }

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::DoCancel()

	{

    iTimer.Cancel();

	}

// ---------------------------------------------------------------------------

void CScreenGrabberModel::ActivateCaptureKeysL(TBool aChangeKey)

    {

    // if changing the capture key, capturing needs to be cancelled first

    if (aChangeKey)

        {

        CancelCapturing();

        }

    // get hotkey of the capture

    TInt captureHotkey(0);

    if (iGrabSettings.iCaptureMode == ECaptureModeSingleCapture)

        captureHotkey = iGrabSettings.iSingleCaptureHotkey;

    else if (iGrabSettings.iCaptureMode == ECaptureModeSequantialCapture)

        captureHotkey = iGrabSettings.iSequantialCaptureHotkey;

    else if (iGrabSettings.iCaptureMode == ECaptureModeVideoCapture)

        captureHotkey = iGrabSettings.iVideoCaptureHotkey;

    else

        User::Panic(_L("Wrong mode"), 40);

    // capture hash key if needed

    if (captureHotkey == EHotkeyHashStar)

        {

        iCapturedKeyHash    = iRootWin.CaptureKey(EStdKeyHash, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

        iCapturedKeyHashUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyHash, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

        iHashKeyCapturingActivated = ETrue;

        }

    // start capturing based on user selected key

    switch (captureHotkey)

        {

        case EHotkeyShiftStar:

            {

            iCapturedKey    = iRootWin.CaptureKey('*', EModifierCtrl|EModifierShift|EModifierFunc, EModifierShift, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns('*', EModifierCtrl|EModifierShift|EModifierFunc, EModifierShift, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeyHashStar:

            {

            iCapturedKey    = iRootWin.CaptureKey('*', EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns('*', EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeyShiftMenu:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyApplication0, EModifierCtrl|EModifierShift|EModifierFunc, EModifierShift, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyApplication0, EModifierCtrl|EModifierShift|EModifierFunc, EModifierShift, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeySendKey:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyYes, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyYes, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeyPowerKey:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyDevice2, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyDevice2, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;

            }

        case EHotkeySideKey:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyDevice6, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyDevice6, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;            

            }

        case EHotkeyCameraKey1:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyDevice7, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyDevice7, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;            

            }

        case EHotkeyCameraKey2:

            {

            iCapturedKey    = iRootWin.CaptureKey(EStdKeyApplication1A, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyApplication1A, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            break;            

            }

       	case EHotkeyPOC:

        	{

        	iCapturedKey    = iRootWin.CaptureKey(EStdKeyApplication1, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

            iCapturedKeyUnD = iRootWin.CaptureKeyUpAndDowns(EStdKeyApplication1, EModifierCtrl|EModifierShift|EModifierFunc, 0, KEY_CAPTURE_PRIORITY);

           	break;

        	}  

        default:

            {

            User::Panic(_L("Key not supported"), 100);

            break;

            }

        }

    }

// ---------------------------------------------------------------------------

void CScreenGrabberModel::CancelCapturing()

    {

	// cancel all captures

    iRootWin.CancelCaptureKey(iCapturedKey);

    iRootWin.CancelCaptureKeyUpAndDowns(iCapturedKeyUnD);

    if (iHashKeyCapturingActivated)

        {

        iRootWin.CancelCaptureKey(iCapturedKeyHash);

        iRootWin.CancelCaptureKeyUpAndDowns(iCapturedKeyHashUnD);

        iHashKeyCapturingActivated = EFalse;

        }

    }

// ---------------------------------------------------------------------------

TBool CScreenGrabberModel::HandleCaptureCommandsL(const TWsEvent& aEvent)

    {

    TBool continueEventLoop(ETrue);

    // get hotkey of the capture

    TInt captureHotkey(0);

    if (iGrabSettings.iCaptureMode == ECaptureModeSingleCapture)

        captureHotkey = iGrabSettings.iSingleCaptureHotkey;

    else if (iGrabSettings.iCaptureMode == ECaptureModeSequantialCapture)

        captureHotkey = iGrabSettings.iSequantialCaptureHotkey;

    else if (iGrabSettings.iCaptureMode == ECaptureModeVideoCapture)

        captureHotkey = iGrabSettings.iVideoCaptureHotkey;

    else

        User::Panic(_L("Wrong mode"), 41);

    // ignore any errors

    if (aEvent.Type()==EEventErrorMessage)

	    {

	    // error

	    }

	// check if hash key has been pushed down

	else if (iHashKeyCapturingActivated && aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyHash)

	    {

        iHashKeyDown = ETrue;	    

	    }

	// check if hash key has been released

	else if (iHashKeyCapturingActivated && aEvent.Type()==EEventKeyUp && aEvent.Key()->iScanCode==EStdKeyHash)

	    {

        iHashKeyDown = EFalse;	    

	    }

    // handle captured keys, we are interested here only of the keydown events

    else if (

              ( captureHotkey == EHotkeyShiftStar &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode=='*' &&

                aEvent.Key()->iModifiers & EModifierShift)

            ||

              ( captureHotkey == EHotkeyHashStar &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode=='*' &&

                iHashKeyDown)

            ||

              ( captureHotkey == EHotkeyShiftMenu &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyApplication0 &&

                aEvent.Key()->iModifiers & EModifierShift)

            ||

              ( captureHotkey == EHotkeySendKey &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyYes )

            ||

              ( captureHotkey == EHotkeyPowerKey &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyDevice2 )

            ||

              ( captureHotkey == EHotkeySideKey &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyDevice6 )

            ||

              ( captureHotkey == EHotkeyCameraKey1 &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyDevice7 )

            ||

              ( captureHotkey == EHotkeyCameraKey2 &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyDevice7 )

            ||

              ( captureHotkey == EHotkeyPOC &&

                aEvent.Type()==EEventKeyDown && aEvent.Key()->iScanCode==EStdKeyApplication1A )

            )

		{

		// check if already capturing images in sequence

		if ( iCapturingInProgress && !iStopCapturing && iNumberOfTakenShots!=0 && iGrabSettings.iCaptureMode == ECaptureModeSequantialCapture )

            {

            // asking to stop capturing

            iStopCapturing = ETrue;

            // cancel the active object, this will cancel any timer delays and ICL stuff

            Cancel();

            // set status

            iState = ECancelCapturing; 

            // jump smoothly to RunL()

            iTimer.After(iStatus, 50);

            SetActive(); 

       		// do not continue the event loop in HandleWsEventL for these events

           	continueEventLoop = EFalse;

            }

		// check if already capturing video