/*

* Copyright (c) 2009-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 <coemain.h>

#include <QProcess>

#include <QApplication>

#include <hbmainwindow.h>

#include <hbslider.h>

#include <hbtoolbar.h>

#include <hblabel.h>

#include <hbtoolbarextension.h>

#include <hbtransparentwindow.h>

#include <hbmenu.h>

#include <hbdialog.h>

#include <hbdeviceprofile.h>

#include <hbnotificationdialog.h>

#include <hbmessagebox.h>

#include <hbaction.h>

#include <hbstyle.h>

#include <hbframeitem.h>

#include <hbwidget.h>

#include "cxeengine.h"

#include "cxeviewfindercontrol.h"

#include "cxezoomcontrol.h"

#include "cxecameradevicecontrol.h"

#include "cxenamespace.h"

#include "cxefeaturemanager.h"

#include "cxestillcapturecontrol.h"

#include "cxevideocapturecontrol.h"

#include "cxesettings.h"

#include "cxutils.h"

#include "cxuienums.h"

#include "cxuidocumentloader.h"

#include "cxuidisplaypropertyhandler.h"

#include "cxuicapturekeyhandler.h"

#include "cxuiprecaptureview.h"

#include "cxuisettingdialog.h"

#include "cxuisettingradiobuttonlist.h"

#include "cxuisettingslider.h"

#include "cxuisettingsinfo.h"

#include "OstTraceDefinitions.h"

#include "cxuiserviceprovider.h"

#include "cxuizoomslider.h"

#include "cxuifullscreenpopup.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuiprecaptureviewTraces.h"

#endif

#include "cxegeotaggingtrail.h"

using namespace CxUiLayout;

using namespace CxUiSettings;

using namespace CxUiInternal;

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

// CxuiPrecaptureView::CxuiPrecaptureView

// Constructor

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

//

CxuiPrecaptureView::CxuiPrecaptureView(QGraphicsItem *parent) :

    CxuiView(parent),

    mViewfinder(0),

    mDisplayHandler(0),

    mSettingsGrid(0),

    mWidgetsLoaded(false),

    mSettingsDialog(NULL),

    mSettingsDialogList(NULL),

    mQualityIcon(NULL),

    mGeoTaggingIndicatorIcon(NULL),

    mFaceTrackingIcon(NULL),

    mStandbyPopup(NULL),

    mSettingsDialogHeading(NULL),

    mSliderSettingsDialog(NULL),

    mSliderSettingsDialogHeading(NULL),

    mSettingsSlider(NULL),

    mSettingsInfo(NULL),

    mSettingsDialogOkAction(NULL),

    mSliderSettingsDialogOkAction(NULL)

{

    CX_DEBUG_ENTER_FUNCTION();

    mDisplayHandler = new CxuiDisplayPropertyHandler();

    CX_DEBUG_EXIT_FUNCTION();

}

CxuiPrecaptureView::~CxuiPrecaptureView()

{

    CX_DEBUG_ENTER_FUNCTION();

    QCoreApplication::instance()->removeEventFilter(this);

    delete mSettingsGrid;

    CX_DEBUG_EXIT_FUNCTION();

}

/**

 * CxuiPrecaptureView::construct

 * Construct-method handles initialisation tasks for this class.

 * @param mainwindow

 * @param engine

 * @param documentLoader

 * @param keyHandler

 */

void CxuiPrecaptureView::construct(HbMainWindow *mainWindow, CxeEngine *engine,

                                   CxuiDocumentLoader *documentLoader,

                                   CxuiCaptureKeyHandler * keyHandler,

                                   HbActivityManager *activityManager)

{

    CX_DEBUG_ENTER_FUNCTION();

    CxuiView::construct(mainWindow, engine, documentLoader, keyHandler, activityManager);

    mSettingsInfo = new CxuiSettingsInfo(engine);

    CX_DEBUG_ASSERT(mSettingsInfo);

    setContentFullScreen(true);

    connect(&mEngine->zoomControl(), SIGNAL(stateChanged(CxeZoomControl::State, CxeError::Id)), this,

            SLOT(handleEngineZoomStateChange(CxeZoomControl::State, CxeError::Id)));

    connect(&mEngine->zoomControl(), SIGNAL(zoomLevelChanged(int)), this,

            SLOT(handleZoomLevelChange(int)));

    connect(&mEngine->viewfinderControl(), SIGNAL(stateChanged(CxeViewfinderControl::State, CxeError::Id)),

            this, SLOT(handleVfStateChanged(CxeViewfinderControl::State, CxeError::Id)));

    connect(&mEngine->geoTaggingTrail(), SIGNAL(stateChanged(CxeGeoTaggingTrail::State, CxeError::Id)),

            this, SLOT(updateLocationIndicator(CxeGeoTaggingTrail::State, CxeError::Id)));

    connect(&(mEngine->settings()), SIGNAL(settingValueChanged(const QString&,QVariant)),

            this, SLOT(handleSettingValueChanged(const QString&, QVariant)));

    // adjust the timer, and connect it to correct slot

    connect(&mHideControlsTimeout, SIGNAL(timeout()), this, SLOT(hideControls()));

    mHideControlsTimeout.setSingleShot(true);

    mHideControlsTimeout.setInterval(CXUI_HIDE_CONTROLS_TIMEOUT);

    hideControls();

    if (CxuiServiceProvider::isCameraEmbedded()) {

        // override exit with action that completes the request before exiting

        HbAction* exitAction = new HbAction(Hb::QuitNaviAction, this);

        connect(exitAction, SIGNAL(triggered()), CxuiServiceProvider::instance(), SLOT(sendFilenameToClientAndExit()));

        setNavigationAction(exitAction);

    }

    QCoreApplication::instance()->installEventFilter(this);

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Is standby mode supported / needed by this view.

* Pre-capture views implement / need standby mode and return true.

* @return True if standby mode is supported, false otherwise.

*/

bool CxuiPrecaptureView::isStandbyModeSupported() const

{

    return true;

}

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

// CxuiPrecaptureView::handleEngineZoomStateChange

// Slot for the initModeComplete signal from device control.

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

//

void CxuiPrecaptureView::handleEngineZoomStateChange(CxeZoomControl::State newState, CxeError::Id /*error*/ )

{

    CX_DEBUG_ENTER_FUNCTION();

    if (newState == CxeZoomControl::Ready) {

        // Set the zoom range (if more than zero!)

        // NOTE: This is & should be done after ECam resolution has been set.

        int min = mEngine->zoomControl().min();

        int max = mEngine->zoomControl().max();

        // only change values if they are acceptable and have changed

        if (mSlider && (max - min > 0) && ((mSlider->maximum() != max)

                || (mSlider->minimum()!= min))) {

            mSlider->setRange(min, max);

        }

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::zoomTo

// Responds to valueChanged notification from zoom bar UI

// and asks the engine to set the appropriate zoom level.

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

//

void CxuiPrecaptureView::zoomTo(int value)

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG(( "Slider value: %d", value ));

    mEngine->zoomControl().zoomTo(value);

    // restarts the timer, if ongoing

    if (mHideControlsTimeout.isActive()) {

        mHideControlsTimeout.start();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::toggleZoom

//

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

//

void CxuiPrecaptureView::toggleZoom()

{

    if (mZoomVisible) {

        hideZoom();

    } else {

        showZoom();

    }

}

/*

 *  Event filter which filters tool bar mouse events and

 *  application wide mouse events.

 */

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

{

    bool eventWasConsumed = false;

    switch (event->type())

    {

    case QEvent::GraphicsSceneMouseRelease:

        if (mStandbyPopup) {

            mStandbyPopup->handleMouseRelease();

        } else {

            mHideControlsTimeout.start();

        }

        break;

    case QEvent::GraphicsSceneMousePress:

        if (object == mStandbyPopup) {

            mStandbyPopup->handleMousePress();

        } else {

            mHideControlsTimeout.stop();

        }

        break;

    default:

        break;

    }

    return eventWasConsumed;

}

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

// CxuiPrecaptureView::toggleControls

//

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

//

void CxuiPrecaptureView::toggleControls()

{

    // This method is put here to demonstrate that widget creation can

    // be postponed using sections in layout xml

    if (!mWidgetsLoaded) {

        // call load widgets to load app DocML and get the pointers to needed widgets

        loadWidgets();

    }

    CxuiView::toggleControls();

}

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

// CxuiPrecaptureView::handleZoomLevelChange

// Slot to handle zoom level change signal from zoom control.

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

//

void CxuiPrecaptureView::handleZoomLevelChange(int zoomValue)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mSlider && zoomValue != mSlider->value()) {

        CX_DEBUG(( "Zoom level is: %d", zoomValue ));

        mSlider->setValue(zoomValue);

    }

    // reset the timer if it is ongoing

    if (mHideControlsTimeout.isActive()) {

        mHideControlsTimeout.start();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::showEvent

//

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

//

void CxuiPrecaptureView::showEvent(QShowEvent *event)

{

    CX_DEBUG_ENTER_FUNCTION();

    QGraphicsWidget::showEvent(event);

    if (event->type() == QEvent::Show) {

        QCoreApplication::instance()->installEventFilter(this);

        event->accept();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::hideEvent

//

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

//

void CxuiPrecaptureView::hideEvent(QHideEvent *event)

{

    CX_DEBUG_ENTER_FUNCTION();

    QGraphicsWidget::hideEvent(event);

    if (event->type() == QEvent::Hide) {

        QCoreApplication::instance()->removeEventFilter(this);

        hideZoom();

        event->accept();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::requestCameraSwitch

// Slot to switch camera. Needed for options menu signals (in DocML).

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

//

void CxuiPrecaptureView::requestCameraSwitch() {

    emit switchCamera();

}

/**

* Handle pressing auto focus key.

*/

void CxuiPrecaptureView::handleAutofocusKeyPressed()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mSettingsDialog) {

        // Prevent us from trying to show grid when dialog closes.

        mSettingsDialog->setStarterAction(NULL);

        mSettingsDialog->close();

    }

    if (mSliderSettingsDialog) {

        mSliderSettingsDialog->setStarterAction(NULL);

        mSliderSettingsDialog->close();

    }

    menu()->close();

    hideControls();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::disableControlsTimeout

// Slot

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

//

void CxuiPrecaptureView::disableControlsTimeout()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mHideControlsTimeout.isActive()) {

        mHideControlsTimeout.stop();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::initCamera

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

void CxuiPrecaptureView::initCamera()

{

    CX_DEBUG_ENTER_FUNCTION();

    mEngine->initMode(mEngine->mode());

    CX_DEBUG_EXIT_FUNCTION();

}

/*

 * viewfinder state call backs

 */

void CxuiPrecaptureView::handleVfStateChanged(

    CxeViewfinderControl::State newState, CxeError::Id /*error*/)

{

    CX_DEBUG_ENTER_FUNCTION();

    if (newState == CxeViewfinderControl::Running) {

        // switch off screen saver and turn on backlight

        if(mDisplayHandler) {

            mDisplayHandler->setDisplayAlwaysVisible(true);

        }

        // start the standby timer

        emit startStandbyTimer();

    } else {

        // switch on screen saver and turn off backlight

        if(mDisplayHandler) {

            mDisplayHandler->setDisplayAlwaysVisible(false);

        }

        // stop the standby timer when vf is not running.

        emit stopStandbyTimer();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Slot for entering standby mode.

* Show standby canvas in addition to base class implementation.

* @sa CxuiView::enterStandby()

*/

void CxuiPrecaptureView::enterStandby()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Release camera right away to avoid any problems with GPU memory.

    CxuiView::enterStandby();

    // If this view is still the current view, show popup.

    // If we moved to precapture view because (error) standby during capturing,

    // don't try show the popup.

    if (mMainWindow->currentView() == this) {

        // Show standby canvas / popup.

        if (!mStandbyPopup) {

            mStandbyPopup = CxuiFullScreenPopup::create(scene(), hbTrId("txt_cam_info_camera_in_standby_mode"));

        }

        mStandbyPopup->show();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Slot for exiting standby mode.

* Hide the standby canvas and re-prepare camera.

* @sa CxuiView::exitStandby()

*/

void CxuiPrecaptureView::exitStandby()

{

    CX_DEBUG_ENTER_FUNCTION();

    CxuiView::exitStandby();

    if (mStandbyPopup) {

        mStandbyPopup->hide();

        delete mStandbyPopup;

        mStandbyPopup = NULL;

    }

    initCamera();

    CX_DEBUG_EXIT_FUNCTION();

}

/*!

* Handle setting dialog showing up.

* If the setting dialog was launched from the setting grid, hide grid now.

* @param action Action that launched the dialog.

*/

void CxuiPrecaptureView::prepareToShowDialog(HbAction *action)

{

    if (!action) {

        return;

    }

    // Check if the dialog was started from grid, and hide the grid now if needed.

    QString fromGrid = action->property(PROPERTY_KEY_SETTING_GRID).toString();

    if (fromGrid.compare(QString(PROPERTY_KEY_TRUE)) == 0 ) {

        hideSettingsGrid();

    }

}

/*!

* Handle setting dialog closing down.

* If the setting dialog was launched from the setting grid, show grid again now.

* @param action Action that launched the dialog.

*/

void CxuiPrecaptureView::prepareToCloseDialog(HbAction *action)

{

    // Check if the dialog was started from grid, and show the grid now if needed.

    // Autofocus key-press will clear the action to disable showing the grid.

    if (action) {

        QString fromGrid = action->property(PROPERTY_KEY_SETTING_GRID).toString();

        if (fromGrid.compare(QString(PROPERTY_KEY_TRUE)) == 0 ) {

            showSettingsGrid();

        }

        // disable geotagging disclaimer after geotagging setting is triggered from FirstTimeUse dialog

        QString settingId = action->property(PROPERTY_KEY_SETTING_ID).toString();

        int value = Cxe::GeoTaggingDisclaimerDisabled;

        mEngine->settings().get(CxeSettingIds::GEOTAGGING_DISCLAIMER, value);

        if (settingId == CxeSettingIds::GEOTAGGING && value == Cxe::GeoTaggingDisclaimerEnabled) {

            // disable geotagging first-time-use dialog

            disableGeotaggingDisclaimer();