camerauis/cameraxui/cxui/src/cxuiscenemodeview.cpp
changeset 28 3075d9b614e6
child 39 c5025ea871a1
child 43 0e652f8f1fbd
equal deleted inserted replaced
19:d9aefe59d544 28:3075d9b614e6
       
     1 /*
       
     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 #include <hbframeitem.h>
       
    18 
       
    19 #include "cxenamespace.h"
       
    20 #include "cxesettings.h"
       
    21 #include "cxuiscenemodeview.h"
       
    22 #include "cxuienums.h"
       
    23 #include "cxutils.h"
       
    24 #include "cxuicapturekeyhandler.h"
       
    25 #include "cxuisettingsinfo.h"
       
    26 #include "cxeviewfindercontrol.h"
       
    27 #include "cxecameradevicecontrol.h"
       
    28 #include "cxuidocumentloader.h"
       
    29 
       
    30 using namespace Cxe;
       
    31 using namespace CxUi;
       
    32 using namespace CxUiLayout;
       
    33 using namespace CxUiSettings;
       
    34 using namespace CxeSettingIds;
       
    35 
       
    36 const int CXUI_SCENES_TRANSITION_TIME = 350; // 350 milliseconds
       
    37 const int CXUI_SCENES_CAMERA_TIMEOUT = 60000; // 60 seconds for the camera hw release timeout
       
    38 const QString CXUI_SCENES_AUTOMATIC_IMAGE=":/camerax/scene_automatic.png";
       
    39 const QString CXUI_SCENES_LANDSCAPE_IMAGE=":/camerax/scene_landscape.png";
       
    40 const QString CXUI_SCENES_CLOSEUP_IMAGE=":/camerax/scene_close-up.png";
       
    41 const QString CXUI_SCENES_PORTRAIT_IMAGE=":/camerax/scene_portrait.png";
       
    42 const QString CXUI_SCENES_SPORT_IMAGE=":/camerax/scene_sport.png";
       
    43 const QString CXUI_SCENES_NIGHT_IMAGE=":/camerax/scene_night.png";
       
    44 const QString CXUI_SCENES_NIGHT_PORTRAIT_IMAGE=":/camerax/scene_nightportrait.png";
       
    45 const QString CXUI_SCENES_LOW_LIGHT_IMAGE=":/camerax/scene_lowlight.png";
       
    46 
       
    47 
       
    48 /*!
       
    49 * Constructor
       
    50 */
       
    51 CxuiSceneModeView::CxuiSceneModeView(QGraphicsItem *parent) :
       
    52     HbView(parent),
       
    53     mMainWindow(NULL),
       
    54     mSettingsInfo(NULL),
       
    55     mEngine(NULL),
       
    56     mDocumentLoader(NULL),
       
    57     mCaptureKeyHandler(NULL),
       
    58 	mScenesBackground(NULL)
       
    59 {
       
    60     CX_DEBUG_IN_FUNCTION();
       
    61 }
       
    62 
       
    63 /*!
       
    64 * Destructor
       
    65 */
       
    66 CxuiSceneModeView::~CxuiSceneModeView()
       
    67 {
       
    68     CX_DEBUG_ENTER_FUNCTION();
       
    69     CX_DEBUG_EXIT_FUNCTION();
       
    70 }
       
    71 
       
    72 /*!
       
    73 * Construct-method handles initialisation tasks for this class. Needs to be called
       
    74 * before the instance of this class is used.
       
    75 * @param mainwindow
       
    76 * @param engine
       
    77 * @param documentLoader
       
    78 * @param keyHandler
       
    79 */
       
    80 void CxuiSceneModeView::construct(HbMainWindow *mainwindow,
       
    81                                CxeEngine *engine,
       
    82                                CxuiDocumentLoader *documentLoader,
       
    83                                CxuiCaptureKeyHandler *keyHandler)
       
    84 {
       
    85     CX_DEBUG_ENTER_FUNCTION();
       
    86 
       
    87     mMainWindow = mainwindow;
       
    88     mDocumentLoader = documentLoader;
       
    89     mCaptureKeyHandler = keyHandler;
       
    90     mEngine = engine;
       
    91     mSettingsInfo = new CxuiSettingsInfo(mEngine);
       
    92     setContentFullScreen(true);
       
    93     loadDefaultWidgets();
       
    94 
       
    95     mCameraReleaseTimer.setInterval(CXUI_SCENES_CAMERA_TIMEOUT);    
       
    96     connect(&mCameraReleaseTimer, SIGNAL(timeout()), this, SLOT(releaseCameraHw()), Qt::UniqueConnection);
       
    97 
       
    98     CX_DEBUG_EXIT_FUNCTION();
       
    99 }
       
   100 
       
   101 /*!
       
   102 * Load widgets from DocML.
       
   103 */
       
   104 void CxuiSceneModeView::loadDefaultWidgets()
       
   105 {
       
   106     CX_DEBUG_ENTER_FUNCTION();
       
   107     CX_DEBUG_ASSERT(mDocumentLoader);
       
   108 
       
   109     QGraphicsWidget *widget = NULL;
       
   110 
       
   111     widget = mDocumentLoader->findWidget(SCENE_VIEW_CONTAINER);
       
   112     mScenesContainer = qobject_cast<HbWidget *> (widget);
       
   113 
       
   114     //Now let's retreive the pointer to icon widget
       
   115     widget = mDocumentLoader->findWidget(SCENE_VIEW_BG_IMAGE);
       
   116     mScenesBackground = qobject_cast<HbLabel *> (widget);
       
   117 
       
   118     widget = mDocumentLoader->findWidget(SCENE_VIEW_BG_IMAGE2);
       
   119     mScenesBackground2 = qobject_cast<HbLabel *> (widget);
       
   120 
       
   121     //Assuming that the automatic scene mode is always the default one
       
   122     CX_DEBUG(("CxuiSceneModeView::loadDefaultWidgets -> Now setting default image"));
       
   123     mScenesBackground->setIcon(HbIcon(CXUI_SCENES_AUTOMATIC_IMAGE));
       
   124 
       
   125     widget = mDocumentLoader->findWidget(SCENE_VIEW_RADIOBUTTONS);
       
   126     mScenesList = qobject_cast<CxuiSettingRadioButtonList *> (widget);
       
   127 
       
   128     mTransitionAnimation = new QPropertyAnimation(mScenesBackground2, "opacity");
       
   129     mTransitionAnimation->setDuration(CXUI_SCENES_TRANSITION_TIME);
       
   130 
       
   131     createWidgetBackgroundGraphic(mScenesContainer, TRANSPARENT_BACKGROUND_GRAPHIC);
       
   132 
       
   133     connectSignals();
       
   134 
       
   135     CX_DEBUG_EXIT_FUNCTION();
       
   136 }
       
   137 
       
   138 /*!
       
   139 * Helper function to connect signals needed in this class.
       
   140 */
       
   141 void CxuiSceneModeView::connectSignals()
       
   142 {
       
   143     connect(mScenesList, SIGNAL(itemSelected(int)), this, SLOT(handleSceneRadiobuttonPress(int)));
       
   144     connect(mTransitionAnimation, SIGNAL(finished()), this, SLOT(finishScenesTransition()));
       
   145 }
       
   146 
       
   147 /*!
       
   148 * Function can be used to create a graphics item and setting it as a background
       
   149 * item for HbWidget. graphicName refers to system wide graphic name. Given graphic
       
   150 * can consist of one, three or nine pieces. Nine piece graphics are used by default.
       
   151 * See HbFrameDrawer documentation for graphic naming.
       
   152 */
       
   153 void CxuiSceneModeView::createWidgetBackgroundGraphic(HbWidget *widget,
       
   154                                                        const QString &graphicName,
       
   155                                                        HbFrameDrawer::FrameType frameType)
       
   156 {
       
   157     if (widget) {
       
   158         HbFrameDrawer *drawer = new HbFrameDrawer(graphicName, frameType);
       
   159 
       
   160         if (drawer) {
       
   161             HbFrameItem *backgroundItem = new HbFrameItem(drawer, widget);
       
   162             if (backgroundItem) {
       
   163                 // set item to fill the whole widget
       
   164                 backgroundItem->setGeometry(QRectF(QPointF(0, 0), widget->size()));
       
   165                 backgroundItem->setZValue(0);
       
   166                 widget->setBackgroundItem(backgroundItem);
       
   167             }
       
   168         }
       
   169     }
       
   170 }
       
   171 
       
   172 /*!
       
   173 * This public method assumes that the view is already properly constructed
       
   174 */
       
   175 void CxuiSceneModeView::loadBackgroundImages()
       
   176 {
       
   177      CX_DEBUG_ENTER_FUNCTION();
       
   178     RadioButtonListParams data;
       
   179     if (mEngine->mode() == Cxe::ImageMode) {
       
   180         mSettingsInfo->getSettingsContent(CxeSettingIds::IMAGE_SCENE, data);
       
   181     } else {
       
   182         mSettingsInfo->getSettingsContent(CxeSettingIds::VIDEO_SCENE, data);
       
   183     }
       
   184     mSettingPairList = data.mSettingPairList;
       
   185     mScenesList->init(&data);
       
   186 
       
   187     if (mScenesBackground) {
       
   188         QString sceneId;
       
   189         mEngine->settings().get(data.mSettingId, sceneId);
       
   190         mScenesBackground->setIcon(HbIcon(backgroundForScene(sceneId)));
       
   191     } else {
       
   192         //First time displaying a list
       
   193         //Assuming that the automatic scene mode is always the default one and is on top of the list
       
   194         mScenesList->setSelected(0);
       
   195     }
       
   196     CX_DEBUG_EXIT_FUNCTION();
       
   197 }
       
   198 
       
   199 /*!
       
   200 * Handle selecting value in scene list.
       
   201 */
       
   202 void CxuiSceneModeView::handleSceneRadiobuttonPress(int index)
       
   203 {
       
   204     CX_DEBUG_ENTER_FUNCTION();
       
   205 
       
   206     CxUiSettings::SettingItem item = mSettingPairList.at(index);
       
   207     QString sceneId = item.mValue.toString();
       
   208     mScenesBackground2->setIcon(HbIcon(backgroundForScene(sceneId)));
       
   209     startBackgroundTransition();
       
   210     CX_DEBUG_EXIT_FUNCTION();
       
   211 }
       
   212 
       
   213 
       
   214 /*!
       
   215 * Helper method for getting the background graphic name
       
   216 * for each of the scenes.
       
   217 */
       
   218 QString CxuiSceneModeView::backgroundForScene(const QString& sceneId)
       
   219 {
       
   220     //!@todo: This mapping should be added to the setting xml.
       
   221     if (sceneId == CxeSettingIds::IMAGE_SCENE_AUTO) {
       
   222         return CXUI_SCENES_AUTOMATIC_IMAGE;
       
   223     } else if (sceneId == CxeSettingIds::IMAGE_SCENE_PORTRAIT) {
       
   224         return CXUI_SCENES_PORTRAIT_IMAGE;
       
   225     } else if (sceneId == CxeSettingIds::IMAGE_SCENE_SCENERY) {
       
   226         return CXUI_SCENES_LANDSCAPE_IMAGE;
       
   227     } else if (sceneId == CxeSettingIds::IMAGE_SCENE_MACRO) {
       
   228         return CXUI_SCENES_CLOSEUP_IMAGE;
       
   229     } else if (sceneId == CxeSettingIds::IMAGE_SCENE_SPORTS) {
       
   230         return CXUI_SCENES_SPORT_IMAGE;
       
   231     } else if (sceneId == CxeSettingIds::IMAGE_SCENE_NIGHT) {
       
   232         return CXUI_SCENES_NIGHT_IMAGE;
       
   233     } else if (sceneId == CxeSettingIds::IMAGE_SCENE_NIGHTPORTRAIT) {
       
   234         return CXUI_SCENES_NIGHT_PORTRAIT_IMAGE;
       
   235     } else if (sceneId == CxeSettingIds::VIDEO_SCENE_AUTO) {
       
   236         return CXUI_SCENES_AUTOMATIC_IMAGE;
       
   237     } else if (sceneId == CxeSettingIds::VIDEO_SCENE_LOWLIGHT) {
       
   238         return CXUI_SCENES_LOW_LIGHT_IMAGE;
       
   239     } else if (sceneId == CxeSettingIds::VIDEO_SCENE_NIGHT) {
       
   240         return CXUI_SCENES_NIGHT_IMAGE;
       
   241     } else {
       
   242         return "";
       
   243     }
       
   244 
       
   245 }
       
   246 
       
   247 /*!
       
   248 * Start animation for changing the scene background graphic.
       
   249 */
       
   250 void CxuiSceneModeView::startBackgroundTransition()
       
   251 {
       
   252     mTransitionAnimation->setStartValue(0.0);
       
   253     mTransitionAnimation->setEndValue(1.0);
       
   254     mTransitionAnimation->start();
       
   255 
       
   256 }
       
   257 
       
   258 /*!
       
   259 * Handle scene background graphic animation finishing.
       
   260 */
       
   261 void CxuiSceneModeView::finishScenesTransition()
       
   262 {
       
   263     mScenesBackground->setIcon(mScenesBackground2->icon());
       
   264     mScenesBackground2->setOpacity(0);
       
   265     mScenesBackground2->setIcon(HbIcon());
       
   266 }
       
   267 
       
   268 /*!
       
   269 * Handle press of ok button.
       
   270 */
       
   271 void CxuiSceneModeView::handleOkButtonPress()
       
   272 {
       
   273     CX_DEBUG_ENTER_FUNCTION();
       
   274     mScenesList->handleSelectionAccepted();
       
   275     closeView();
       
   276     CX_DEBUG_EXIT_FUNCTION();
       
   277 }
       
   278 
       
   279 /*!
       
   280 * Handle press of cancel button.
       
   281 */
       
   282 void CxuiSceneModeView::handleCancelButtonPress()
       
   283 {
       
   284     CX_DEBUG_ENTER_FUNCTION();
       
   285     closeView();
       
   286     CX_DEBUG_EXIT_FUNCTION();
       
   287 }
       
   288 
       
   289 /*!
       
   290 * This view is about to be shown.
       
   291 * Update the view to match currently selected scene.
       
   292 */
       
   293 void CxuiSceneModeView::showEvent(QShowEvent *event)
       
   294 {
       
   295     CX_DEBUG_ENTER_FUNCTION();
       
   296     mScenesList->scrollTo(mScenesList->currentIndex(), HbAbstractItemView::PositionAtTop);
       
   297 
       
   298     mEngine->viewfinderControl().stop();
       
   299     mCameraReleaseTimer.start();
       
   300     QGraphicsWidget::showEvent(event);
       
   301     CX_DEBUG_EXIT_FUNCTION();
       
   302 }
       
   303 
       
   304 /*!
       
   305 * Slot to handle capture key full press.
       
   306 */
       
   307 void CxuiSceneModeView::handleCaptureKeyPressed()
       
   308 {
       
   309     CX_DEBUG_ENTER_FUNCTION();
       
   310     closeView();
       
   311     CX_DEBUG_EXIT_FUNCTION();
       
   312 }
       
   313 
       
   314 /*!
       
   315 * Slot to handle capture key half press / autofocus key press.
       
   316 */
       
   317 void CxuiSceneModeView::handleAutofocusKeyPressed()
       
   318 {
       
   319     CX_DEBUG_ENTER_FUNCTION();
       
   320     closeView();
       
   321     CX_DEBUG_EXIT_FUNCTION();
       
   322 }
       
   323 
       
   324 /*!
       
   325 * Closing the view and reactivating camera hw if needed
       
   326 */
       
   327 void CxuiSceneModeView::closeView()
       
   328 {
       
   329     CX_DEBUG_ENTER_FUNCTION();
       
   330     mScenesList->handleClose();
       
   331     mScenesBackground->setIcon(HbIcon());
       
   332     // Make sure engine prepares for new image/video if necessary
       
   333     mEngine->initMode(mEngine->mode());
       
   334     emit viewCloseEvent();
       
   335     CX_DEBUG_EXIT_FUNCTION();
       
   336 }
       
   337 
       
   338 /*!
       
   339 * Slot to handle camera hw release timeout
       
   340 */
       
   341 void CxuiSceneModeView::releaseCameraHw()
       
   342 {
       
   343     CX_DEBUG_ENTER_FUNCTION();
       
   344     mCameraReleaseTimer.stop();
       
   345     mEngine->cameraDeviceControl().release();
       
   346     CX_DEBUG_EXIT_FUNCTION();
       
   347 }
       
   348 
       
   349 // end of file
       
   350