/*

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

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cxuiprecaptureviewTraces.h"

#endif

#include "cxuiserviceprovider.h"

#include "cxuizoomslider.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),

    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)

{

    CX_DEBUG_ENTER_FUNCTION();

    OstTrace0( camerax_performance, CXUIPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_PRECAPVIEW_CONST 1" );

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

    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->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);

    }

    OstTrace0( camerax_performance, DUP1_CXUIPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_PRECAPVIEW_CONST 0" );

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

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::prepareWindow

//

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

//

void CxuiPrecaptureView::prepareWindow()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mMainWindow) {

        mEngine->viewfinderControl().setWindow(mMainWindow->effectiveWinId());

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// 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)

{

    Q_UNUSED(object)

    bool eventWasConsumed = false;

    switch (event->type())

    {

    case QEvent::GraphicsSceneMouseRelease:

        mHideControlsTimeout.start();

        break;

    case QEvent::GraphicsSceneMousePress:

        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();

}

/*

 * CxuiPrecaptureView::handleFocusGained

 */

void CxuiPrecaptureView::handleFocusGained()

{

    CX_DEBUG_ENTER_FUNCTION();

    // Set the window size and handle again.

    prepareWindow();

    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.

    }

    // Clear the starter actions to be sure they are not reused.

    if (mSettingsDialog) {

        mSettingsDialog->setStarterAction(NULL);

    }

    if (mSliderSettingsDialog) {

        mSliderSettingsDialog->setStarterAction(NULL);

    }

    // Dialog will be deleted automatically when closed

    // The pointers may become invalid at any time

    mSettingsDialog = NULL;

    mSettingsDialogList = NULL;

    mSettingsDialogHeading = NULL;

    mSliderSettingsDialog = NULL;

    mSliderSettingsDialogHeading = NULL;

    mSettingsSlider = NULL;

}

/*!

*Helper method to create setting dialog

*/

CxuiSettingDialog* CxuiPrecaptureView::createSettingsDialog()

{

    CX_DEBUG_ENTER_FUNCTION();

    CX_DEBUG(("Loading popup DocML"));

    CxuiDocumentLoader *documentLoader = new CxuiDocumentLoader(mEngine);

    // Use document loader to create popup

    bool ok = false;

    documentLoader->load(SETTINGS_DIALOG_XML, &ok);

    CX_DEBUG(("load ok=%d", ok));

    CxuiSettingDialog *dialog =

        qobject_cast<CxuiSettingDialog*>(documentLoader->findWidget(SETTINGS_DIALOG_WIDGET));

    CX_ASSERT_ALWAYS(dialog);

    dialog->setTimeout(HbDialog::NoTimeout);

    dialog->setBackgroundFaded(false);

    mSettingsDialogHeading = qobject_cast<HbLabel *>(

                                    documentLoader->findWidget(SETTINGS_DIALOG_HEADING_WIDGET));

    CX_ASSERT_ALWAYS(mSettingsDialogHeading);

    mSettingsDialogList = qobject_cast<CxuiSettingRadioButtonList *>(

                                    documentLoader->findWidget(SETTINGS_DIALOG_CONTENT_WIDGET));

    CX_ASSERT_ALWAYS(mSettingsDialogList);