FCL/sf/mw/hb: comparison src/hbcore/primitives/hbrichtextitem.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include <QTextBlock>
 #include <QTextLayout>
 #include <QPainter>
 #include <QAbstractTextDocumentLayout>
 #include <QApplication>
+#include <QWidget>
-const int KMinimumLetersToShow = 4;
+#include <QStyleOptionGraphicsItem>
+const qreal KMinimumRichTextWidth = 6.0;
 static const QString KDefaultColorThemeName = "qtc_view_normal";
 HbRichTextItemPrivate::HbRichTextItemPrivate() :
-mAlignment(Qt::AlignLeft|Qt::AlignVCenter),
+mTextOption(Qt::AlignLeft|Qt::AlignVCenter),
-mTextOption(mAlignment),
+mRtf(0)
-mDontPrint(false),
-mDontClip(false),
-mRtf(0)
 {
 }
 HbRichTextItemPrivate::~HbRichTextItemPrivate()
 {
 */
 void HbRichTextItemPrivate::init()
 {
 Q_Q(HbRichTextItem);
-q->setFlag(QGraphicsItem::ItemClipsToShape, !mDontClip);
+q->setFlag(QGraphicsItem::ItemClipsToShape, true);
 q->setFlag(QGraphicsItem::ItemIsSelectable, false);
 q->setFlag(QGraphicsItem::ItemIsFocusable,  false);
 mRtf = new QTextDocument(q);
 mRtf->setDocumentMargin(0.0); // no margins needed
 mRtf->setDefaultFont(q->font());
 }
 void HbRichTextItemPrivate::clear()
 {
-delete mRtf;
+}
-}
+void HbRichTextItemPrivate::setDocumentWidth(qreal newWidth)
-int HbRichTextItemPrivate::textFlagsFromTextOption() const
+{
-{
+if (!qFuzzyCompare(mRtf->textWidth(), newWidth)) {
-int flags = (int)mAlignment;
+mRtf->setTextWidth(newWidth);
-switch(mTextOption.wrapMode()) {
-case QTextOption::NoWrap:
-flags |= Qt::TextSingleLine;
-break;
-case QTextOption::WordWrap:
-flags |=Qt::TextWordWrap;
-break;
-case QTextOption::ManualWrap:
-break;
-case QTextOption::WrapAnywhere:
-flags |=Qt::TextWrapAnywhere;
-break;
-case QTextOption::WrapAtWordBoundaryOrAnywhere:
-flags |=Qt::TextWordWrap | Qt::TextWrapAnywhere;
-break;
-}
-if(mDontClip)  flags |= Qt::TextDontClip;
-if(mDontPrint) flags |= Qt::TextDontPrint;
-return flags;
-}
-bool HbRichTextItemPrivate::setLayoutDirection(Qt::LayoutDirection newDirection)
-{
-Qt::Alignment oldAlign = mTextOption.alignment();
-Qt::Alignment alignment = QStyle::visualAlignment(newDirection, mAlignment);
-mTextOption.setAlignment(alignment);
-mTextOption.setTextDirection(newDirection);
-mRtf->setDefaultTextOption(mTextOption);
-return alignment!=oldAlign;
-}
-void HbRichTextItemPrivate::setSize(const QSizeF &newSize)
-{
-if(mRtf->size()!=newSize) {
-Q_Q(HbRichTextItem);
-mRtf->setTextWidth(newSize.width());
 calculateOffset();
-q->update();
 }
 }
 // #define HB_RICH_TEXT_ITEM_ALWAS_SHOW_FIRST_LINE
 void HbRichTextItemPrivate::calculateOffset()
 {
 Q_Q(HbRichTextItem);
 qreal diff;
-if(mAlignment.testFlag(Qt::AlignTop)) {
+Qt::Alignment align = mTextOption.alignment();
+if (align.testFlag(Qt::AlignTop)) {
 diff = 0.0;
 } else {
 diff = q->geometry().height() - mRtf->size().height();
-if(!mAlignment.testFlag(Qt::AlignBottom)) {
+if (!align.testFlag(Qt::AlignBottom)) {
 // default align Qt::AlignVCenter if no flags are set
 diff*=0.5;
 }
 }
 #ifdef HB_RICH_TEXT_ITEM_ALWAS_SHOW_FIRST_LINE
 diff = qMax(diff, (qreal)0.0);
 #endif
-if(diff!=mOffset.y()) {
+if (diff!=mOffset.y()) {
 mOffset.setY(diff);
 q->prepareGeometryChange();
 }
+}
+QSizeF HbRichTextItemPrivate::minimumSizeHint(const QSizeF &/*constraint*/) const
+{
+QSizeF result(KMinimumRichTextWidth, 0);
+QTextBlock textBlock = mRtf->begin();
+if (textBlock.isValid() && textBlock.layout()->lineCount() > 0) {
+QTextLine line = textBlock.layout()->lineAt(0);
+result.setHeight(line.height());
+} else {
+QFontMetricsF metrics(mRtf->defaultFont());
+result.setHeight(metrics.height());
+}
+qreal doubleDocMargin = mRtf->documentMargin() * (qreal)2.0;
+result.rheight() += doubleDocMargin;
+result.rwidth() += doubleDocMargin;
+return result;
+}
+void HbRichTextItemPrivate::clearPrefSizeCache()
+{
+mPrefSize.setWidth(-1);
+mMinWidthForAdjust = QWIDGETSIZE_MAX;
+mMaxWidthForAdjust = -1;
+}
+QSizeF HbRichTextItemPrivate::preferredSizeHint(const QSizeF &constraint) const
+{
+if (mPrefSizeConstraint==constraint && mPrefSize.isValid()) {
+return mPrefSize;
+}
+mPrefSizeConstraint=constraint;
+QSizeF result;
+if (constraint.width()<=0) {
+mRtf->setTextWidth(QWIDGETSIZE_MAX);
+} else {
+QTextOption::WrapMode wrapMode = mTextOption.wrapMode();
+// optimization when there is no automatic wrap there is no reason
+// to setTextWidth with width constraint (width measure is not needed)
+if (wrapMode!=QTextOption::NoWrap
+&& wrapMode!=QTextOption::ManualWrap) {
+mRtf->setTextWidth(constraint.width());
+}
+}
+result = mRtf->size();
+mMaxWidthForAdjust = result.width();
+result.setWidth(mRtf->idealWidth());
+mMinWidthForAdjust = result.width();
+mDefaultPrefHeight = result.height();
+mPrefSize = result;
+return result;
+}
+bool HbRichTextItemPrivate::isAdjustHeightNeeded(qreal newWidth,
+qreal prefHeight,
+qreal minHeight,
+qreal maxHeight)
+{
+// first check if wrapping of text is not active
+QTextOption::WrapMode wrapMode = mTextOption.wrapMode();
+if (wrapMode==QTextOption::NoWrap
+|| wrapMode==QTextOption::ManualWrap) {
+return false;
+}
+// preferred height was set from outside of this class so there is mo reason to adjust it
+if (mPrefSizeConstraint.height()>0) {
+return false;
+}
+// check if adjusted size has been already calculated
+// new width is bigger than last estimated range of same height
+if ((mMaxWidthForAdjust>=newWidth
+// new width is smaller than last estimated range of same height
+&& newWidth>=mMinWidthForAdjust)) {
+return false;
+}
+if (!mPrefSize.isValid()) {
+// this means that preferred size is set outside of class by setPreferredSize
+// so sizeHint(Qt::Preferredsize) was not called and size adjustment is useless
+return false;
+}
+// new text width was set in setGeometry here it is not needed
+Q_ASSERT_X(qFuzzyCompare(mRtf->textWidth(), newWidth),
+"HbRichTextItemPrivate::isAdjustHeightNeeded",
+QString("mRtf->textWidth()=%1, newWidth=%2")
+.arg(mRtf->textWidth())
+.arg(newWidth).toAscii().data());
+// if preconditions are met test if current height is enough
+QSizeF newAdjust = mRtf->size();
+if (qFuzzyCompare(newAdjust.height(), mPrefSize.height())) {
+// height is same as last time update range of same height
+mMaxWidthForAdjust = qMax(mMaxWidthForAdjust, newWidth);
+mMinWidthForAdjust = qMin(mMinWidthForAdjust, newWidth);
+return false;
+}
+// new height was calculated create new range for which
+// current mPrefSize.height is valid
+mMaxWidthForAdjust = newWidth;
+mMinWidthForAdjust = mRtf->idealWidth();
+// store new height, don't change width
+mPrefSize.setHeight(newAdjust.height());
+Q_ASSERT_X(mPrefSizeConstraint.width()>0 || mPrefSize.width()>=mMinWidthForAdjust,
+"HbRichTextItemPrivate::isAdjustHeightNeeded",
+QString("Fail for (%1<%2) string: \"%3\"")
+.arg(mPrefSize.width())
+.arg(mMinWidthForAdjust)
+.arg(mText).toAscii().data());
+if (qFuzzyCompare(qBound(minHeight, mPrefSize.height(), maxHeight),
+prefHeight)) {
+// updateGeometry has no effect
+return false;
+}
+// all conditions for calling updateGeometry are meet
+return true;
+}
+/*
+returns true if updateGeometry is needed
+*/
+bool HbRichTextItemPrivate::restoreDefaultHeightHint()
+{
+if (mPrefSizeConstraint.height()>0) {
+return false;
+}
+if (mPrefSizeConstraint.width()>0) {
+clearPrefSizeCache();
+return true;
+}
+if (mPrefSize.height()==mDefaultPrefHeight) {
+return true;
+}
+mPrefSize.setHeight(mDefaultPrefHeight);
+mMinWidthForAdjust = mPrefSize.width();
+mMaxWidthForAdjust = QWIDGETSIZE_MAX;
+return true;
 }
 /*!
 @proto
 @hbcore
 /*!
 Constructor for the class.
 */
 HbRichTextItem::HbRichTextItem(QGraphicsItem *parent) :
 HbWidgetBase(*new HbRichTextItemPrivate, parent)
 {
 Q_D(HbRichTextItem);
 d->init();
 }
 /*!
 Constructor which set content using \a html format.
 */
 HbRichTextItem::HbRichTextItem(const QString &html, QGraphicsItem *parent) :
 HbWidgetBase(*new HbRichTextItemPrivate, parent)
 {
 Q_D(HbRichTextItem);
 d->init();
 setText(html);
 }
 /*
 Constructor for internal use only
 */
 HbRichTextItem::HbRichTextItem(HbRichTextItemPrivate &dd, QGraphicsItem *parent) :
 HbWidgetBase(dd, parent)
 {
 Q_D(HbRichTextItem);
 d->init();
 }
 {
 Q_D(HbRichTextItem);
 if (d->mText != text) {
 d->mText = text;
 d->mRtf->setHtml(text);
+d->clearPrefSizeCache();
+update();
 updateGeometry();
 }
 }
 /*!
 \sa HbRichTextItem::setText()
 */
 QString HbRichTextItem::text() const
 {
-Q_D( const HbRichTextItem );
+Q_D(const HbRichTextItem);
 return d->mText;
 }
 /*!
 Sets \a alignment for the text from Qt::Alignment enumeration.
 \sa HbRichTextItem::alignment()
 */
 void HbRichTextItem::setAlignment(Qt::Alignment alignment)
 {
-Q_D( HbRichTextItem );
+Q_D(HbRichTextItem);
-	d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, true);
+d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextAlign, true);
-alignment &= Qt::AlignVertical_Mask | Qt::AlignHorizontal_Mask;
+alignment = d->combineAlignment(alignment, d->mTextOption.alignment());
-if( d->mAlignment!=alignment ) {
+if (d->mTextOption.alignment()!=alignment) {
 prepareGeometryChange();
-d->mAlignment = alignment;
+d->mTextOption.setAlignment(alignment);
+d->mRtf->setDefaultTextOption(d->mTextOption);
 d->calculateOffset();
-if(d->setLayoutDirection(layoutDirection())) {
+update();
-update();
-}
 }
 }
 /*!
 Returns alignment for the text from Qt::Alignment enumeration.
 \sa HbRichTextItem::setAlignment()
 */
 Qt::Alignment HbRichTextItem::alignment() const
 {
-Q_D( const HbRichTextItem );
+Q_D(const HbRichTextItem);
-return d->mAlignment;
+return d->mTextOption.alignment();
 }
 /*!
 \reimp
 */
 void HbRichTextItem::paint(QPainter *painter,
 const QStyleOptionGraphicsItem *option,
 QWidget *widget)
 {
-Q_UNUSED(option);
 Q_UNUSED(widget);
 Q_D(HbRichTextItem);
-// Save painter's state
+if (option->exposedRect.isEmpty()) {
-QRegion oldClipRegion = painter->clipRegion();
+// nothing to paint
-QTransform oldTransform = painter->transform();
+return;
+}
-if(!d->mDontPrint) {
-if(!d->mDontClip) {
+painter->translate(d->mOffset);
-painter->setClipRect(contentsRect(), Qt::IntersectClip);
-}
+QAbstractTextDocumentLayout::PaintContext context;
-painter->translate(d->mOffset);
+context.clip = option->exposedRect;
-QAbstractTextDocumentLayout::PaintContext context;
+// painter was translated so it should be compensated
-context.palette.setColor(QPalette::Text, textDefaultColor());
+context.clip.translate(-d->mOffset);
-d->mRtf->documentLayout()->draw(painter, context);
-}
+context.palette.setColor(QPalette::Text, textDefaultColor());
-// Restore painter's state
+d->mRtf->documentLayout()->draw(painter, context);
-painter->setClipRegion(oldClipRegion);
-painter->setTransform(oldTransform);
+// restore painter
+painter->translate(-d->mOffset);
 }
 /*!
 \reimp
 {
 Q_D(HbRichTextItem);
 HbWidgetBase::setGeometry(rect);
-if(rect.isValid()) {
+// this call is needed since there is possible scenario
-d->setSize(rect.size());
+// when size was not changed after updateGeometry and sizeHint calls
+d->setDocumentWidth(size().width());
+if (parentLayoutItem() && parentLayoutItem()->isLayout()) {
+// rect.size can't be used here since size can be limited inside of
+// called method HbWidgetBase::setGeometry(rect) so size is used which
+// holds current size
+if (d->isAdjustHeightNeeded(size().width(),
+preferredHeight(),
+minimumHeight(),
+maximumHeight())) {
+updateGeometry();
+return;
+}
 }
 }
 /*!
 \reimp
 */
 QRectF HbRichTextItem::boundingRect () const
 {
 Q_D(const HbRichTextItem);
-QRectF result(d->mOffset, d->mRtf->size());
+QRectF result(d->mRtf->documentLayout()->frameBoundingRect(d->mRtf->rootFrame()));
+result.translate(d->mOffset);
-if(!d->mDontClip) {
+if (flags().testFlag(QGraphicsItem::ItemClipsToShape)) {
 // clip
-result = result.intersect(QRectF(QPointF(),
+result = result.intersect(contentsRect());
-size()));
 }
 return result;
 }
 /*!
 \reimp
 Relayouts text according to new size.
 */
-void HbRichTextItem::resizeEvent(QGraphicsSceneResizeEvent *event)
+void HbRichTextItem::resizeEvent(QGraphicsSceneResizeEvent * /*event*/)
 {
 Q_D(HbRichTextItem);
-d->setSize(event->newSize());
+d->setDocumentWidth(size().width());
+d->calculateOffset();
 }
 /*!
 \reimp
-This impelementation detects layout direction changes, font changes and theme changes.
+This implementation detects layout direction changes, font changes and theme changes.
 */
 void HbRichTextItem::changeEvent(QEvent *event)
 {
 Q_D(HbRichTextItem);
 switch(event->type()) {
 case QEvent::LayoutDirectionChange: {
 prepareGeometryChange();
-d->setLayoutDirection(layoutDirection());
+d->mTextOption.setTextDirection(layoutDirection());
+d->mRtf->setDefaultTextOption(d->mTextOption);
 update();
 }
 break;
 case QEvent::FontChange: {
 d->mRtf->setDefaultFont(font());
+d->clearPrefSizeCache();
 updateGeometry();
 }
 break;
 default:
 // Listens theme changed event so that item size hint is
 // update when physical font is changed.
 if (event->type() == HbEvent::ThemeChanged) {
 Q_D(HbRichTextItem);
 d->mDefaultColor = QColor();
-if(!d->mColor.isValid()) {
+if (!d->mColor.isValid()) {
 update();
 }
 }
 }
 HbWidgetBase::changeEvent(event);
 {
 Q_D(const HbRichTextItem);
 QSizeF result;
 switch(which) {
 case Qt::MinimumSize: {
-QTextBlock textBlock = d->mRtf->begin();
+result = d->minimumSizeHint(constraint);
-if(textBlock.isValid() && textBlock.layout()->lineCount() > 0) {
-QTextLine line = textBlock.layout()->lineAt(0);
-result.setHeight(line.height());
-int cursorPos(KMinimumLetersToShow);
-result.setWidth( line.cursorToX(&cursorPos) );
-qreal doubleDocMargin = d->mRtf->documentMargin() * (qreal)2.0;
-result.rheight() += doubleDocMargin;
-result.rwidth() += doubleDocMargin;
-} else {
-result = HbWidgetBase::sizeHint(which, constraint);
-}
 }
 break;
 case Qt::PreferredSize: {
-if(constraint.width()<=0) {
+result = d->preferredSizeHint(constraint);
-d->mRtf->adjustSize();
-} else {
-d->mRtf->setTextWidth(constraint.width());
-}
-result = d->mRtf->size();
 }
 break;
 default:
 result = HbWidgetBase::sizeHint(which, constraint);
 * \sa QTextOption::setWrapMode
 */
 void HbRichTextItem::setTextWrapping(Hb::TextWrapping mode)
 {
 Q_D(HbRichTextItem);
-	d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode, true);
+d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextWrapMode, true);
 QTextOption::WrapMode textWrapMode = static_cast<QTextOption::WrapMode>(mode);
-if(d->mTextOption.wrapMode()!=textWrapMode) {
+if (d->mTextOption.wrapMode()!=textWrapMode) {
 prepareGeometryChange();
 d->mTextOption.setWrapMode(textWrapMode);
 d->mRtf->setDefaultTextOption(d->mTextOption);
-updateGeometry();
+d->calculateOffset();
+if (d->restoreDefaultHeightHint()) {
+updateGeometry();
+}
 }
 }
 /*!
 * @proto
 *
 * \sa setTextDefaultColor()
 */
 QColor HbRichTextItem::textDefaultColor() const
 {
-Q_D( const HbRichTextItem );
+Q_D(const HbRichTextItem);
 if (d->mColor.isValid()) { // Means user has set text color
 return d->mColor;
 }
 if (!d->mDefaultColor.isValid()) {
 /*!
 * Shows (default) or hides text. Size hint remains unchanged (same as when text is visible).
 */
 void HbRichTextItem::setTextVisible(bool isVisible)
 {
-Q_D(HbRichTextItem);
+setVisible(isVisible);
-if( d->mDontPrint == isVisible ) {
-d->mDontPrint = !isVisible;
-update();
-}
 }
 /*!
 * Returns if text is visible.
 */
 bool HbRichTextItem::isTextVisible() const
 {
-Q_D(const HbRichTextItem);
+return isVisible();
-return !d->mDontPrint;
 }
 /*!
 * Enables (default) or disables text clipping when item geometry is too small.
 */
-void HbRichTextItem::setTextClip(bool cliping)
+void HbRichTextItem::setTextClip(bool clipping)
 {
-Q_D(HbRichTextItem);
+setFlag(QGraphicsItem::ItemClipsToShape, clipping);
-if( d->mDontClip == cliping ) {
-prepareGeometryChange();
-d->mDontClip = !cliping;
-setFlag(QGraphicsItem::ItemClipsToShape, cliping);
-update();
-}
 }
 /*!
 * Returns true if text is clipped when item geometry is too small.
 */
 bool HbRichTextItem::isTextClip() const
 {
-Q_D(const HbRichTextItem);
+return flags().testFlag(ItemClipsToShape);
-return !d->mDontClip;
 }
 // end of file

changeset 34	ed14f46c0e55
parent 1	f7ac710697a9