13 * |
13 * |
14 * Description: Clock widget |
14 * Description: Clock widget |
15 * |
15 * |
16 */ |
16 */ |
17 |
17 |
18 #include <QtGui> |
18 #include <QTimer> |
19 #include <QGraphicsWidget> |
|
20 #include <QSizePolicy> |
|
21 #include <QGraphicsLinearLayout> |
19 #include <QGraphicsLinearLayout> |
22 #include <hblabel.h> |
|
23 #include <hbextendedlocale.h> |
|
24 #include <hbdeviceprofile.h> // temp |
|
25 |
20 |
26 #include "hsclockwidget.h" |
21 #include "hsclockwidget.h" |
27 #include "hsanalogclockwidget.h" |
22 #include "hsanalogclockwidget.h" |
28 #include "hsdigitalclockwidget.h" |
23 #include "hsdigitalclockwidget.h" |
29 |
24 |
30 #ifdef Q_OS_SYMBIAN |
25 #ifdef Q_OS_SYMBIAN |
31 #include "hsclockwidgettype_symbian.h" |
26 #include "hsclocksettingsnotifier_symbian.h" |
32 #include <apgtask.h> |
27 #include <apgtask.h> |
33 #include <eikenv.h> |
28 #include <eikenv.h> |
34 #endif //Q_OS_SYMBIAN |
29 #endif //Q_OS_SYMBIAN |
35 |
30 |
36 namespace |
31 namespace |
37 { |
32 { |
38 const char ANALOG[] = "analog"; |
33 const char ANALOG[] = "analog"; |
39 const char DIGITAL[] = "digital"; |
34 const char DIGITAL[] = "digital"; |
|
35 const char TIME12[] = "TIME12"; |
|
36 const char TIME24[] = "TIME24"; |
40 |
37 |
41 const int clockUpdateInterval = 1000; // msec |
38 const int clockUpdateInterval = 1000; // msec |
42 } |
39 } |
43 |
40 |
44 #ifdef Q_OS_SYMBIAN |
41 #ifdef Q_OS_SYMBIAN |
48 |
45 |
49 /*! |
46 /*! |
50 \class HsClockWidget |
47 \class HsClockWidget |
51 \ingroup group_hsclockwidgetplugin |
48 \ingroup group_hsclockwidgetplugin |
52 \brief Implementation for the homescreen clock widget. |
49 \brief Implementation for the homescreen clock widget. |
53 |
50 */ |
54 */ |
51 |
55 |
52 /*! |
56 |
|
57 /*! |
|
58 \fn HsClockWidget::HsClockWidget(QGraphicsItem *parent, Qt::WindowFlags flags) |
|
59 |
|
60 Constructs widget. |
53 Constructs widget. |
61 */ |
54 */ |
62 HsClockWidget::HsClockWidget(QGraphicsItem *parent, Qt::WindowFlags flags) |
55 HsClockWidget::HsClockWidget(QGraphicsItem *parent, Qt::WindowFlags flags) |
63 : HbWidget(parent, flags), |
56 : HbWidget(parent, flags), |
64 mTimer(0), |
57 mWidget(0), |
65 mClockType(ANALOG), |
58 mLayout(0), |
66 mWidget(0), |
59 mTimer(0), |
67 mLayout(0), |
60 mClockType(ANALOG), |
68 mWidgetShown(false) |
61 mTimeType(TIME12) |
69 { |
62 { |
70 #if 0 |
|
71 #ifdef Q_OS_SYMBIAN |
63 #ifdef Q_OS_SYMBIAN |
72 HsClockWidgetType *clockType = new HsClockWidgetType(this); |
64 mClockSettingsNotifier = new HsClockSettingsNotifier(this); |
73 mClockType=clockType->type(); |
65 mClockType = mClockSettingsNotifier->clockFormat(); |
74 connect(clockType, SIGNAL(typeChanged(QString)), this, SLOT(onTypeChanged(QString))); |
66 mTimeType = mClockSettingsNotifier->timeFormat(); |
75 #endif |
|
76 #endif |
67 #endif |
77 } |
68 } |
78 |
69 |
79 /*! |
70 /*! |
80 \fn HsClockWidget::~HsClockWidget() |
|
81 |
|
82 Destructor. |
71 Destructor. |
83 */ |
72 */ |
84 HsClockWidget::~HsClockWidget() |
73 HsClockWidget::~HsClockWidget() |
85 { |
74 { |
86 } |
75 } |
87 |
76 |
88 /*! |
77 /*! |
89 Returns the clock type. |
78 Initializes this widget. |
90 */ |
|
91 QString HsClockWidget::clockType() const |
|
92 { |
|
93 return mClockType; |
|
94 } |
|
95 |
|
96 /*! |
|
97 Sets the clock type; |
|
98 */ |
|
99 void HsClockWidget::setClockType(const QString &type) |
|
100 { |
|
101 if (type == DIGITAL) { |
|
102 mClockType = DIGITAL; |
|
103 } else { |
|
104 mClockType = ANALOG; |
|
105 } |
|
106 } |
|
107 |
|
108 /*! |
|
109 \fn void HsClockWidget::onInitialize() |
|
110 |
|
111 Initializes clock widget |
|
112 */ |
79 */ |
113 void HsClockWidget::onInitialize() |
80 void HsClockWidget::onInitialize() |
114 { |
81 { |
115 mLayout = new QGraphicsLinearLayout(Qt::Vertical); |
82 mLayout = new QGraphicsLinearLayout(Qt::Vertical); |
116 mLayout->setContentsMargins(0,0,0,0); |
83 mLayout->setContentsMargins(0, 0, 0, 0); |
117 |
|
118 mWidget = loadClockWidget(); |
84 mWidget = loadClockWidget(); |
119 mLayout->addItem(mWidget); |
85 mLayout->addItem(mWidget); |
120 setPreferredSize(mWidget->preferredSize()); |
|
121 parentWidget()->resize(preferredSize()); // workaround for layouting |
|
122 |
|
123 mTimer = new QTimer(this); |
86 mTimer = new QTimer(this); |
124 connect(mTimer, SIGNAL(timeout()), SLOT(updateTime())); |
87 connect(mTimer, SIGNAL(timeout()), SLOT(updateTime())); |
125 setLayout(mLayout); |
88 setLayout(mLayout); |
126 } |
89 #ifdef Q_OS_SYMBIAN |
127 |
90 connect(mClockSettingsNotifier, SIGNAL(settingsChanged(QString, QString)), this, SLOT(onSettingsChanged(QString, QString))); |
128 /*! |
91 #endif |
129 \fn void HsClockWidget::show() |
92 |
130 |
93 } |
131 Shows the widget |
94 |
|
95 /*! |
|
96 Shows this widget. |
132 */ |
97 */ |
133 void HsClockWidget::onShow() |
98 void HsClockWidget::onShow() |
134 { |
99 { |
135 mWidgetShown = true; |
|
136 mTimer->start(clockUpdateInterval); |
100 mTimer->start(clockUpdateInterval); |
137 } |
101 } |
138 |
102 |
139 |
103 |
140 /*! |
104 /*! |
141 \fn void HsClockWidget::show() |
105 Hides this widget. |
142 |
|
143 Hides the widget |
|
144 */ |
106 */ |
145 void HsClockWidget::onHide() |
107 void HsClockWidget::onHide() |
146 { |
108 { |
147 mWidgetShown = false; |
|
148 mTimer->stop(); |
109 mTimer->stop(); |
149 } |
110 } |
150 |
111 |
151 /*! |
112 /*! |
152 Uninitializes the widget. |
113 Uninitializes this widget. |
153 */ |
114 */ |
154 void HsClockWidget::onUninitialize() |
115 void HsClockWidget::onUninitialize() |
155 { |
116 { |
156 mTimer->stop(); |
117 mTimer->stop(); |
157 } |
118 } |
158 |
119 |
159 /*! |
120 /*! |
160 \fn void HsClockWidget::updateTime() |
121 Draws the clock with every second. |
161 |
|
162 Draws the clock with every second |
|
163 */ |
122 */ |
164 void HsClockWidget::updateTime() |
123 void HsClockWidget::updateTime() |
165 { |
124 { |
166 if (mClockType == DIGITAL) { |
125 if (mClockType == DIGITAL) { |
167 hide(); // workaround for clock not updating |
126 static_cast<HsDigitalClockWidget*>(mWidget)->tick(); |
168 static_cast<HbLabel*>(mWidget)->setPlainText( |
|
169 HbExtendedLocale().format(QTime::currentTime(), r_qtn_time_usual_with_zero)); |
|
170 show(); // workaround for clock not updating |
|
171 } else { |
127 } else { |
172 static_cast<HsAnalogClockWidget*>(mWidget)->tick(); |
128 static_cast<HsAnalogClockWidget*>(mWidget)->tick(); |
173 } |
129 } |
174 } |
130 } |
175 |
131 |
176 /*! |
132 /*! |
177 Toggles the clock type. |
133 \internal |
178 */ |
134 */ |
179 void HsClockWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) |
135 void HsClockWidget::onSettingsChanged(const QString &clockFormat, const QString &timeFormat) |
180 { |
136 { |
181 if (!contains(event->pos())) { |
137 if (mClockType != clockFormat) { |
182 return; |
138 mClockType = clockFormat; |
183 } |
139 mLayout->removeItem(mWidget); |
184 |
140 delete mWidget; |
185 #ifndef Q_OS_SYMBIAN |
141 mWidget = 0; |
186 mTimer->stop(); |
142 mWidget = loadClockWidget(); |
187 toggleClockType(); |
143 mLayout->addItem(mWidget); |
188 emit setPreferences(QStringList() << "clockType"); |
144 } |
189 |
145 |
190 hide(); |
146 if (mTimeType != timeFormat) { |
191 |
147 mTimeType = timeFormat; |
|
148 if (mClockType == DIGITAL) { |
|
149 if (mTimeType == TIME12) { |
|
150 static_cast<HsDigitalClockWidget*>(mWidget)->setAmPm(true); |
|
151 } else { |
|
152 static_cast<HsDigitalClockWidget*>(mWidget)->setAmPm(false); |
|
153 } |
|
154 } |
|
155 } |
|
156 } |
|
157 |
|
158 /*! |
|
159 Clock tapped. |
|
160 */ |
|
161 void HsClockWidget::onClockTapped() |
|
162 { |
|
163 #ifndef Q_OS_SYMBIAN |
|
164 if (mClockType == ANALOG) { |
|
165 mClockType = DIGITAL; |
|
166 if (mTimeType == TIME12) { |
|
167 mTimeType = TIME24; |
|
168 } else { |
|
169 mTimeType = TIME12; |
|
170 } |
|
171 } else { |
|
172 mClockType = ANALOG; |
|
173 } |
192 mLayout->removeItem(mWidget); |
174 mLayout->removeItem(mWidget); |
193 delete mWidget; |
175 delete mWidget; |
194 mWidget = 0; |
176 mWidget = 0; |
195 mWidget = loadClockWidget(); |
177 mWidget = loadClockWidget(); |
196 mLayout->addItem(mWidget); |
178 mLayout->addItem(mWidget); |
197 setPreferredSize(mWidget->preferredSize()); |
|
198 parentWidget()->resize(preferredSize()); |
|
199 |
|
200 show(); |
|
201 updateTime(); |
179 updateTime(); |
202 update(); |
|
203 |
|
204 mTimer->start(clockUpdateInterval); |
|
205 #else //Q_OS_SYMBIAN |
180 #else //Q_OS_SYMBIAN |
206 TApaTaskList taskList(CEikonEnv::Static()->WsSession()); |
181 TApaTaskList taskList(CEikonEnv::Static()->WsSession()); |
207 TApaTask task = taskList.FindApp(KClockAppUid); |
182 TApaTask task = taskList.FindApp(KClockAppUid); |
208 if (task.Exists()){ |
183 if (task.Exists()){ |
209 task.BringToForeground(); |
184 task.BringToForeground(); |
219 } |
194 } |
220 } |
195 } |
221 #endif //Q_OS_SYMBIAN |
196 #endif //Q_OS_SYMBIAN |
222 } |
197 } |
223 |
198 |
224 |
|
225 /*! |
|
226 Toggles the clock type. |
|
227 */ |
|
228 void HsClockWidget::toggleClockType() |
|
229 { |
|
230 if (mClockType == ANALOG) { |
|
231 mClockType = DIGITAL; |
|
232 } else { |
|
233 mClockType = ANALOG; |
|
234 } |
|
235 } |
|
236 |
|
237 /*! |
199 /*! |
238 Loads the digital or analog clock widget. |
200 Loads the digital or analog clock widget. |
239 */ |
201 */ |
240 HbWidget *HsClockWidget::loadClockWidget() |
202 HbWidget *HsClockWidget::loadClockWidget() |
241 { |
203 { |
242 HbWidget *clockWidget = 0; |
204 HbWidget *clockWidget = 0; |
243 |
205 |
244 if (mClockType == DIGITAL) { |
206 if (mClockType == DIGITAL) { |
245 clockWidget = new HsDigitalClockWidget(); |
207 bool useAmPm = true; |
246 clockWidget->setBackgroundItem(HbStyle::P_Fade_background); |
208 if (mTimeType == TIME24) { |
|
209 useAmPm = false; |
|
210 } |
|
211 clockWidget = new HsDigitalClockWidget(useAmPm); |
247 } else { |
212 } else { |
248 clockWidget = new HsAnalogClockWidget(); |
213 clockWidget = new HsAnalogClockWidget(); |
249 } |
214 } |
250 |
215 |
251 qreal unit = HbDeviceProfile::current().unitValue(); |
216 connect(clockWidget, SIGNAL(clockTapped()), this, SLOT(onClockTapped()), Qt::QueuedConnection); |
252 clockWidget->setPreferredSize(QSizeF(25 * unit, 25 * unit)); // TODO: temp workaround |
|
253 |
|
254 return clockWidget; |
217 return clockWidget; |
255 } |
218 } |
256 |
|
257 void HsClockWidget::onTypeChanged(QString type) |
|
258 { |
|
259 Q_UNUSED(type); |
|
260 #if 0 |
|
261 if (mClockType != type) { |
|
262 mTimer->stop(); |
|
263 mClockType = type; |
|
264 emit setPreferences(QStringList() << "clockType"); |
|
265 hide(); |
|
266 mLayout->removeItem(mWidget); |
|
267 delete mWidget; |
|
268 mWidget = 0; |
|
269 mWidget = loadClockWidget(); |
|
270 mLayout->addItem(mWidget); |
|
271 setPreferredSize(mWidget->preferredSize()); |
|
272 parentWidget()->resize(preferredSize()); |
|
273 if ( mWidgetShown ) { |
|
274 mTimer->start(clockUpdateInterval); |
|
275 show(); |
|
276 } |
|
277 } |
|
278 #endif |
|
279 } |
|