/*

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

#include <QTimer>

#include <hbmainwindow.h>

#include <coemain.h>

#include <QGraphicsSceneEvent>

#include "cxuiviewmanager.h"

#include "cxuivideoprecaptureview.h"

#include "cxuistillprecaptureview.h"

#include "cxuipostcaptureview.h"

#include "cxuicapturekeyhandler.h"

#include "cxeengine.h"

#include "cxecameradevicecontrol.h"

#include "cxefeaturemanager.h" //  mEngine->featureManager()

#include "cxeviewfindercontrol.h"

#include "cxenamespace.h"

#include "cxuienums.h"

#include "cxutils.h"

#include "cxuidocumentloader.h"

#include "cxuistandby.h"

#include "cxuierrormanager.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuiviewmanagerTraces.h"

#endif

using namespace Cxe;

using namespace CxUiLayout;

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

// CxuiViewManager::CxuiViewManager

//

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

//

    mMainWindow(mainWindow),

    mStillPrecaptureView(NULL),

    mVideoPrecaptureView(NULL),

    mPostcaptureView(NULL),

    mEngine(engine),

{

    CX_DEBUG_ENTER_FUNCTION();

    mMainWindow.installEventFilter(this); // in order to filter capture and AF keys

    OstTrace0( camerax_performance, CXUIVIEWMANAGER_CXUIVIEWMANAGER, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 1" );

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CXUIVIEWMANAGER, "msg: e_CX_VIEWMANAGER_CREATE_DOCLOADER 0" );

    // standby functionality and necessary signal connections

    connect(mStandbyHandler, SIGNAL(aboutToEnterStandby()),this, SLOT(aboutToLooseFocus()));

    connect(mStandbyHandler, SIGNAL(aboutToExitStandby()),this, SLOT(aboutToGainFocus()));

    // error manager, handling errors and notifying users based on their severity

    // connecting necessary signals from error manager to release and init camera.

    connect(mErrorManager, SIGNAL(aboutToRecoverError()), this, SLOT(aboutToLooseFocus()));

    connect(mErrorManager, SIGNAL(errorRecovered()), this, SLOT(aboutToGainFocus()));

    //connecting initmode signals

    connect(&mEngine.cameraDeviceControl(), SIGNAL(initModeComplete(CxeError::Id)),

            this, SLOT(createPostcaptureView()));

    connect(&mEngine.cameraDeviceControl(), SIGNAL(initModeComplete(CxeError::Id)),

            mErrorManager, SLOT(analyze(CxeError::Id)));

    if (CxuiServiceProvider::isCameraEmbedded()) {

        // connect signals to set up the view after image/video prepare

        connect(&mEngine.stillCaptureControl(), SIGNAL(imagePrepareComplete(CxeError::Id)),

                this, SLOT(changeToPrecaptureView()));

        connect(&mEngine.videoCaptureControl(), SIGNAL(videoPrepareComplete(CxeError::Id)),

                this, SLOT(changeToPrecaptureView()));

        // start standby timer now because view will not be ready when viewfinder is started

        mStandbyHandler->startTimer();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::~CxuiViewManager

//

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

//

CxuiViewManager::~CxuiViewManager()

{

    CX_DEBUG_ENTER_FUNCTION();

    delete mCameraDocumentLoader;

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::prepareWindow

//

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

//

void CxuiViewManager::prepareWindow()

{

    getPrecaptureView(mEngine.mode(), mEngine.cameraDeviceControl().cameraIndex())->prepareWindow();

}

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

// CxuiViewManager::createStillPrecaptureView

//

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

//

void CxuiViewManager::createStillPrecaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATESTILLPRECAPTUREVIEW, "msg: e_CX_CREATE_STILLPRECAPTUREVIEW 1" );

    // Use document loader to create widgets and layouts

    // (non-sectioned parts are parsed and loaded)

    mCameraDocumentLoader->load(STILL_1ST_XML, &ok);

    Q_ASSERT_X(ok, "createStillPrecaptureView", "error in xml file parsing");

    OstTrace0( camerax_performance, DUP2_CXUIVIEWMANAGER_CREATESTILLPRECAPTUREVIEW, "msg: e_CX_DOCLOADER_LOAD 0" );

    OstTrace0( camerax_performance, DUP4_CXUIVIEWMANAGER_ADDPRECAPTUREVIEWS, "msg: e_CX_DOCLOADER_FINDWIDGET 1" );

    // ask for the still precapture view widget pointer

    widget = mCameraDocumentLoader->findWidget(STILL_PRE_CAPTURE_VIEW);

    mStillPrecaptureView = qobject_cast<CxuiStillPrecaptureView *> (widget);

    CX_DEBUG_ASSERT(mStillPrecaptureView);

    OstTrace0( camerax_performance, DUP5_CXUIVIEWMANAGER_ADDPRECAPTUREVIEWS, "msg: e_CX_DOCLOADER_FINDWIDGET 0" );

    // call for needed consturction methods

    // .. and add to main window (which also takes ownership)

    mMainWindow.addView(widget);

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATESTILLPRECAPTUREVIEW, "msg: e_CX_CREATE_STILLPRECAPTUREVIEW 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

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

//

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

//

{

    CX_DEBUG_ENTER_FUNCTION();

    bool ok = false;

    CX_DEBUG_ASSERT(mCameraDocumentLoader);

    // Use document loader to create widgets and layouts

    // (non-sectioned parts are parsed and loaded)

    QGraphicsWidget *widget = NULL;

    // .. and add to main window (which also takes ownership)

    mMainWindow.addView(widget);

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::createVideoPrecaptureView

//

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

//

void CxuiViewManager::createVideoPrecaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATEVIDEOPRECAPTUREVIEW, "msg: e_CX_CREATE_VIDEOPRECAPTUREVIEW 1" );

    CX_DEBUG_ASSERT(mCameraDocumentLoader);

    bool ok = false;

    // load and create the default widgets in video xml

    mCameraDocumentLoader->load(VIDEO_1ST_XML, &ok);

    CX_DEBUG_ASSERT(ok);

    // get pointer to videoprecaptureview and do some initialisation

    QGraphicsWidget *widget = NULL;

    widget = mCameraDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIEW);

    mVideoPrecaptureView = qobject_cast<CxuiVideoPrecaptureView *> (widget);

    CX_DEBUG_ASSERT(mVideoPrecaptureView);

    // add view to main window

    mMainWindow.addView(mVideoPrecaptureView);

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATEVIDEOPRECAPTUREVIEW, "msg: e_CX_CREATE_VIDEOPRECAPTUREVIEW 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::createStillPostcaptureView

//

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

//

void CxuiViewManager::createPostcaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG_ASSERT(mCameraDocumentLoader);

    OstTrace0( camerax_performance, CXUIVIEWMANAGER_CREATESTILLPOSTCAPTUREVIEW, "msg: e_CX_CREATE_STILLPOSTCAPTUREVIEW 1" );

    if (!mPostcaptureView) {

        bool ok = false;

        mCameraDocumentLoader->load(POSTCAPTURE_XML, &ok);

        CX_DEBUG_ASSERT(ok);

        // get pointer to videoprecaptureview and do some initialisation

        QGraphicsWidget *widget = NULL;

        widget = mCameraDocumentLoader->findWidget(POSTCAPTURE_VIEW);

        mPostcaptureView = qobject_cast<CxuiPostcaptureView *> (widget);

        CX_DEBUG_ASSERT(mPostcaptureView);

        mPostcaptureView->construct(&mMainWindow, &mEngine, mCameraDocumentLoader);

        mMainWindow.addView(mPostcaptureView);

        connect(mPostcaptureView, SIGNAL(changeToPrecaptureView()), this, SLOT(changeToPrecaptureView()));

    }

    OstTrace0( camerax_performance, DUP1_CXUIVIEWMANAGER_CREATESTILLPOSTCAPTUREVIEW, "msg: e_CX_CREATE_STILLPOSTCAPTUREVIEW 0" );

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::getPrecaptureView

//

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

//

CxuiPrecaptureView*

CxuiViewManager::getPrecaptureView(Cxe::CameraMode mode, Cxe::CameraIndex camera)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG(("CxuiViewManager::getPrecaptureView() mode=%d, camera index=%d", mode, camera));

    if (mode == ImageMode) {

        CX_DEBUG(("CxuiViewManager::getPrecaptureView() image mode"));

        }

    } else {

        CX_DEBUG(("CxuiViewManager::getPrecaptureView() video mode"));

        }

    }

}

CxuiDocumentLoader* CxuiViewManager::documentLoader()

{

    return mCameraDocumentLoader;

}

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

// CxuiViewManager::changeToPostcaptureView

//

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

//

void CxuiViewManager::changeToPostcaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (!mPostcaptureView) {

        createPostcaptureView();

    }

    mMainWindow.blockSignals(true);

    mMainWindow.setCurrentView(mPostcaptureView, false);

    mMainWindow.blockSignals(false);

    // connecting all necessary signals for postcapture view

    connectPostCaptureSignals();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::changeToPrecaptureView

//

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

//

void CxuiViewManager::changeToPrecaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (CxuiServiceProvider::isCameraEmbedded()) {

        // disconnect signals, we only want to call this once after the initial prepare

        disconnect(&mEngine.stillCaptureControl(), SIGNAL(imagePrepareComplete(CxeError::Id)),

                this, SLOT(changeToPrecaptureView()));

        disconnect(&mEngine.videoCaptureControl(), SIGNAL(videoPrepareComplete(CxeError::Id)),

                this, SLOT(changeToPrecaptureView()));

    }

    HbView *view = getPrecaptureView(mEngine.mode(),

        mEngine.cameraDeviceControl().cameraIndex());

    mMainWindow.blockSignals(true);

    mMainWindow.setCurrentView(view, false);

    mMainWindow.blockSignals(false);

    // connecting necessary pre-capture view signals

    connectPreCaptureSignals();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::switchCamera

//

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

//

void CxuiViewManager::switchCamera()

{

    CX_DEBUG_ENTER_FUNCTION();

    Cxe::CameraIndex nextCamera;

    Qt::Orientation nextViewOrientation;

    if (mEngine.cameraDeviceControl().cameraIndex() == Cxe::PrimaryCameraIndex) {

        nextCamera = Cxe::SecondaryCameraIndex;

        nextViewOrientation = Qt::Vertical;

    } else {

        nextCamera = Cxe::PrimaryCameraIndex;

        nextViewOrientation = Qt::Horizontal;

    }

    CxuiPrecaptureView* view = getPrecaptureView(mEngine.mode(), nextCamera);

    mMainWindow.blockSignals(true);

    mMainWindow.setCurrentView(view, false);

    mMainWindow.blockSignals(false);

    view->updateOrientation(nextViewOrientation);

    view->prepareWindow();

    connectPreCaptureSignals();

    mEngine.cameraDeviceControl().switchCamera(nextCamera);

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::eventFilter

//

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

//

bool CxuiViewManager::eventFilter(QObject *object, QEvent *event)

{

    bool eventWasConsumed = false;

    switch (event->type())

    {

    case QEvent::KeyPress:

    case QEvent::KeyRelease:

        break;

    }

    // No need to call base class implementation, because we derive from QObject directly.

    // QObject::eventFilter() implementation always returns false.

    return eventWasConsumed;

}

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

// CxuiViewManager::connectCaptureKeySignals

//

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

//

void CxuiViewManager::connectCaptureKeySignals()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Disconnect all existing capture key signals

    QObject *currentView = mMainWindow.currentView();

    if (currentView) {

        // If the view class does not implement the named slot, the connect will fail

        // and output some warnings as debug prints. This is by design.

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiViewManager::connectPreCaptureSignals

//

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