/*

* Copyright (c) 2010 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 <eikenv.h>

#include <APGTASK.H>

#include <hbdeviceprogressdialog.h>

#include "enginewrapper.h"

#include "settingsview.h"

#include "sgengine.h"

#include "mainview.h"

#include "notifications.h"

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

EngineWrapper::EngineWrapper()

: iSGEngine(0), iProgressNote(0)

{

}

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

EngineWrapper::~EngineWrapper()

{

    if (iSGEngine) {

        iSGEngine->DeActivateModelL();

        delete iSGEngine;

    }

    if(iProgressNote){

        delete iProgressNote;

    }

}

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

bool EngineWrapper::init()

{

    TRAPD(error, iSGEngine = SGEngine::NewL(this));

    if (error == KErrNone) {

        TRAP(error, iSGEngine->ActivateModelL());

    }

    if (error != KErrNone) {

        return false;

    }

    else {

        return true;

    }

}

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

GrabSettings EngineWrapper::getGrabSettings()

{

    TGrabSettings tSettings = iSGEngine->GrabSettings();

    GrabSettings settings;

    // Convert TGrabSettings to GrabSettings

    settings.mCaptureMode = tSettings.iCaptureMode;

    // Single image settings

    settings.mSingleCaptureHotkey = tSettings.iSingleCaptureHotkey;

    settings.mSingleCaptureImageFormat = tSettings.iSingleCaptureImageFormat;

	settings.mSingleCaptureMemoryInUseMultiDrive = tSettings.iSingleCaptureMemoryInUseMultiDrive;

    settings.mSingleCaptureFileName = QString((QChar*)tSettings.iSingleCaptureFileName.Ptr(),tSettings.iSingleCaptureFileName.Length());

    //Seguantial image settings

    settings.mSequantialCaptureDelay = tSettings.iSequantialCaptureDelay;

    settings.mSequantialCaptureHotkey = tSettings.iSequantialCaptureHotkey;

    settings.mSequantialCaptureImageFormat = tSettings.iSequantialCaptureImageFormat;

	settings.mSequantialCaptureMemoryInUseMultiDrive = tSettings.iSequantialCaptureMemoryInUseMultiDrive;

    settings.mSequantialCaptureDelay = tSettings.iSequantialCaptureDelay;

    //convert TFilename to QString

    settings.mSequantialCaptureFileName = QString((QChar*)tSettings.iSequantialCaptureFileName.Ptr(),tSettings.iSequantialCaptureFileName.Length());

    // Video settings

    settings.mVideoCaptureHotkey = tSettings.iVideoCaptureHotkey;

    settings.mVideoCaptureVideoFormat = tSettings.iVideoCaptureVideoFormat;

	settings.mVideoCaptureMemoryInUseMultiDrive = tSettings.iVideoCaptureMemoryInUseMultiDrive;

    //convert TFilename to QString

    settings.mVideoCaptureFileName = QString((QChar*)tSettings.iVideoCaptureFileName.Ptr(),tSettings.iVideoCaptureFileName.Length());

    return settings;

}

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

bool EngineWrapper::saveSettings(const GrabSettings& settings)

{

    TGrabSettings tSettings;

    // Convert GrabSettings to TGrabSettings

    tSettings.iCaptureMode = settings.mCaptureMode;

    tSettings.iSingleCaptureHotkey = settings.mSingleCaptureHotkey;

    tSettings.iSingleCaptureImageFormat = settings.mSingleCaptureImageFormat;

    tSettings.iSingleCaptureMemoryInUseMultiDrive = settings.mSingleCaptureMemoryInUseMultiDrive;

    //convert TFilename to QString

    tSettings.iSingleCaptureFileName = TFileName(settings.mSingleCaptureFileName.utf16());

    tSettings.iSequantialCaptureDelay = settings.mSequantialCaptureDelay;

    tSettings.iSequantialCaptureHotkey = settings.mSequantialCaptureHotkey;

    tSettings.iSequantialCaptureImageFormat = settings.mSequantialCaptureImageFormat;

    tSettings.iSequantialCaptureMemoryInUseMultiDrive = settings.mSequantialCaptureMemoryInUseMultiDrive; 

    tSettings.iSequantialCaptureDelay = settings.mSequantialCaptureDelay;

    //convert TFilename to QString

    tSettings.iSequantialCaptureFileName = TFileName(settings.mSequantialCaptureFileName.utf16());

    tSettings.iVideoCaptureHotkey = settings.mVideoCaptureHotkey;

    tSettings.iVideoCaptureVideoFormat = settings.mVideoCaptureVideoFormat;

    tSettings.iVideoCaptureMemoryInUseMultiDrive = settings.mVideoCaptureMemoryInUseMultiDrive; 

    //convert TFilename to QString

    tSettings.iVideoCaptureFileName = TFileName(settings.mVideoCaptureFileName.utf16());

    TRAPD(error, iSGEngine->SaveSettingsL(tSettings));

    if (error == KErrNone) {

        TRAP(error, iSGEngine->ActivateCaptureKeysL(true));

    }

    if (error == KErrNone) {

        return true;

    }

    else {

        return false;

    }

}

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

void EngineWrapper::ShowImageCapturedNote()

{

    Notifications::imageCaptured();

}

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

void EngineWrapper::ShowErrorMessage(const TDesC16& aErrorMessage)

{

    QString errorMessage((QChar*)aErrorMessage.Ptr(),aErrorMessage.Length());

    Notifications::error(errorMessage);

}

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

void EngineWrapper::sendUIToBackground()

{

    CCoeEnv* coeEnv = CCoeEnv::Static();

    TApaTask selfTask(coeEnv->WsSession());

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

    selfTask.SendToBackground();

}

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

#if defined(HB_QT_S60_EVENT_FILTER)

bool EngineWrapper::handleCaptureCommands(const TWsEvent* aEvent)

#else

bool EngineWrapper::handleCaptureCommands(const QSymbianEvent *aEvent)

#endif

{

    TBool retVal = ETrue;

    TRAPD(errorCode, retVal = iSGEngine->HandleCaptureCommandsL(aEvent));

    if (errorCode != KErrNone) {

        Notifications::error("Error occured when capturing screen.");

    }

    return convertTBoolToBool(retVal);

}

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

bool EngineWrapper::convertTBoolToBool(TBool value)

{

    if (value) {

        return true;

    }

    else {

        return false;

    }

}

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

void EngineWrapper::ShowSequantialImagesCapturedNote(TInt amount)

{

    Notifications::sequantialImagesCaptured(amount);

}

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

void EngineWrapper::ShowVideoCapturedNote()

{

    Notifications::videoCaptured();

}

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

void EngineWrapper::ShowProgressBar(int max)

{

    iProgressNote = Notifications::showProgressBar(max);

}

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

void EngineWrapper::IncrementProgressbarValue()

{

    iProgressNote->setProgressValue(iProgressNote->progressValue() + 1);

}

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

void EngineWrapper::CloseProgressbar()

{

    delete iProgressNote;

    iProgressNote = 0;

}

void EngineWrapper::EnableRcpOfFoc(TBool aState)

{

    iSGEngine->EnableRcpOfFoc(aState);

}

void EngineWrapper::LoadSettings(void)

{

	iSGEngine->LoadSettingsL();

}

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