|
1 /* |
|
2 * Copyright (c) 2009 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 <QGraphicsWidget> |
|
18 #include <hblabel.h> |
|
19 #include <hbpushbutton.h> |
|
20 |
|
21 #include "cxuiselftimer.h" |
|
22 #include "cxutils.h" |
|
23 #include "cxuienums.h" |
|
24 #include "cxuidocumentloader.h" |
|
25 #include "cxesettings.h" |
|
26 #include "cxenamespace.h" // CxeSettingIds |
|
27 #include "cxeerror.h" |
|
28 |
|
29 using namespace CxUiLayout; |
|
30 |
|
31 /*! |
|
32 \class CxuiSelfTimer |
|
33 \brief Class for handling selftimer countdown. |
|
34 |
|
35 CxuiSelfTimer class handles the selftimer countdown and updates widgets |
|
36 accordingly. |
|
37 */ |
|
38 |
|
39 // constants |
|
40 const int CONTINUOUS_POSTCAPTURE = -1; |
|
41 const int UNKNOWN = -99; |
|
42 |
|
43 CxuiSelfTimer::CxuiSelfTimer(CxeSettings &settings) |
|
44 : mDelay(-1), |
|
45 mCounter(0), |
|
46 mTimer(this), |
|
47 mOldPostCaptureTimeOut(UNKNOWN), |
|
48 mIndicatorContainer(NULL), |
|
49 mButtonContainer(NULL), |
|
50 mTimerLabel(NULL), |
|
51 mCancelButton(NULL), |
|
52 mStartButton(NULL), |
|
53 mSettings(settings) |
|
54 { |
|
55 CX_DEBUG_ENTER_FUNCTION(); |
|
56 |
|
57 connect(&mTimer, SIGNAL(timeout()), this, SLOT(timeout())); |
|
58 mTimer.setSingleShot(false); |
|
59 |
|
60 CX_DEBUG_EXIT_FUNCTION(); |
|
61 } |
|
62 |
|
63 CxuiSelfTimer::~CxuiSelfTimer() |
|
64 { |
|
65 CX_DEBUG_IN_FUNCTION(); |
|
66 } |
|
67 |
|
68 /*! |
|
69 Get pointers to the UI widgets from the documentloader. |
|
70 |
|
71 \param documentLoader Pointer to a CxuiDocumentLoader instance that has |
|
72 loaded the docml containing selftimer widgets. |
|
73 */ |
|
74 void CxuiSelfTimer::loadSelftimerWidgets(CxuiDocumentLoader *documentLoader) { |
|
75 |
|
76 if (documentLoader) { |
|
77 |
|
78 QGraphicsWidget *widget = NULL; |
|
79 |
|
80 widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER); |
|
81 mIndicatorContainer = qobject_cast<HbWidget *>(widget); |
|
82 CX_DEBUG_ASSERT(mIndicatorContainer); |
|
83 |
|
84 widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_BUTTON_CONTAINER); |
|
85 mButtonContainer = qobject_cast<HbWidget *>(widget); |
|
86 CX_DEBUG_ASSERT(mButtonContainer); |
|
87 |
|
88 widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_COUNTER); |
|
89 mTimerLabel = qobject_cast<HbLabel *>(widget); |
|
90 CX_DEBUG_ASSERT(mTimerLabel); |
|
91 |
|
92 widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CANCEL_BUTTON); |
|
93 mCancelButton = qobject_cast<HbPushButton *>(widget); |
|
94 CX_DEBUG_ASSERT(mCancelButton); |
|
95 |
|
96 widget = documentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_START_BUTTON); |
|
97 mStartButton = qobject_cast<HbPushButton *>(widget); |
|
98 CX_DEBUG_ASSERT(mStartButton); |
|
99 |
|
100 connect(mCancelButton, SIGNAL(released()), this, SLOT(cancel())); |
|
101 connect(mStartButton, SIGNAL(released()), this, SLOT(startTimer())); |
|
102 |
|
103 updateWidgets(); |
|
104 } |
|
105 } |
|
106 |
|
107 /*! |
|
108 Method for checking if selftimer is enabled. |
|
109 Selftimer is enabled/disabled using slots cancel() and changeTimeout() |
|
110 \return True if selftimer is enabled |
|
111 |
|
112 \sa changeTimeOut(int seconds) |
|
113 \sa cancel() |
|
114 */ |
|
115 bool CxuiSelfTimer::isEnabled() |
|
116 { |
|
117 return (mDelay >= 0); |
|
118 } |
|
119 |
|
120 /*! |
|
121 Method for checking if selftimer countdown is ongoing. |
|
122 Countdown is started with by calling startTimer(). |
|
123 \return True if selftimer is active. |
|
124 |
|
125 \sa startTimer() |
|
126 */ |
|
127 bool CxuiSelfTimer::isOngoing() |
|
128 { |
|
129 return mTimer.isActive(); |
|
130 } |
|
131 |
|
132 /*! Slot for canceling the selftimer. |
|
133 Disables selftimer, sets back the postcapturetimeout if it |
|
134 has been changed by selftimer and emits signal to notify interested |
|
135 parties that cancel has been called. |
|
136 |
|
137 \sa startTimer() |
|
138 */ |
|
139 void CxuiSelfTimer::cancel() |
|
140 { |
|
141 CX_DEBUG_ENTER_FUNCTION(); |
|
142 |
|
143 // show postcapture setting is changed when selftimer is started |
|
144 // if it has been changed, then change it back |
|
145 if (mOldPostCaptureTimeOut != UNKNOWN) { |
|
146 mSettings.set(CxeSettingIds::STILL_SHOWCAPTURED, mOldPostCaptureTimeOut); |
|
147 mOldPostCaptureTimeOut = UNKNOWN; |
|
148 } |
|
149 |
|
150 // Reset counter and stop any ongoing action. |
|
151 // Start button back to enabled. |
|
152 reset(false); |
|
153 // Disable self timer |
|
154 mDelay = -1; |
|
155 |
|
156 // Update UI components. |
|
157 updateWidgets(); |
|
158 |
|
159 // Signal others about cancellation. |
|
160 emit cancelled(); |
|
161 |
|
162 CX_DEBUG_EXIT_FUNCTION(); |
|
163 } |
|
164 |
|
165 /*! |
|
166 Slot for handling timer timouts. Counter will be updated and when |
|
167 selftimer countdown is finished, timerFinished() signal is emitted. |
|
168 */ |
|
169 void CxuiSelfTimer::timeout() |
|
170 { |
|
171 CX_DEBUG_ENTER_FUNCTION(); |
|
172 |
|
173 // Update seconds passed. |
|
174 ++mCounter; |
|
175 |
|
176 // Update now to have better looking user experience, |
|
177 // especially when counter elapses: "0" is updated before emitting event, |
|
178 // so the UI seems to update smoother. |
|
179 updateWidgets(); |
|
180 |
|
181 // Check if timer ran out |
|
182 if (mCounter >= mDelay) { |
|
183 mTimer.stop(); |
|
184 emit timerFinished(); |
|
185 } |
|
186 |
|
187 CX_DEBUG_EXIT_FUNCTION(); |
|
188 } |
|
189 |
|
190 /*! |
|
191 Slot for resetting the selftimer countdown. Countdown is stopped, |
|
192 and set back to starting value. Start button is set enabled. |
|
193 |
|
194 */ |
|
195 void CxuiSelfTimer::reset() |
|
196 { |
|
197 CX_DEBUG_ENTER_FUNCTION(); |
|
198 reset(true); |
|
199 CX_DEBUG_EXIT_FUNCTION(); |
|
200 } |
|
201 |
|
202 /*! |
|
203 Slot for starting the countdown. Show postcapture setting is set to |
|
204 continuous and previous value stored. Timer is started. |
|
205 |
|
206 \sa cancel() |
|
207 */ |
|
208 void CxuiSelfTimer::startTimer() |
|
209 { |
|
210 CX_DEBUG_ENTER_FUNCTION(); |
|
211 |
|
212 // get the current postcapture timeout |
|
213 CxeError::Id error = mSettings.get(CxeSettingIds::STILL_SHOWCAPTURED, mOldPostCaptureTimeOut); |
|
214 |
|
215 if (error == CxeError::None) { |
|
216 // set continuous postcapture (view is visible until dismissed) |
|
217 mSettings.set(CxeSettingIds::STILL_SHOWCAPTURED, CONTINUOUS_POSTCAPTURE); |
|
218 } else { |
|
219 // if there was an error, don't modify the postcapture setting |
|
220 mOldPostCaptureTimeOut = UNKNOWN; |
|
221 } |
|
222 |
|
223 if (mStartButton) { |
|
224 mStartButton->setEnabled(false); |
|
225 } |
|
226 |
|
227 // start countdown |
|
228 mCounter = 0; |
|
229 mTimer.start(1000); // 1000 milliseconds == 1 second |
|
230 |
|
231 CX_DEBUG_EXIT_FUNCTION(); |
|
232 } |
|
233 |
|
234 /*! |
|
235 Slot for receiving changes to the selftimer countdown timeout. |
|
236 |
|
237 \param seconds Amount of seconds for the selftimer countdown. If the value is |
|
238 0 then selftimer is disabled. |
|
239 */ |
|
240 void CxuiSelfTimer::changeTimeOut(int seconds) |
|
241 { |
|
242 CX_DEBUG_ENTER_FUNCTION(); |
|
243 |
|
244 // make sure that timer is not running (should not be) |
|
245 reset(false); |
|
246 |
|
247 // set the new timer value |
|
248 // if incoming value is 0, it means that the selftimer is disabled |
|
249 if (seconds > 0) { |
|
250 mDelay = seconds; |
|
251 } else { |
|
252 //value == 0 |
|
253 mDelay = -1; |
|
254 } |
|
255 |
|
256 updateWidgets(); |
|
257 |
|
258 CX_DEBUG_EXIT_FUNCTION(); |
|
259 } |
|
260 |
|
261 /*! Resets the selftimer countdown. |
|
262 Countdown is stopped, and set back to starting value. Start button is set enabled. |
|
263 @param update Update the UI widgets if true, skip update if false. |
|
264 Can be used to by-pass the UI update if planned to do shortly again. |
|
265 */ |
|
266 void CxuiSelfTimer::reset(bool update) |
|
267 { |
|
268 // Stop timer and reset counter. |
|
269 mTimer.stop(); |
|
270 mCounter = 0; |
|
271 |
|
272 // Set start buttonback to enabled. |
|
273 if (mStartButton) { |
|
274 mStartButton->setEnabled(true); |
|
275 } |
|
276 |
|
277 // Update UI if requested. |
|
278 if(update) { |
|
279 updateWidgets(); |
|
280 } |
|
281 } |
|
282 |
|
283 /*! Updates the selftimer widgets |
|
284 Changes the visibility of the selftimer widgets (counter and cancel button) |
|
285 based on the timeoutValue. Updates the counter value. |
|
286 */ |
|
287 void CxuiSelfTimer::updateWidgets() |
|
288 { |
|
289 CX_DEBUG_ENTER_FUNCTION(); |
|
290 |
|
291 int remaining(mDelay - mCounter); |
|
292 CX_DEBUG(("remaining time %d", remaining)); |
|
293 |
|
294 if (mTimerLabel) { |
|
295 mTimerLabel->setPlainText(QString::number(remaining)); |
|
296 } |
|
297 |
|
298 if (isEnabled()) { |
|
299 showWidgets(); |
|
300 } else { |
|
301 hideWidgets(); |
|
302 } |
|
303 |
|
304 CX_DEBUG_EXIT_FUNCTION(); |
|
305 } |
|
306 |
|
307 /*! |
|
308 Shows the selftimer widgets. |
|
309 */ |
|
310 void CxuiSelfTimer::showWidgets() |
|
311 { |
|
312 if (mIndicatorContainer){ |
|
313 mIndicatorContainer->show(); |
|
314 } |
|
315 |
|
316 if (mButtonContainer){ |
|
317 mButtonContainer->show(); |
|
318 } |
|
319 |
|
320 } |
|
321 |
|
322 /*! |
|
323 Hides the selftimer widgets. |
|
324 */ |
|
325 void CxuiSelfTimer::hideWidgets() |
|
326 { |
|
327 if (mIndicatorContainer){ |
|
328 mIndicatorContainer->hide(); |
|
329 } |
|
330 |
|
331 if (mButtonContainer){ |
|
332 mButtonContainer->hide(); |
|
333 } |
|
334 |
|
335 } |