/*
* Copyright (c) 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 <hbframeitem.h>

#include "cxenamespace.h"
#include "cxesettings.h"
#include "cxuiscenemodeview.h"
#include "cxuienums.h"
#include "cxutils.h"
#include "cxuicapturekeyhandler.h"
#include "cxuisettingsinfo.h"
#include "cxeviewfindercontrol.h"
#include "cxecameradevicecontrol.h"
#include "cxuidocumentloader.h"

using namespace Cxe;
using namespace CxUi;
using namespace CxUiLayout;
using namespace CxUiSettings;
using namespace CxeSettingIds;

const int CXUI_SCENES_TRANSITION_TIME = 350; // 350 milliseconds
const int CXUI_SCENES_CAMERA_TIMEOUT = 60000; // 60 seconds for the camera hw release timeout
const QString CXUI_SCENES_AUTOMATIC_IMAGE=":/camerax/scene_automatic.png";
const QString CXUI_SCENES_LANDSCAPE_IMAGE=":/camerax/scene_landscape.png";
const QString CXUI_SCENES_CLOSEUP_IMAGE=":/camerax/scene_close-up.png";
const QString CXUI_SCENES_PORTRAIT_IMAGE=":/camerax/scene_portrait.png";
const QString CXUI_SCENES_SPORT_IMAGE=":/camerax/scene_sport.png";
const QString CXUI_SCENES_NIGHT_IMAGE=":/camerax/scene_night.png";
const QString CXUI_SCENES_NIGHT_PORTRAIT_IMAGE=":/camerax/scene_nightportrait.png";
const QString CXUI_SCENES_LOW_LIGHT_IMAGE=":/camerax/scene_lowlight.png";


/*!
* Constructor
*/
CxuiSceneModeView::CxuiSceneModeView(QGraphicsItem *parent) :
    HbView(parent),
    mMainWindow(NULL),
    mSettingsInfo(NULL),
    mEngine(NULL),
    mDocumentLoader(NULL),
    mCaptureKeyHandler(NULL),
	mScenesBackground(NULL)
{
    CX_DEBUG_IN_FUNCTION();
}

/*!
* Destructor
*/
CxuiSceneModeView::~CxuiSceneModeView()
{
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Construct-method handles initialisation tasks for this class. Needs to be called
* before the instance of this class is used.
* @param mainwindow
* @param engine
* @param documentLoader
* @param keyHandler
*/
void CxuiSceneModeView::construct(HbMainWindow *mainwindow,
                               CxeEngine *engine,
                               CxuiDocumentLoader *documentLoader,
                               CxuiCaptureKeyHandler *keyHandler)
{
    CX_DEBUG_ENTER_FUNCTION();

    mMainWindow = mainwindow;
    mDocumentLoader = documentLoader;
    mCaptureKeyHandler = keyHandler;
    mEngine = engine;
    mSettingsInfo = new CxuiSettingsInfo(mEngine);
    setContentFullScreen(true);
    loadDefaultWidgets();

    mCameraReleaseTimer.setInterval(CXUI_SCENES_CAMERA_TIMEOUT);    
    connect(&mCameraReleaseTimer, SIGNAL(timeout()), this, SLOT(releaseCameraHw()), Qt::UniqueConnection);

    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Load widgets from DocML.
*/
void CxuiSceneModeView::loadDefaultWidgets()
{
    CX_DEBUG_ENTER_FUNCTION();
    CX_DEBUG_ASSERT(mDocumentLoader);

    QGraphicsWidget *widget = NULL;

    widget = mDocumentLoader->findWidget(SCENE_VIEW_CONTAINER);
    mScenesContainer = qobject_cast<HbWidget *> (widget);

    //Now let's retreive the pointer to icon widget
    widget = mDocumentLoader->findWidget(SCENE_VIEW_BG_IMAGE);
    mScenesBackground = qobject_cast<HbLabel *> (widget);

    widget = mDocumentLoader->findWidget(SCENE_VIEW_BG_IMAGE2);
    mScenesBackground2 = qobject_cast<HbLabel *> (widget);

    //Assuming that the automatic scene mode is always the default one
    CX_DEBUG(("CxuiSceneModeView::loadDefaultWidgets -> Now setting default image"));
    mScenesBackground->setIcon(HbIcon(CXUI_SCENES_AUTOMATIC_IMAGE));

    widget = mDocumentLoader->findWidget(SCENE_VIEW_RADIOBUTTONS);
    mScenesList = qobject_cast<CxuiSettingRadioButtonList *> (widget);

    mTransitionAnimation = new QPropertyAnimation(mScenesBackground2, "opacity");
    mTransitionAnimation->setDuration(CXUI_SCENES_TRANSITION_TIME);

    createWidgetBackgroundGraphic(mScenesContainer, TRANSPARENT_BACKGROUND_GRAPHIC);

    connectSignals();

    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Helper function to connect signals needed in this class.
*/
void CxuiSceneModeView::connectSignals()
{
    connect(mScenesList, SIGNAL(itemSelected(int)), this, SLOT(handleSceneRadiobuttonPress(int)));
    connect(mTransitionAnimation, SIGNAL(finished()), this, SLOT(finishScenesTransition()));
}

/*!
* Function can be used to create a graphics item and setting it as a background
* item for HbWidget. graphicName refers to system wide graphic name. Given graphic
* can consist of one, three or nine pieces. Nine piece graphics are used by default.
* See HbFrameDrawer documentation for graphic naming.
*/
void CxuiSceneModeView::createWidgetBackgroundGraphic(HbWidget *widget,
                                                       const QString &graphicName,
                                                       HbFrameDrawer::FrameType frameType)
{
    if (widget) {
        HbFrameDrawer *drawer = new HbFrameDrawer(graphicName, frameType);

        if (drawer) {
            HbFrameItem *backgroundItem = new HbFrameItem(drawer, widget);
            if (backgroundItem) {
                // set item to fill the whole widget
                backgroundItem->setGeometry(QRectF(QPointF(0, 0), widget->size()));
                backgroundItem->setZValue(0);
                widget->setBackgroundItem(backgroundItem);
            }
        }
    }
}

/*!
* This public method assumes that the view is already properly constructed
*/
void CxuiSceneModeView::loadBackgroundImages()
{
     CX_DEBUG_ENTER_FUNCTION();
    RadioButtonListParams data;
    if (mEngine->mode() == Cxe::ImageMode) {
        mSettingsInfo->getSettingsContent(CxeSettingIds::IMAGE_SCENE, data);
    } else {
        mSettingsInfo->getSettingsContent(CxeSettingIds::VIDEO_SCENE, data);
    }
    mSettingPairList = data.mSettingPairList;
    mScenesList->init(&data);

    if (mScenesBackground) {
        QString sceneId;
        mEngine->settings().get(data.mSettingId, sceneId);
        mScenesBackground->setIcon(HbIcon(backgroundForScene(sceneId)));
    } else {
        //First time displaying a list
        //Assuming that the automatic scene mode is always the default one and is on top of the list
        mScenesList->setSelected(0);
    }
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Handle selecting value in scene list.
*/
void CxuiSceneModeView::handleSceneRadiobuttonPress(int index)
{
    CX_DEBUG_ENTER_FUNCTION();

    CxUiSettings::SettingItem item = mSettingPairList.at(index);
    QString sceneId = item.mValue.toString();
    mScenesBackground2->setIcon(HbIcon(backgroundForScene(sceneId)));
    startBackgroundTransition();
    CX_DEBUG_EXIT_FUNCTION();
}


/*!
* Helper method for getting the background graphic name
* for each of the scenes.
*/
QString CxuiSceneModeView::backgroundForScene(const QString& sceneId)
{
    //!@todo: This mapping should be added to the setting xml.
    if (sceneId == CxeSettingIds::IMAGE_SCENE_AUTO) {
        return CXUI_SCENES_AUTOMATIC_IMAGE;
    } else if (sceneId == CxeSettingIds::IMAGE_SCENE_PORTRAIT) {
        return CXUI_SCENES_PORTRAIT_IMAGE;
    } else if (sceneId == CxeSettingIds::IMAGE_SCENE_SCENERY) {
        return CXUI_SCENES_LANDSCAPE_IMAGE;
    } else if (sceneId == CxeSettingIds::IMAGE_SCENE_MACRO) {
        return CXUI_SCENES_CLOSEUP_IMAGE;
    } else if (sceneId == CxeSettingIds::IMAGE_SCENE_SPORTS) {
        return CXUI_SCENES_SPORT_IMAGE;
    } else if (sceneId == CxeSettingIds::IMAGE_SCENE_NIGHT) {
        return CXUI_SCENES_NIGHT_IMAGE;
    } else if (sceneId == CxeSettingIds::IMAGE_SCENE_NIGHTPORTRAIT) {
        return CXUI_SCENES_NIGHT_PORTRAIT_IMAGE;
    } else if (sceneId == CxeSettingIds::VIDEO_SCENE_AUTO) {
        return CXUI_SCENES_AUTOMATIC_IMAGE;
    } else if (sceneId == CxeSettingIds::VIDEO_SCENE_LOWLIGHT) {
        return CXUI_SCENES_LOW_LIGHT_IMAGE;
    } else if (sceneId == CxeSettingIds::VIDEO_SCENE_NIGHT) {
        return CXUI_SCENES_NIGHT_IMAGE;
    } else {
        return "";
    }

}

/*!
* Start animation for changing the scene background graphic.
*/
void CxuiSceneModeView::startBackgroundTransition()
{
    mTransitionAnimation->setStartValue(0.0);
    mTransitionAnimation->setEndValue(1.0);
    mTransitionAnimation->start();

}

/*!
* Handle scene background graphic animation finishing.
*/
void CxuiSceneModeView::finishScenesTransition()
{
    mScenesBackground->setIcon(mScenesBackground2->icon());
    mScenesBackground2->setOpacity(0);
    mScenesBackground2->setIcon(HbIcon());
}

/*!
* Handle press of ok button.
*/
void CxuiSceneModeView::handleOkButtonPress()
{
    CX_DEBUG_ENTER_FUNCTION();
    mScenesList->handleSelectionAccepted();
    closeView();
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Handle press of cancel button.
*/
void CxuiSceneModeView::handleCancelButtonPress()
{
    CX_DEBUG_ENTER_FUNCTION();
    closeView();
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* This view is about to be shown.
* Update the view to match currently selected scene.
*/
void CxuiSceneModeView::showEvent(QShowEvent *event)
{
    CX_DEBUG_ENTER_FUNCTION();
    mScenesList->scrollTo(mScenesList->currentIndex(), HbAbstractItemView::PositionAtTop);

    mEngine->viewfinderControl().stop();
    mCameraReleaseTimer.start();
    QGraphicsWidget::showEvent(event);
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Slot to handle capture key full press.
*/
void CxuiSceneModeView::handleCaptureKeyPressed()
{
    CX_DEBUG_ENTER_FUNCTION();
    closeView();
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Slot to handle capture key half press / autofocus key press.
*/
void CxuiSceneModeView::handleAutofocusKeyPressed()
{
    CX_DEBUG_ENTER_FUNCTION();
    closeView();
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Closing the view and reactivating camera hw if needed
*/
void CxuiSceneModeView::closeView()
{
    CX_DEBUG_ENTER_FUNCTION();
    mScenesList->handleClose();
    mScenesBackground->setIcon(HbIcon());
    // Make sure engine prepares for new image/video if necessary
    mEngine->initMode(mEngine->mode());
    emit viewCloseEvent();
    CX_DEBUG_EXIT_FUNCTION();
}

/*!
* Slot to handle camera hw release timeout
*/
void CxuiSceneModeView::releaseCameraHw()
{
    CX_DEBUG_ENTER_FUNCTION();
    mCameraReleaseTimer.stop();
    mEngine->cameraDeviceControl().release();
    CX_DEBUG_EXIT_FUNCTION();
}

// end of file