/*

* Copyright (c) 2009 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 <QGraphicsSceneEvent>

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

// CONSTANTS

const int CXUI_HIDE_CONTROLS_TIMEOUT     = 6000; // 6 seconds

const QString PhotosAppExe = "photos.exe";

const QString VideosAppExe = "videoplayer.exe";

using namespace CxUiLayout;

using namespace CxUiSettings;

using namespace CxUiInternal;

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

// CxuiPrecaptureView::CxuiPrecaptureView

// Constructor

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

//

CxuiPrecaptureView::CxuiPrecaptureView(QGraphicsItem *parent) :

    HbView(parent),

    mEngine(0),

    mViewfinder(0),

    mMainWindow(0),

    mDocumentLoader(0),

    mDisplayHandler(0),

    mControlsVisible(false),

    mHideControlsTimeout(this),

    mSlider(0),

    mToolBar(0),

    mSettingsGrid(0),

    mZoomVisible(false),

    mWidgetsLoaded(false),

    mSettingsDialog(NULL),

    mSettingsDialogList(NULL),

    mKeyHandler(NULL),

    mQualityIcon(NULL),

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

}

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

    CX_ASSERT_ALWAYS(mainWindow);

    CX_ASSERT_ALWAYS(engine);

    CX_ASSERT_ALWAYS(documentLoader);

    mMainWindow = mainWindow;

    mEngine = engine;

    mDocumentLoader = documentLoader;

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

        setFlag(QGraphicsItem::ItemIsFocusable);

        setFocusPolicy(Qt::StrongFocus);

        setFocus();

    }

    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::hideControls

//

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

//

void CxuiPrecaptureView::hideControls()

{

    CX_DEBUG_ENTER_FUNCTION();

    hideItems(Hb::AllItems);

    hideZoom();

    mControlsVisible = false;

    if (mHideControlsTimeout.isActive()) {

        mHideControlsTimeout.stop();

    }

    hideToolbar();

    // show indicators when controls are hidden

    showIndicators();

    // give the keyboard focus back to the view

    // for the view to receive key events

    setFocus();

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::hideToolbar

//

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

//

void CxuiPrecaptureView::hideToolbar()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mToolBar) {

        mToolBar->hide();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::hideZoom

//

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

//

void CxuiPrecaptureView::hideZoom()

{

    if (mSlider) {

        mSlider->hide();

    }

    mZoomVisible = false;

}

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

// CxuiPrecaptureView::showZoom

//

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

//

void CxuiPrecaptureView::showZoom()

{

    CX_DEBUG_ENTER_FUNCTION();

    if (mSlider) {

        // if maxVal has not been set yet, ask for new parameters from engine

        if (mSlider->maximum() <= 0) {

            // get the zoom range

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

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

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

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

                mSlider->setRange(min, max);

            }

        }

        // show zoom only if the slider has acceptable value

        if (mSlider->maximum() > 0) {

            mSlider->show();

        }

    }

    mZoomVisible = true;

    CX_DEBUG_EXIT_FUNCTION();

}

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

// CxuiPrecaptureView::toggleZoom

//

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

//

void CxuiPrecaptureView::toggleZoom()

{

    if (mZoomVisible) {

        hideZoom();

    } else {

        showZoom();

    }

}

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

// CxuiPrecaptureView::hideIndicators

//

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

//

void CxuiPrecaptureView::hideIndicators()

{

    if (mIndicators) {

        mIndicators->hide();

    }

}

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

// CxuiPrecaptureView::showIndicators

//

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

//

void CxuiPrecaptureView::showIndicators()

{

    if (mIndicators) {

        mIndicators->show();

    }

}

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

// CxuiPrecaptureView::showControls

//

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

//

void CxuiPrecaptureView::showControls()

{

    if (mEngine) {

        bool videoCases = (mEngine->videoCaptureControl().state() == CxeVideoCaptureControl::Recording ||

                           mEngine->videoCaptureControl().state() == CxeVideoCaptureControl::Paused);

        if (mEngine->isEngineReady() || videoCases) {

            // show toolbar

            showToolbar();

            // show zoom

            showZoom();

            // show titlepane

            showItems(Hb::AllItems);

            // hide indicators when controls are shown

            hideIndicators();

            mHideControlsTimeout.start();

            mControlsVisible = true;

        }

    }

}

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

// CxuiPrecaptureView::showToolbar

// shows toolbar

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

//

void CxuiPrecaptureView::showToolbar()

{

    CX_DEBUG_ENTER_FUNCTION();

    // toolbar pointer is missing if widgets for the view have not been loaded

    // from the DocML

    if (mToolBar) {

        mToolBar->show();

    }

    CX_DEBUG_EXIT_FUNCTION();

}

/*

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

    }

    if (mControlsVisible) {

        hideControls();

    } else {

        showControls();

    }

}

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

// CxuiPrecaptureView::mousePressEvent

//

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

//

void CxuiPrecaptureView::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

    //! @todo temporary workaround for title bar mouse event handling bug

    if (event->type() == QEvent::GraphicsSceneMousePress && event->scenePos().y() > 70) {

        toggleControls();

        event->accept();

    }

}

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

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