FCL/sf/mw/hb: comparison src/hbwidgets/widgets/hblabel.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include "hbcolorscheme.h"
 #include "hbwidget_p.h"
 #include "hbstyleoptionlabel_p.h"
 #include "hbwidgetbase.h"
 #include "hblabel.h"
+#include "hbstyle_p.h"
+#include "hbstyletextprimitivedata.h"
+#include "hbstylerichtextprimitivedata.h"
+#include "hbstyleiconprimitivedata.h"
 /*!
 @alpha
 @hbcore
 class HbLabelPrivate: public HbWidgetPrivate {
 Q_DECLARE_PUBLIC(HbLabel)
 public:
-HbLabelPrivate ();
+HbLabelPrivate();
-~HbLabelPrivate ();
+~HbLabelPrivate();
+void init();
+void clear();
 void clearAll();
-void setText(const QString &text, HbStyle::Primitive primitiveId);
+void setText(const QString &text, HbStyle::PrimitiveType primitiveId);
 void setIcon(const HbIcon &icon);
 void updatePrimitives ();
 void createPrimitives ();
 //shared between icon and text
-Qt::Alignment mAlignment;
+HbStyleValue<Qt::Alignment> mAlignment;
 // text section
-QString mText;
+HbStyleValue<QString> mText;
-Qt::TextElideMode mElideMode;
+HbStyleValue<Qt::TextElideMode> mElideMode;
-Hb::TextWrapping mTextWrapping;
+HbStyleValue<Hb::TextWrapping> mTextWrapping;
-QColor mColor;
+HbStyleValue<QColor> mColor;
+HbStyleValue<int> mMaxLines;
 // icon section
-HbIcon mIcon;
+HbStyleValue<HbIcon> mIcon;
-Qt::AspectRatioMode mAspectRatioMode;
+HbStyleValue<Qt::AspectRatioMode> mAspectRatioMode;
 // primitive handling
-QGraphicsItem *mPrimitiveItem;
+QGraphicsObject *mPrimitiveItem;
-HbStyle::Primitive mActivePrimitive;
+HbStyle::PrimitiveType mActivePrimitive;
 };
 HbLabelPrivate::HbLabelPrivate() :
 HbWidgetPrivate(),
-mAlignment(Qt::AlignLeft | Qt::AlignVCenter),
-mText(QString()),
-mElideMode(Qt::ElideRight),
-mTextWrapping(Hb::TextNoWrap),
-mAspectRatioMode(Qt::KeepAspectRatio),
 mPrimitiveItem(0),
-mActivePrimitive(HbStyle::P_None)
+mActivePrimitive(HbStyle::PT_None)
 {
 }
+void HbLabelPrivate::init()
+{
+Q_Q(HbLabel);
+q->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
+}
+void HbLabelPrivate::clear()
+{
+// no implementation needed
+}
 void HbLabelPrivate::clearAll()
 {
 if (mPrimitiveItem) {
 delete mPrimitiveItem;
 mPrimitiveItem = 0;
-mActivePrimitive = HbStyle::P_None;
+mActivePrimitive = HbStyle::PT_None;
 }
 mText.clear();
 mIcon.clear();
 }
-void HbLabelPrivate::setText(const QString &text, HbStyle::Primitive primitiveId)
+void HbLabelPrivate::setText(const QString &text, HbStyle::PrimitiveType primitiveId)
 {
 Q_Q(HbLabel);
 if (text.isNull()) {
 clearAll();
 if (mActivePrimitive != primitiveId) {
 clearAll();
 }
-if (mText != text || mText.isNull()) {
+if (mText!=text) {
 mText = text;
 if (mActivePrimitive != primitiveId) {
 mActivePrimitive = primitiveId;
 createPrimitives();
 q->repolish(); // reconecting new primitive to HbAnchorLayout so it is really needed!
 if (icon.isNull()) {
 clearAll();
 return;
 }
-if (mActivePrimitive != HbStyle::P_Label_icon) {
+if (mActivePrimitive != HbStyle::PT_IconItem) {
 clearAll();
 }
 if (mIcon != icon) {
 mIcon = icon;
-if (mActivePrimitive != HbStyle::P_Label_icon) {
+if (mActivePrimitive != HbStyle::PT_IconItem) {
-mActivePrimitive = HbStyle::P_Label_icon;
+mActivePrimitive = HbStyle::PT_IconItem;
 createPrimitives();
 q->repolish(); // reconecting new primitive to HbAnchorLayout so it is really needed!
 }
 q->updatePrimitives();
 }
 {
 Q_Q(HbLabel);
 Q_ASSERT(mPrimitiveItem==0);
-if (mActivePrimitive != HbStyle::P_None) {
+switch (mActivePrimitive) {
-mPrimitiveItem = q->style()->createPrimitive(mActivePrimitive, q);
+case HbStyle::PT_None:
+break;
+case HbStyle::PT_IconItem:
+mPrimitiveItem = q->style()->createPrimitive(mActivePrimitive, QString("icon"),q);
+break;
+case HbStyle::PT_TextItem: // no break
+case HbStyle::PT_RichTextItem:
+mPrimitiveItem = q->style()->createPrimitive(mActivePrimitive, QString("text"),q);
+break;
+default:
+Q_ASSERT(0);
 }
 }
 void HbLabelPrivate::updatePrimitives()
 {
 Q_Q(HbLabel);
-if (mActivePrimitive != HbStyle::P_None) {
+if (mActivePrimitive != HbStyle::PT_None) {
-Q_ASSERT(mActivePrimitive == HbStyle::P_Label_icon
+Q_ASSERT(mActivePrimitive == HbStyle::PT_IconItem
-|| mActivePrimitive == HbStyle::P_Label_richtext
+|| mActivePrimitive == HbStyle::PT_RichTextItem
-|| mActivePrimitive == HbStyle::P_Label_text);
+|| mActivePrimitive == HbStyle::PT_TextItem);
-HbStyleOptionLabel option;
+switch (mActivePrimitive) {
-q->initStyleOption(&option);
+case HbStyle::PT_IconItem: {
-q->style()->updatePrimitive(mPrimitiveItem, mActivePrimitive, &option);
+HbStyleIconPrimitiveData data;
+// set common data:
+data.alignment = mAlignment;
+// set icon data:
+data.aspectRatioMode = mAspectRatioMode;
+data.icon = mIcon;
+q->style()->updatePrimitive(mPrimitiveItem,
+&data);
+}
+break;
+case HbStyle::PT_TextItem: {
+HbStyleTextPrimitiveData data;
+// set common data:
+data.alignment = mAlignment;
+// set text common data:
+data.text = mText;
+data.textColor = mColor;
+data.textWrapping = mTextWrapping;
+// plain text specyfic:
+data.elideMode = mElideMode;
+data.maximumLines = mMaxLines;
+q->style()->updatePrimitive(mPrimitiveItem,
+&data);
+}
+break;
+case HbStyle::PT_RichTextItem: {
+HbStyleRichTextPrimitiveData data;
+// set common data:
+data.alignment = mAlignment;
+// set text common data:
+data.text = mText;
+data.defaultColor = mColor;
+data.textWrappingMode = mTextWrapping;
+q->style()->updatePrimitive(mPrimitiveItem,
+&data);
+}
+break;
+case 0: {
+}
+break;
+default:
+Q_ASSERT(0);
+}
 }
 }
 /*!
 Constructs the label with a given \a parent.
 \param parent - the parent graphics item.
 */
 HbLabel::HbLabel(QGraphicsItem *parent) :
 HbWidget(*new HbLabelPrivate, parent)
 {
-setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
+Q_D(HbLabel);
+d->init();
 }
 /*!
 \internal
 */
 HbLabel::HbLabel(HbLabelPrivate &dd, QGraphicsItem * parent) :
 HbWidget(dd, parent)
 {
-setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
+Q_D(HbLabel);
+d->init();
 }
 /*!
 Constructs the label with a given \a text and \a parent. This constructor is a convenience for
 common use case to have a label with plain text content. Using this contructor you do not need
 /*!
 Label destructor.
 */
 HbLabel::~HbLabel ()
 {
+Q_D(HbLabel);
+d->clear();
 }
 /*!
 Sets the label contents to plain text containing the textual
 representation of integer \a num. Any previous content is cleared.
 void HbLabel::setElideMode (Qt::TextElideMode elideMode)
 {
 Q_D(HbLabel);
 if (elideMode != d->mElideMode) {
 d->mElideMode = elideMode;
-if (!d->mText.isNull()) {
+if (d->mText.isSet()) {
 updatePrimitives();
 }
 }
 }
 /*!
-Default elide mode is Qt::ElideRight.
+By default this method returns invalid value to indicate that
+eliding is controlled by CSS (setElideMode was not used).
+In CSS elide by default is set to Qt::ElideRight.
 \return the elide mode of the text.
 \sa HbLabel::setElideMode()
 */
 Qt::TextElideMode HbLabel::elideMode() const
 {
 Q_D(const HbLabel);
-return d->mElideMode;
+if (d->mElideMode.isSet()) {
+return d->mElideMode;
+} else {
+return (Qt::TextElideMode)-1;
+}
 }
 /*!
 Sets the text wrapping mode to \a mode.
 \param mode - wrapping mode
 void HbLabel::setTextWrapping(Hb::TextWrapping mode)
 {
 Q_D(HbLabel);
 if (d->mTextWrapping != mode) {
 d->mTextWrapping = mode;
-if (!d->mText.isNull()) {
+if (d->mText.isSet()) {
 updatePrimitives();
 }
 }
 }
 /*!
 \return the label's current text wrapping mode.
-Default value is NoWrap.
+Default value is Hb::TextNoWrap.
 \sa setTextWrapping()
 */
 Hb::TextWrapping HbLabel::textWrapping() const
 {
 Q_D(const HbLabel);
-return d->mTextWrapping;
+if (d->mTextWrapping.isSet()) {
+return d->mTextWrapping;
+} else {
+return Hb::TextNoWrap;
+}
 }
 /*!
 Sets the icon displayed by this label.
 Removes any existing text from the label.
 \sa setIcon
 */
 HbIcon HbLabel::icon() const
 {
 Q_D(const HbLabel);
-return d->mIcon;
+if (d->mIcon.isSet()) {
+return d->mIcon;
+} else {
+return HbIcon();
+}
 }
 /*!
 Clears the content of the label. After this the label is empty.
 void HbLabel::setAspectRatioMode(Qt::AspectRatioMode aspectRatioMode)
 {
 Q_D(HbLabel);
 if (d->mAspectRatioMode != aspectRatioMode) {
 d->mAspectRatioMode = aspectRatioMode;
-if (!d->mIcon.isNull()) {
+if (d->mIcon.isSet()) {
 updatePrimitives();
 }
 }
 }
 \sa setAspectRatio()
 */
 Qt::AspectRatioMode HbLabel::aspectRatioMode() const
 {
 Q_D(const HbLabel);
-return d->mAspectRatioMode;
+if (d->mAspectRatioMode.isSet()) {
+return d->mAspectRatioMode;
+} else {
+return Qt::KeepAspectRatio;
+}
 }
 /*!
 Sets the label contents to plain text containing \a text. Any previous content is cleared.
 Does nothing if the string representation is the same as the current contents of the label.
 \sa setIcon()
 */
 void HbLabel::setPlainText(const QString &text)
 {
 Q_D(HbLabel);
-d->setText(text, HbStyle::P_Label_text);
+d->setText(text, HbStyle::PT_TextItem);
 }
 /*!
 Sets the label contents to html text containing \a text. Any previous content is cleared.
 Does nothing if the string representation is the same as the current contents of the label.
 \sa setIcon()
 */
 void HbLabel::setHtml(const QString &text)
 {
 Q_D(HbLabel);
-d->setText(text, HbStyle::P_Label_richtext);
+d->setText(text, HbStyle::PT_RichTextItem);
 }
 /*!
 Sets the \a alignment of the label.
 \param alignment - the new alignment.
 void HbLabel::setAlignment(Qt::Alignment alignment)
 {
 Q_D(HbLabel);
 if (d->mAlignment != alignment) {
 d->mAlignment = alignment;
-if (d->mActivePrimitive!=HbStyle::P_None) {
+if (alignment == 0) {
+d->mAlignment.clear();
+}
+if (d->mActivePrimitive!=HbStyle::PT_None) {
 updatePrimitives();
 }
 }
 }
 /*!
-\return the alignment. Default alignment is 'Qt::AlignLeft | Qt::AlignVCenter'
+\return the alignment. Default alignment is '0' indicating that nothing was
+set (so CSS cotrols alignment).
 \sa HbLabel::setAlignment()
 */
 Qt::Alignment HbLabel::alignment() const
 {
 Q_D(const HbLabel);
-return d->mAlignment;
+if (d->mAlignment.isSet()) {
+return d->mAlignment;
+} else {
+return 0;
+}
 }
 /*!
 \return true if both text and icon are empty; otherwise returns false.
 \sa clear()
 */
 bool HbLabel::isEmpty() const
 {
 Q_D(const HbLabel);
-return d->mActivePrimitive == HbStyle::P_None;
+return d->mActivePrimitive == HbStyle::PT_None;
 }
 /*!
 \deprecated HbLabel::primitive(HbStyle::Primitive)
 is deprecated.
 Returns a pointer to the QGraphicsItem primitive used by this label.
 \param primitive - the type of graphics primitive required.
-HbLabel supports HbStyle::P_Label_text and HbStyle::P_Label_icon.
+HbLabel supports HbStyle::PT_TextItem and HbStyle::PT_IconItem.
 \return the QGraphicsItem used by the label. It is 0 if type \a primitive not currently in use.
 It is also 0 if the text or icon object is empty.
 \reimp
 \sa isEmpty()
 */
 QGraphicsItem * HbLabel::primitive(HbStyle::Primitive primitive) const
 {
 Q_D(const HbLabel);
-if (primitive == d->mActivePrimitive) {
+switch ((HbStylePrivate::Primitive)primitive) {
+case HbStylePrivate::P_Label_icon:
+if (d->mActivePrimitive != HbStyle::PT_IconItem) {
+break;
+}
 return d->mPrimitiveItem;
-}
-return HbWidget::primitive(primitive);
+case HbStylePrivate::P_Label_text:
+if (d->mActivePrimitive != HbStyle::PT_TextItem) {
+break;
+}
+return d->mPrimitiveItem;
+case HbStylePrivate::P_Label_richtext:
+if (d->mActivePrimitive != HbStyle::PT_RichTextItem) {
+break;
+}
+return d->mPrimitiveItem;
+default:
+return HbWidget::primitive(primitive);
+}
+return 0;
 }
 /*!
 Initializes \a option with the values from this HbLabel.
 HbStyleOptionLabel is used by HbStyle to perform changes in appearance
 HbWidget::initStyleOption(option);
 option->alignment = d->mAlignment;
-if (!d->mText.isNull()) {
+if (d->mText.isSet()) {
 option->text = d->mText;
 option->elideMode = d->mElideMode;
 option->textWrapMode = d->mTextWrapping;
 option->color = d->mColor;
-}
+option->maximumLines = d->mMaxLines;
+}
-if (!d->mIcon.isNull()) {
+if (d->mIcon.isSet()) {
 option->icon = d->mIcon;
 option->aspectRatioMode = d->mAspectRatioMode;
 }
 }
 QSizeF HbLabel::sizeHint ( Qt::SizeHint which, const QSizeF & constraint ) const
 {
-if (isEmpty()) {
+if (isEmpty() && which!=Qt::MaximumSize) {
 return QSizeF(0,0);
 }
 return HbWidget::sizeHint(which,constraint);
 }
 Plain text accessor. Returns empty string if not set.
 */
 QString HbLabel::plainText() const
 {
 Q_D(const HbLabel);
-if (d->mActivePrimitive == HbStyle::P_Label_text) {
+if (d->mActivePrimitive == HbStyle::PT_TextItem) {
 return d->mText;
 }
 return QString();
 }
 Rich text text accessor. Returns empty string if not set.
 */
 QString HbLabel::html() const
 {
 Q_D(const HbLabel);
-if (d->mActivePrimitive == HbStyle::P_Label_richtext) {
+if (d->mActivePrimitive == HbStyle::PT_RichTextItem) {
 return d->mText;
 }
 return QString();
 }
 void HbLabel::setTextColor( const QColor &textColor )
 {
 Q_D(HbLabel);
 if (d->mColor!=textColor) {
 d->mColor=textColor;
-if (!d->mText.isNull()) {
+if (d->mText.isSet()) {
 updatePrimitives();
 }
 }
 }
 Returns color of text or invalid value if theme color is used.
 */
 QColor HbLabel::textColor() const
 {
 Q_D(const HbLabel);
-return d->mColor;
+if (d->mColor.isSet()) {
+return d->mColor;
+} else {
+return QColor();
+}
+}
+/*!
+If plain text is used (\sa setPlainText) this will set maximum number of lines
+to be visible in label.
+Zero or negative value disables the feature.
+\sa maximumLines()
+*/
+void HbLabel::setMaximumLines(int maxLines)
+{
+Q_D(HbLabel);
+maxLines = qMax(maxLines, 0);
+if (d->mMaxLines != maxLines) {
+d->mMaxLines = maxLines;
+if (d->mActivePrimitive == HbStyle::PT_TextItem) {
+updatePrimitives();
+}
+}
+}
+/*!
+Returns maximum number of lines which can be visible in label when
+plain text is used (\sa setPlainText).
+Zero value means that there is no limitation.
+\sa setMaximumLines(int)
+*/
+int HbLabel::maximumLines() const
+{
+Q_D(const HbLabel);
+if (d->mMaxLines.isSet()) {
+return d->mMaxLines;
+} else {
+return 0;
+}
 }
 #include "moc_hblabel.cpp"

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9