diff -r 8b2d6d0384b0 -r d9aefe59d544 camerauis/cameraxui/cxui/src/cxuiselftimer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraxui/cxui/src/cxuiselftimer.cpp Fri Apr 16 14:51:30 2010 +0300 @@ -0,0 +1,335 @@ +/* +* 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 +#include +#include + +#include "cxuiselftimer.h" +#include "cxutils.h" +#include "cxuienums.h" +#include "cxuidocumentloader.h" +#include "cxesettings.h" +#include "cxenamespace.h" // CxeSettingIds +#include "cxeerror.h" + +using namespace CxUiLayout; + +/*! + \class CxuiSelfTimer + \brief Class for handling selftimer countdown. + + CxuiSelfTimer class handles the selftimer countdown and updates widgets + accordingly. +*/ + +// constants +const int CONTINUOUS_POSTCAPTURE = -1; +const int UNKNOWN = -99; + +CxuiSelfTimer::CxuiSelfTimer(CxeSettings &settings) +: mDelay(-1), + mCounter(0), + mTimer(this), + mOldPostCaptureTimeOut(UNKNOWN), + mIndicatorContainer(NULL), + mButtonContainer(NULL), + mTimerLabel(NULL), + mCancelButton(NULL), + mStartButton(NULL), + mSettings(settings) +{ + CX_DEBUG_ENTER_FUNCTION(); + + connect(&mTimer, SIGNAL(timeout()), this, SLOT(timeout())); + mTimer.setSingleShot(false); + + CX_DEBUG_EXIT_FUNCTION(); +} + +CxuiSelfTimer::~CxuiSelfTimer() +{ + CX_DEBUG_IN_FUNCTION(); +} + +/*! + Get pointers to the UI widgets from the documentloader. + + \param documentLoader Pointer to a CxuiDocumentLoader instance that has + loaded the docml containing selftimer widgets. + */ +void CxuiSelfTimer::loadSelftimerWidgets(CxuiDocumentLoader *documentLoader) { + + if (documentLoader) { + + QGraphicsWidget *widget = NULL; + + widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER); + mIndicatorContainer = qobject_cast(widget); + CX_DEBUG_ASSERT(mIndicatorContainer); + + widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_BUTTON_CONTAINER); + mButtonContainer = qobject_cast(widget); + CX_DEBUG_ASSERT(mButtonContainer); + + widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_COUNTER); + mTimerLabel = qobject_cast(widget); + CX_DEBUG_ASSERT(mTimerLabel); + + widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CANCEL_BUTTON); + mCancelButton = qobject_cast(widget); + CX_DEBUG_ASSERT(mCancelButton); + + widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_START_BUTTON); + mStartButton = qobject_cast(widget); + CX_DEBUG_ASSERT(mStartButton); + + connect(mCancelButton, SIGNAL(released()), this, SLOT(cancel())); + connect(mStartButton, SIGNAL(released()), this, SLOT(startTimer())); + + updateWidgets(); + } +} + +/*! + Method for checking if selftimer is enabled. + Selftimer is enabled/disabled using slots cancel() and changeTimeout() + \return True if selftimer is enabled + + \sa changeTimeOut(int seconds) + \sa cancel() + */ +bool CxuiSelfTimer::isEnabled() +{ + return (mDelay >= 0); +} + +/*! + Method for checking if selftimer countdown is ongoing. + Countdown is started with by calling startTimer(). + \return True if selftimer is active. + + \sa startTimer() + */ +bool CxuiSelfTimer::isOngoing() +{ + return mTimer.isActive(); +} + +/*! Slot for canceling the selftimer. + Disables selftimer, sets back the postcapturetimeout if it + has been changed by selftimer and emits signal to notify interested + parties that cancel has been called. + + \sa startTimer() + */ +void CxuiSelfTimer::cancel() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // show postcapture setting is changed when selftimer is started + // if it has been changed, then change it back + if (mOldPostCaptureTimeOut != UNKNOWN) { + mSettings.set(CxeSettingIds::STILL_SHOWCAPTURED, mOldPostCaptureTimeOut); + mOldPostCaptureTimeOut = UNKNOWN; + } + + // Reset counter and stop any ongoing action. + // Start button back to enabled. + reset(false); + // Disable self timer + mDelay = -1; + + // Update UI components. + updateWidgets(); + + // Signal others about cancellation. + emit cancelled(); + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Slot for handling timer timouts. Counter will be updated and when + selftimer countdown is finished, timerFinished() signal is emitted. + */ +void CxuiSelfTimer::timeout() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // Update seconds passed. + ++mCounter; + + // Update now to have better looking user experience, + // especially when counter elapses: "0" is updated before emitting event, + // so the UI seems to update smoother. + updateWidgets(); + + // Check if timer ran out + if (mCounter >= mDelay) { + mTimer.stop(); + emit timerFinished(); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Slot for resetting the selftimer countdown. Countdown is stopped, + and set back to starting value. Start button is set enabled. + + */ +void CxuiSelfTimer::reset() +{ + CX_DEBUG_ENTER_FUNCTION(); + reset(true); + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Slot for starting the countdown. Show postcapture setting is set to + continuous and previous value stored. Timer is started. + + \sa cancel() + */ +void CxuiSelfTimer::startTimer() +{ + CX_DEBUG_ENTER_FUNCTION(); + + // get the current postcapture timeout + CxeError::Id error = mSettings.get(CxeSettingIds::STILL_SHOWCAPTURED, mOldPostCaptureTimeOut); + + if (error == CxeError::None) { + // set continuous postcapture (view is visible until dismissed) + mSettings.set(CxeSettingIds::STILL_SHOWCAPTURED, CONTINUOUS_POSTCAPTURE); + } else { + // if there was an error, don't modify the postcapture setting + mOldPostCaptureTimeOut = UNKNOWN; + } + + if (mStartButton) { + mStartButton->setEnabled(false); + } + + // start countdown + mCounter = 0; + mTimer.start(1000); // 1000 milliseconds == 1 second + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Slot for receiving changes to the selftimer countdown timeout. + + \param seconds Amount of seconds for the selftimer countdown. If the value is + 0 then selftimer is disabled. + */ +void CxuiSelfTimer::changeTimeOut(int seconds) +{ + CX_DEBUG_ENTER_FUNCTION(); + + // make sure that timer is not running (should not be) + reset(false); + + // set the new timer value + // if incoming value is 0, it means that the selftimer is disabled + if (seconds > 0) { + mDelay = seconds; + } else { + //value == 0 + mDelay = -1; + } + + updateWidgets(); + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! Resets the selftimer countdown. + Countdown is stopped, and set back to starting value. Start button is set enabled. + @param update Update the UI widgets if true, skip update if false. + Can be used to by-pass the UI update if planned to do shortly again. + */ +void CxuiSelfTimer::reset(bool update) +{ + // Stop timer and reset counter. + mTimer.stop(); + mCounter = 0; + + // Set start buttonback to enabled. + if (mStartButton) { + mStartButton->setEnabled(true); + } + + // Update UI if requested. + if(update) { + updateWidgets(); + } +} + +/*! Updates the selftimer widgets + Changes the visibility of the selftimer widgets (counter and cancel button) + based on the timeoutValue. Updates the counter value. + */ +void CxuiSelfTimer::updateWidgets() +{ + CX_DEBUG_ENTER_FUNCTION(); + + int remaining(mDelay - mCounter); + CX_DEBUG(("remaining time %d", remaining)); + + if (mTimerLabel) { + mTimerLabel->setPlainText(QString::number(remaining)); + } + + if (isEnabled()) { + showWidgets(); + } else { + hideWidgets(); + } + + CX_DEBUG_EXIT_FUNCTION(); +} + +/*! + Shows the selftimer widgets. + */ +void CxuiSelfTimer::showWidgets() +{ + if (mIndicatorContainer){ + mIndicatorContainer->show(); + } + + if (mButtonContainer){ + mButtonContainer->show(); + } + +} + +/*! + Hides the selftimer widgets. + */ +void CxuiSelfTimer::hideWidgets() +{ + if (mIndicatorContainer){ + mIndicatorContainer->hide(); + } + + if (mButtonContainer){ + mButtonContainer->hide(); + } + +}