1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 #include <eikenv.h>

    18 #include <apgtask.h>

    19 #include <hbdeviceprogressdialog.h>

    20 #include "enginewrapper.h"

    21 

    22 #include "settingsview.h"

    23 #include "sgengine.h"

    24 #include "mainview.h"

    25 #include "notifications.h"

    26 

    27 

    28 // ---------------------------------------------------------------------------

    29 

    30 EngineWrapper::EngineWrapper()

    31 : iSGEngine(0), iProgressNote(0)

    32 {

    33 }

    34 

    35 // ---------------------------------------------------------------------------

    36 

    37 EngineWrapper::~EngineWrapper()

    38 {

    39     if (iSGEngine) {

    40         iSGEngine->DeActivateModelL();

    41         delete iSGEngine;

    42     }

    43     if(iProgressNote){

    44         delete iProgressNote;

    45     }

    46 }

    47 

    48 // ---------------------------------------------------------------------------

    49 

    50 bool EngineWrapper::init()

    51 {

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

    53 	

    54     

    55     if (error == KErrNone) {

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

    57     }

    58     

    59     if (error != KErrNone) {

    60         return false;

    61     }

    62     else {

    63         return true;

    64     }

    65 	

    66 }

    67 

    68 // ---------------------------------------------------------------------------

    69 

    70 GrabSettings EngineWrapper::getGrabSettings()

    71 {

    72     TGrabSettings tSettings = iSGEngine->GrabSettings();

    73     GrabSettings settings;

    74     

    75     // Convert TGrabSettings to GrabSettings

    76     settings.mCaptureMode = tSettings.iCaptureMode;

    77     

    78     // Single image settings

    79     settings.mSingleCaptureHotkey = tSettings.iSingleCaptureHotkey;

    80     settings.mSingleCaptureImageFormat = tSettings.iSingleCaptureImageFormat;

    81 	settings.mSingleCaptureMemoryInUseMultiDrive = tSettings.iSingleCaptureMemoryInUseMultiDrive;

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

    83     

    84     //Seguantial image settings

    85     settings.mSequantialCaptureDelay = tSettings.iSequantialCaptureDelay;

    86     settings.mSequantialCaptureHotkey = tSettings.iSequantialCaptureHotkey;

    87     settings.mSequantialCaptureImageFormat = tSettings.iSequantialCaptureImageFormat;

    88 	settings.mSequantialCaptureMemoryInUseMultiDrive = tSettings.iSequantialCaptureMemoryInUseMultiDrive;

    89     settings.mSequantialCaptureDelay = tSettings.iSequantialCaptureDelay;

    90     //convert TFilename to QString

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

    92     

    93     

    94     // Video settings

    95     settings.mVideoCaptureHotkey = tSettings.iVideoCaptureHotkey;

    96     settings.mVideoCaptureVideoFormat = tSettings.iVideoCaptureVideoFormat;

    97 	settings.mVideoCaptureMemoryInUseMultiDrive = tSettings.iVideoCaptureMemoryInUseMultiDrive;

    98     //convert TFilename to QString

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

   100     

   101     return settings;

   102 }

   103 

   104 // ---------------------------------------------------------------------------

   105 

   106 bool EngineWrapper::saveSettings(const GrabSettings& settings)

   107 {

   108     TGrabSettings tSettings;

   109     // Convert GrabSettings to TGrabSettings

   110     tSettings.iCaptureMode = settings.mCaptureMode;

   111     

   112     tSettings.iSingleCaptureHotkey = settings.mSingleCaptureHotkey;

   113     tSettings.iSingleCaptureImageFormat = settings.mSingleCaptureImageFormat;

   114     tSettings.iSingleCaptureMemoryInUseMultiDrive = settings.mSingleCaptureMemoryInUseMultiDrive;

   115     //convert TFilename to QString

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

   117     tSettings.iSequantialCaptureDelay = settings.mSequantialCaptureDelay;

   118     tSettings.iSequantialCaptureHotkey = settings.mSequantialCaptureHotkey;

   119     tSettings.iSequantialCaptureImageFormat = settings.mSequantialCaptureImageFormat;

   120     tSettings.iSequantialCaptureMemoryInUseMultiDrive = settings.mSequantialCaptureMemoryInUseMultiDrive; 

   121     tSettings.iSequantialCaptureDelay = settings.mSequantialCaptureDelay;

   122     //convert TFilename to QString

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

   124     

   125     tSettings.iVideoCaptureHotkey = settings.mVideoCaptureHotkey;

   126     tSettings.iVideoCaptureVideoFormat = settings.mVideoCaptureVideoFormat;

   127     tSettings.iVideoCaptureMemoryInUseMultiDrive = settings.mVideoCaptureMemoryInUseMultiDrive; 

   128     //convert TFilename to QString

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

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

   131     

   132     if (error == KErrNone) {

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

   134     }

   135     

   136     if (error == KErrNone) {

   137         return true;

   138     }

   139     else {

   140         return false;

   141     }

   142     

   143     

   144 }

   145 

   146 // ---------------------------------------------------------------------------

   147 

   148 

   149 void EngineWrapper::ShowImageCapturedNote()

   150 {

   151     Notifications::imageCaptured();

   152 }

   153 

   154 // ---------------------------------------------------------------------------

   155 

   156 void EngineWrapper::ShowErrorMessage(const TDesC16& aErrorMessage)

   157 {

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

   159     Notifications::error(errorMessage);

   160  

   161 }

   162 

   163 // ---------------------------------------------------------------------------

   164 

   165 void EngineWrapper::sendUIToBackground()

   166 {

   167     CCoeEnv* coeEnv = CCoeEnv::Static();

   168     TApaTask selfTask(coeEnv->WsSession());

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

   170     selfTask.SendToBackground();

   171 }

   172 

   173 // ---------------------------------------------------------------------------

   174 

   175 

   176 #if defined(HB_QT_S60_EVENT_FILTER)

   177 bool EngineWrapper::handleCaptureCommands(const TWsEvent* aEvent)

   178 #else

   179 bool EngineWrapper::handleCaptureCommands(const QSymbianEvent *aEvent)

   180 #endif

   181 {

   182     TBool retVal = ETrue;

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

   184     if (errorCode != KErrNone) {

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

   186     }

   187     

   188     return convertTBoolToBool(retVal);

   189     

   190 }

   191 

   192 // ---------------------------------------------------------------------------

   193 

   194 bool EngineWrapper::convertTBoolToBool(TBool value)

   195 {

   196     if (value) {

   197         return true;

   198     }

   199     else {

   200         return false;

   201     }

   202 }

   203 

   204 // ---------------------------------------------------------------------------

   205 

   206 void EngineWrapper::ShowSequantialImagesCapturedNote(TInt amount)

   207 {

   208     Notifications::sequantialImagesCaptured(amount);

   209 }

   210 

   211 // ---------------------------------------------------------------------------

   212 

   213 void EngineWrapper::ShowVideoCapturedNote()

   214 {

   215     Notifications::videoCaptured();

   216 }

   217 

   218 // ---------------------------------------------------------------------------

   219 

   220 void EngineWrapper::ShowProgressBar(int max)

   221 {

   222     iProgressNote = Notifications::showProgressBar(max);

   223 }

   224 

   225 // ---------------------------------------------------------------------------

   226 

   227 void EngineWrapper::IncrementProgressbarValue()

   228 {

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

   230 }

   231 

   232 // ---------------------------------------------------------------------------

   233 

   234 void EngineWrapper::CloseProgressbar()

   235 {

   236     delete iProgressNote;

   237     iProgressNote = 0;

   238 }

   239 

   240 void EngineWrapper::EnableRcpOfFoc(TBool aState)

   241 {

   242     iSGEngine->EnableRcpOfFoc(aState);

   243 }

   244 

   245 void EngineWrapper::LoadSettings(void)

   246 {

   247 	iSGEngine->LoadSettingsL();

   248 }

   249 

   250 // ---------------------------------------------------------------------------