|
1 /**************************************************************************** |
|
2 ** |
|
3 ** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). |
|
4 ** All rights reserved. |
|
5 ** Contact: Nokia Corporation (developer.feedback@nokia.com) |
|
6 ** |
|
7 ** This file is part of the HbWidgets module of the UI Extensions for Mobile. |
|
8 ** |
|
9 ** GNU Lesser General Public License Usage |
|
10 ** This file may be used under the terms of the GNU Lesser General Public |
|
11 ** License version 2.1 as published by the Free Software Foundation and |
|
12 ** appearing in the file LICENSE.LGPL included in the packaging of this file. |
|
13 ** Please review the following information to ensure the GNU Lesser General |
|
14 ** Public License version 2.1 requirements will be met: |
|
15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
|
16 ** |
|
17 ** In addition, as a special exception, Nokia gives you certain additional |
|
18 ** rights. These rights are described in the Nokia Qt LGPL Exception |
|
19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
|
20 ** |
|
21 ** If you have questions regarding the use of this file, please contact |
|
22 ** Nokia at developer.feedback@nokia.com. |
|
23 ** |
|
24 ****************************************************************************/ |
|
25 |
|
26 |
|
27 |
|
28 |
|
29 #include <hbnamespace_p.h> |
|
30 #include <hbiconitem.h> |
|
31 #include <hbaction.h> |
|
32 #include <hbprogressnote.h> |
|
33 #include <hbprogressnote_p.h> |
|
34 #include <hbstyleoptionprogressdialog.h> |
|
35 #include <hbstyleoptionprogressbar.h> |
|
36 #include <hbinstance.h> |
|
37 |
|
38 #include <QGraphicsItem> |
|
39 #include <QDebug> |
|
40 |
|
41 class HbProgressNoteContentWidget:public HbWidget |
|
42 { |
|
43 Q_OBJECT |
|
44 public: |
|
45 QGraphicsItem* mIconItem; |
|
46 HbProgressBar* mPb; |
|
47 HbLabel *mText;// This will be HbTextItem and creation will delegate to style when it fixes the layout issue... |
|
48 HbProgressNotePrivate *d; |
|
49 enum { Type = HbPrivate::ItemType_ProgressNoteContentWidget }; |
|
50 int type() const { return Type; } |
|
51 HbProgressNoteContentWidget(HbProgressNotePrivate *priv,QGraphicsItem* parent =0 ):HbWidget(parent), |
|
52 mIconItem(0),mPb(0),mText(0),d(priv) |
|
53 { |
|
54 |
|
55 if( !mPb ){ |
|
56 mPb = new HbProgressBar(HbProgressBar::SimpleProgressBar,this); |
|
57 } |
|
58 |
|
59 // Unfortunately i cant create the textitem via Style... |
|
60 /*mTextItem = style()->createPrimitive(HbStyle::P_Note_text, this); |
|
61 */ |
|
62 |
|
63 mText = new HbLabel(this); // This will be HbTextItem and creation will delegate to style |
|
64 // when it fixes the layout issue... |
|
65 mIconItem = style()->createPrimitive(HbStyle::P_MessageBox_icon, this); |
|
66 |
|
67 mText->setTextWrapping(Hb::TextWrapAnywhere); |
|
68 HbStyle::setItemName(mText, "text"); |
|
69 HbStyle::setItemName(mIconItem, "icon"); |
|
70 HbStyle::setItemName(mPb, "pbar"); |
|
71 HbStyle::setItemName(this, "this"); |
|
72 |
|
73 setProperty("hasText",true); |
|
74 setProperty("hasIcon",true); |
|
75 |
|
76 } |
|
77 void polish( HbStyleParameters& params ) { |
|
78 |
|
79 if( ((HbIconItem*)mIconItem)->isNull()){ |
|
80 HbStyle::setItemName(mIconItem,QString()); |
|
81 setProperty("hasIcon",false); |
|
82 } |
|
83 HbWidget::polish(params); |
|
84 //hack for popups resize issue |
|
85 if(parentLayoutItem()->parentLayoutItem()) { |
|
86 HbWidget* parentWidget = (HbWidget*) parentLayoutItem()->parentLayoutItem(); |
|
87 parentWidget->resize(parentWidget->preferredSize()); |
|
88 } |
|
89 } |
|
90 |
|
91 }; |
|
92 |
|
93 HbProgressNotePrivate::HbProgressNotePrivate() : |
|
94 mAction(0),mTimer(0),mContentWidget(0),mTextWrapping(true),mMinDuration(0),mDelayTime(0) |
|
95 { |
|
96 |
|
97 } |
|
98 |
|
99 HbProgressNotePrivate::~HbProgressNotePrivate() |
|
100 { |
|
101 |
|
102 } |
|
103 |
|
104 |
|
105 void HbProgressNotePrivate::init(HbProgressNote::ProgressNoteType type) |
|
106 { |
|
107 Q_Q(HbProgressNote); |
|
108 mContentWidget = new HbProgressNoteContentWidget(this); |
|
109 q->setContentWidget(mContentWidget); |
|
110 mNoteType = type ; |
|
111 |
|
112 if(mNoteType == HbProgressNote::WaitNote){ |
|
113 mContentWidget->mPb->setRange(0,0); |
|
114 } |
|
115 else{ |
|
116 mContentWidget->mPb->setRange(0,100); |
|
117 } |
|
118 mAction = new HbAction(q->tr("Cancel")); |
|
119 QObject::connect(mAction, SIGNAL(triggered()), q, SLOT(_q_userCancel())); |
|
120 q->setPrimaryAction(mAction); |
|
121 mMinDuration = 1500; |
|
122 mDelayTime = 1000; |
|
123 |
|
124 mTimer = new QTimeLine(mDelayTime, q); |
|
125 mTimer->setFrameRange(0, 100); |
|
126 |
|
127 |
|
128 QObject::connect(mTimer, SIGNAL(finished()), q, SLOT(_q_finished())); |
|
129 q->setTimeout(HbPopup::NoTimeout); |
|
130 q->setDismissPolicy(HbPopup::NoDismiss); |
|
131 q->setModal(false); |
|
132 q->setBackgroundFaded(false); |
|
133 q->hide(); |
|
134 |
|
135 |
|
136 |
|
137 } |
|
138 |
|
139 void HbProgressNotePrivate::_q_userCancel() |
|
140 { |
|
141 Q_Q(HbProgressNote); |
|
142 flags &= ~HbProgressNotePrivate::Closetimer; |
|
143 mTimer->stop(); |
|
144 q->cancel(); |
|
145 |
|
146 } |
|
147 |
|
148 void HbProgressNotePrivate::_q_finished() |
|
149 { |
|
150 Q_Q(HbProgressNote); |
|
151 |
|
152 if(flags.testFlag(HbProgressNotePrivate::Showtimer)){ |
|
153 mTimer->stop(); |
|
154 q->HbDialog::show(); |
|
155 mTimer->setDuration(mMinDuration); |
|
156 mTimer->setCurrentTime(0); |
|
157 mTimer->start(); |
|
158 flags &= ~HbProgressNotePrivate::Showtimer; |
|
159 flags |= HbProgressNotePrivate::Closetimer; |
|
160 } |
|
161 else if(flags.testFlag(HbProgressNotePrivate::Closetimer)){ |
|
162 flags &= ~HbProgressNotePrivate::Closetimer; |
|
163 if(flags.testFlag(HbProgressNotePrivate::Closepending)){ |
|
164 q->close(); |
|
165 } |
|
166 } |
|
167 } |
|
168 |
|
169 void HbProgressNotePrivate::_q_progressValueChanged(int value) |
|
170 { |
|
171 Q_Q(HbProgressNote); |
|
172 if(value >= mContentWidget->mPb->maximum() && q->autoClose()){ |
|
173 if(flags.testFlag(HbProgressNotePrivate::Closetimer)){ |
|
174 flags |= HbProgressNotePrivate::Closepending; |
|
175 flags &= ~HbProgressNotePrivate::Showtimer; |
|
176 } |
|
177 else if(!flags.testFlag(HbProgressNotePrivate::Showtimer)){ |
|
178 q->close(); |
|
179 } |
|
180 else{ |
|
181 flags &= ~HbProgressNotePrivate::Showtimer; |
|
182 } |
|
183 } |
|
184 } |
|
185 |
|
186 |
|
187 /*! |
|
188 @deprecated |
|
189 @hbwidgets |
|
190 |
|
191 \this is deprecated class, use HbPrgoressDialog. |
|
192 |
|
193 \class HbProgressNote |
|
194 \brief HbProgressNote is a notification widget that combines test, icon, and a progress bar. |
|
195 |
|
196 \image html hbprogressnote.png A progress note. |
|
197 |
|
198 HbProgressNote provides several types of notifications. The supported types are: |
|
199 |
|
200 \code |
|
201 enum ProgressNoteType { ProgressNote, WaitNote }; |
|
202 \endcode |
|
203 |
|
204 \sa HbDialog |
|
205 |
|
206 Progress note has a number of use cases. Depending on the use case, either the value of the progress bar |
|
207 is updated manually or waiting progress bar will be shown. The former case is used when displaying a download note. |
|
208 The latter case is used when connecting to network or opening a web page. The examples below demonstrate the use |
|
209 cases. |
|
210 |
|
211 The first example is a note displayed when the application is connecting |
|
212 to network. As the delay is unknown the waiting progressbar will be shown indefinitely. |
|
213 The note disappears if the user clicks Cancel button or |
|
214 after the connection is established in which case the application closes the progress note. |
|
215 |
|
216 Here is an example of using the infinite progress note: |
|
217 |
|
218 \code |
|
219 HbProgressNote *note = new HbProgressNote(HbProgressNote::WaitNote); |
|
220 note->show(); |
|
221 \endcode |
|
222 |
|
223 The progress note is closed explicitly when the user clicks Cancel button or the application calls cancel(). |
|
224 |
|
225 Another use case is an application downloading a file. |
|
226 \code |
|
227 HbProgressNote *note = new HbProgressNote(HbProgressNote::ProgressNote); |
|
228 note->setMinimum(0); |
|
229 note->setMaximum(1000); |
|
230 note->show(); |
|
231 for (int i=0;i<1000;i+=100) |
|
232 { |
|
233 note->setProgressValue(i); |
|
234 note->setText(QString("Downloaded %1/1000 KB").arg(i)); |
|
235 } |
|
236 |
|
237 \endcode |
|
238 */ |
|
239 |
|
240 /*! |
|
241 Constructor. |
|
242 |
|
243 \param type Must be one of the defined ProgressNoteType enumerations. |
|
244 \param parent An optional parameter. |
|
245 |
|
246 \deprecated HbProgressNote::HbProgressNote(HbProgressNote::ProgressNoteType, QGraphicsItem*) |
|
247 is deprecated. |
|
248 */ |
|
249 |
|
250 HbProgressNote::HbProgressNote(ProgressNoteType type, QGraphicsItem *parent) : |
|
251 HbDialog(*new HbProgressNotePrivate, parent) |
|
252 { |
|
253 Q_D(HbProgressNote); |
|
254 d->init(type); |
|
255 setAutoClose(true); |
|
256 } |
|
257 |
|
258 /*! |
|
259 Constructor. |
|
260 |
|
261 \param parent An optional parameter. |
|
262 |
|
263 \deprecated HbProgressNote::HbProgressNote(QGraphicsItem*) |
|
264 is deprecated. |
|
265 |
|
266 */ |
|
267 HbProgressNote::HbProgressNote(QGraphicsItem *parent) : |
|
268 HbDialog(*new HbProgressNotePrivate, parent) |
|
269 { |
|
270 Q_D(HbProgressNote); |
|
271 d->init(ProgressNote); |
|
272 setAutoClose(true); |
|
273 } |
|
274 |
|
275 /*! |
|
276 Returns the maximum value of the progressbar within the note. |
|
277 |
|
278 The default value is \c 100. |
|
279 |
|
280 \sa setMaximum() |
|
281 */ |
|
282 int HbProgressNote::maximum() const |
|
283 { |
|
284 Q_D(const HbProgressNote); |
|
285 |
|
286 return d->mContentWidget->mPb->maximum(); |
|
287 } |
|
288 |
|
289 |
|
290 /*! |
|
291 Sets the maximum value of the progressbar within the note. |
|
292 |
|
293 \sa maximum() |
|
294 */ |
|
295 void HbProgressNote::setMaximum(int max) |
|
296 { |
|
297 Q_D(HbProgressNote); |
|
298 |
|
299 d->mContentWidget->mPb->setMaximum(max); |
|
300 } |
|
301 |
|
302 /*! |
|
303 Returns the minimum value of the progressbar within the note. |
|
304 |
|
305 The default value is \c 0. |
|
306 |
|
307 \sa setMinimum() |
|
308 */ |
|
309 int HbProgressNote::minimum() const |
|
310 { |
|
311 Q_D(const HbProgressNote); |
|
312 return d->mContentWidget->mPb->minimum(); |
|
313 } |
|
314 |
|
315 /*! |
|
316 Sets the minimum value of the progressbar within the note. |
|
317 |
|
318 \sa minimum() |
|
319 */ |
|
320 void HbProgressNote::setMinimum(int min) |
|
321 { |
|
322 Q_D(HbProgressNote); |
|
323 |
|
324 d->mContentWidget->mPb->setMinimum(min); |
|
325 } |
|
326 |
|
327 /*! |
|
328 Sets the minimum and maximum value of the progressbar within the note. |
|
329 |
|
330 \sa minimum() |
|
331 \sa maximum() |
|
332 */ |
|
333 void HbProgressNote::setRange(int min,int max) |
|
334 { |
|
335 Q_D(HbProgressNote); |
|
336 d->mContentWidget->mPb->setRange(min,max); |
|
337 } |
|
338 |
|
339 /*! |
|
340 Returns the value of the progressbar within the note. |
|
341 |
|
342 This value is constrained as follows: |
|
343 \b minimum <= \c value <= \b maximum. |
|
344 |
|
345 \sa setValue() |
|
346 |
|
347 */ |
|
348 int HbProgressNote::progressValue() const |
|
349 { |
|
350 Q_D(const HbProgressNote); |
|
351 |
|
352 return d->mContentWidget->mPb->progressValue(); |
|
353 } |
|
354 |
|
355 /*! |
|
356 Sets the value of the progressbar within the note. |
|
357 After the timeline has been started the value is updated automatically. |
|
358 Use this function only if the timer is not used. |
|
359 |
|
360 This value is constrained as follows: |
|
361 \b minimum <= \c value <= \b maximum. |
|
362 |
|
363 \sa value() |
|
364 |
|
365 */ |
|
366 void HbProgressNote::setProgressValue(int value) |
|
367 { |
|
368 Q_D(HbProgressNote); |
|
369 |
|
370 d->mContentWidget->mPb->setProgressValue(value); |
|
371 d->_q_progressValueChanged(value); |
|
372 } |
|
373 |
|
374 /*! |
|
375 Closes the popup while emitting the cancelled() signal. This function is called when |
|
376 user presses the Cancel button or then the timer expires. |
|
377 |
|
378 */ |
|
379 void HbProgressNote::cancel() |
|
380 { |
|
381 // Q_D(HbProgressNote); |
|
382 |
|
383 emit cancelled(); |
|
384 close(); |
|
385 } |
|
386 |
|
387 QGraphicsItem* HbProgressNote::primitive(HbStyle::Primitive primitive) const |
|
388 { |
|
389 Q_D(const HbProgressNote); |
|
390 switch (primitive) { |
|
391 case HbStyle::P_Popup_background: |
|
392 return HbDialog::primitive(primitive); |
|
393 case HbStyle::P_ProgressDialog_icon: |
|
394 return d->mContentWidget->mIconItem; |
|
395 default: |
|
396 return 0; |
|
397 } |
|
398 } |
|
399 |
|
400 /*! |
|
401 Sets the progressnote type. |
|
402 \sa progressNoteType() |
|
403 */ |
|
404 void HbProgressNote::setProgressNoteType(HbProgressNote::ProgressNoteType type) |
|
405 { |
|
406 Q_D(HbProgressNote); |
|
407 if(d->mNoteType != type) { |
|
408 d->mNoteType = type; |
|
409 if(type == WaitNote){ |
|
410 d->mContentWidget->mPb->setRange(0,0); |
|
411 } |
|
412 else { |
|
413 d->mContentWidget->mPb->setRange(0,100); |
|
414 } |
|
415 } |
|
416 } |
|
417 |
|
418 /*! |
|
419 returns progressnote type; |
|
420 \sa setProgressNoteType() |
|
421 */ |
|
422 HbProgressNote::ProgressNoteType HbProgressNote::progressNoteType() const |
|
423 { |
|
424 Q_D(const HbProgressNote); |
|
425 return d->mNoteType; |
|
426 } |
|
427 |
|
428 |
|
429 void HbProgressNote::showEvent(QShowEvent *event) |
|
430 { |
|
431 Q_D(HbProgressNote); |
|
432 d->mContentWidget->mPb->show(); |
|
433 HbDialog::showEvent(event); |
|
434 } |
|
435 |
|
436 /*! |
|
437 Shows the Note after a delay(say 1sec). This is a convenient slot |
|
438 if user cancels note before delay expired note wont be shown at all |
|
439 */ |
|
440 void HbProgressNote::delayedShow() |
|
441 { |
|
442 Q_D(HbProgressNote); |
|
443 d->flags |= HbProgressNotePrivate::Showtimer; |
|
444 d->mTimer->setDuration(d->mDelayTime); |
|
445 d->mTimer->start(); |
|
446 } |
|
447 |
|
448 bool HbProgressNote::autoClose () const |
|
449 { |
|
450 Q_D(const HbProgressNote); |
|
451 return d->flags.testFlag(HbProgressNotePrivate::Autoclose); |
|
452 } |
|
453 |
|
454 void HbProgressNote::setAutoClose ( bool b ) |
|
455 { |
|
456 Q_D(HbProgressNote); |
|
457 b?d->flags |
|
458 |= HbProgressNotePrivate::Autoclose : d->flags &= ~HbProgressNotePrivate::Autoclose; |
|
459 } |
|
460 |
|
461 void HbProgressNote::initStyleOption(HbStyleOption *option) const |
|
462 { |
|
463 Q_D(const HbProgressNote); |
|
464 HbStyleOptionProgressDialog* progressNoteOption |
|
465 = qstyleoption_cast< HbStyleOptionProgressDialog *>(option); |
|
466 |
|
467 HbDialog::initStyleOption(progressNoteOption); |
|
468 progressNoteOption->progressBarSize = d->mContentWidget->mPb->minimumSize(); |
|
469 progressNoteOption->icon = d->mIcon; |
|
470 progressNoteOption->iconAlignment = d->mIconAlignment; |
|
471 } |
|
472 void HbProgressNote::closeEvent ( QCloseEvent * event ) |
|
473 { |
|
474 Q_D(HbProgressNote); |
|
475 d->mAction->setToolTip(""); |
|
476 if(d->flags.testFlag(HbProgressNotePrivate::Closetimer)){ |
|
477 d->flags |= HbProgressNotePrivate::Closepending; |
|
478 event->setAccepted(false); |
|
479 return; |
|
480 } |
|
481 if(d->flags.testFlag(HbProgressNotePrivate::Showtimer)){ |
|
482 d->mTimer->stop(); |
|
483 d->flags &= ~HbProgressNotePrivate::Showtimer; |
|
484 } |
|
485 d->mContentWidget->mPb->close(); |
|
486 HbDialog::closeEvent(event); |
|
487 |
|
488 } |
|
489 |
|
490 /*! |
|
491 Sets text of the note. |
|
492 \sa text() |
|
493 */ |
|
494 void HbProgressNote::setText(const QString &text) |
|
495 { |
|
496 Q_D(HbProgressNote); |
|
497 if ( text != d->mContentWidget->mText->plainText() ) { |
|
498 d->mContentWidget->mText->setPlainText(text); |
|
499 } |
|
500 } |
|
501 /*! |
|
502 Returns text of the note. |
|
503 \sa setText() |
|
504 */ |
|
505 QString HbProgressNote::text() const |
|
506 { |
|
507 Q_D(const HbProgressNote); |
|
508 return d->mContentWidget->mText->plainText(); |
|
509 } |
|
510 |
|
511 |
|
512 /*! |
|
513 Sets icon for the note. |
|
514 \sa icon() |
|
515 */ |
|
516 void HbProgressNote::setIcon(const HbIcon &icon) |
|
517 { |
|
518 Q_D(HbProgressNote); |
|
519 if (icon != d->mIcon){ |
|
520 d->mIcon = icon; |
|
521 if (d->mContentWidget->mIconItem) { |
|
522 HbStyleOptionProgressDialog progressNoteOption; |
|
523 initStyleOption(&progressNoteOption); |
|
524 style()->updatePrimitive(d->mContentWidget->mIconItem, HbStyle::P_ProgressDialog_icon, &progressNoteOption); |
|
525 } |
|
526 } |
|
527 } |
|
528 |
|
529 |
|
530 /*! |
|
531 Returns icon of the note. |
|
532 \sa setIcon() |
|
533 */ |
|
534 HbIcon HbProgressNote::icon() const |
|
535 { |
|
536 Q_D(const HbProgressNote); |
|
537 return d->mIcon; |
|
538 } |
|
539 |
|
540 |
|
541 /*! |
|
542 Sets the text alignment. |
|
543 \param align Qt defined alignment options can used. |
|
544 |
|
545 The default value is Qt::AlignLeft|Qt::AlignVCenter |
|
546 |
|
547 \sa mTextAlignment() |
|
548 */ |
|
549 void HbProgressNote::setTextAlignment( Qt::Alignment align ) |
|
550 { |
|
551 Q_D(HbProgressNote); |
|
552 |
|
553 if (align != d->mContentWidget->mText->alignment()) { |
|
554 d->mContentWidget->mText->setAlignment(align); |
|
555 |
|
556 } |
|
557 } |
|
558 |
|
559 |
|
560 /*! |
|
561 Returns the text alignment. |
|
562 |
|
563 \sa setTextAlignment() |
|
564 */ |
|
565 Qt::Alignment HbProgressNote::textAlignment() const |
|
566 { |
|
567 Q_D(const HbProgressNote); |
|
568 return d->mContentWidget->mText->alignment(); |
|
569 } |
|
570 |
|
571 |
|
572 /*! |
|
573 Sets the icon alignment. |
|
574 |
|
575 \param align Qt defined alignment options can used. |
|
576 |
|
577 The default value is Qt::AlignCenter. |
|
578 |
|
579 \sa mIconAlignment() |
|
580 */ |
|
581 void HbProgressNote::setIconAlignment( Qt::Alignment align ) |
|
582 { |
|
583 Q_D(HbProgressNote); |
|
584 if (align != d->mIconAlignment){ |
|
585 d->mIconAlignment = align; |
|
586 if (d->mContentWidget->mIconItem) { |
|
587 HbStyleOptionProgressDialog progressNoteOption; |
|
588 initStyleOption(&progressNoteOption); |
|
589 style()->updatePrimitive(d->mContentWidget->mIconItem, HbStyle::P_ProgressDialog_icon, &progressNoteOption); |
|
590 } |
|
591 } |
|
592 } |
|
593 |
|
594 |
|
595 /*! |
|
596 Returns the icon alignment. |
|
597 |
|
598 \sa setIconAlignment() |
|
599 */ |
|
600 Qt::Alignment HbProgressNote::iconAlignment() const |
|
601 { |
|
602 Q_D(const HbProgressNote); |
|
603 return d->mIconAlignment; |
|
604 } |
|
605 |
|
606 |
|
607 /*! |
|
608 Sets the text wrapping. |
|
609 \param wrap When set, the text is drawn with Qt::TextWordWrap enabled |
|
610 meaning that lines breaks are at appropriate point, |
|
611 e.g. at word boundaries. |
|
612 |
|
613 The default value is true; |
|
614 |
|
615 \sa textWrapping() |
|
616 */ |
|
617 void HbProgressNote::setTextWrapping(bool wrap) |
|
618 { |
|
619 Q_D(HbProgressNote); |
|
620 if (wrap != d->mTextWrapping){ |
|
621 d->mTextWrapping = wrap; |
|
622 if(wrap) { |
|
623 d->mContentWidget->mText->setTextWrapping(Hb::TextWordWrap); |
|
624 } |
|
625 else{ |
|
626 d->mContentWidget->mText->setTextWrapping(Hb::TextNoWrap); |
|
627 } |
|
628 } |
|
629 } |
|
630 |
|
631 /*! |
|
632 Returns the text wrapping setting. |
|
633 |
|
634 \sa setTextWrapping() |
|
635 */ |
|
636 bool HbProgressNote::textWrapping() const |
|
637 { |
|
638 Q_D(const HbProgressNote); |
|
639 return d->mTextWrapping; |
|
640 } |
|
641 |
|
642 |
|
643 #include "moc_hbprogressnote.cpp" |
|
644 #include "hbprogressnote.moc" |
|
645 |