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

equal deleted inserted replaced

-:c3690ec91ef8
+:923ff622b8b9
 // #define HB_TEXT_ITEM_LOGS
 #define EPSILON 0.01
 #ifdef HB_TEXT_ITEM_LOGS
 #   include <QDebug>
+const int KMaxLogedTextLength = 30;
 #endif // HB_TEXT_ITEM_LOGS
 bool HbTextItemPrivate::outlinesEnabled = false;
 static const QString KDefaultColorThemeName = "qtc_view_normal";
 }
 }
 return i;
 }
-QSizeF HbTextItemPrivate::respectSizeLimits(QSizeF size) const
+qreal HbTextItemPrivate::respectHeightLimits(qreal height) const
 {
 QFontMetricsF metrics(mTextLayout.font());
 Q_ASSERT(mMinLines>0);
 qreal minHeight = metrics.lineSpacing()*mMinLines - metrics.leading();
-if (size.height()<minHeight) {
+if (height<minHeight) {
-size.setHeight(minHeight);
+height=minHeight;
 }
 if (mMaxLines>0) {
 qreal maxHeight = metrics.lineSpacing()*mMaxLines - metrics.leading();
-if (size.height()>maxHeight) {
+if (height>maxHeight) {
-size.setHeight(maxHeight);
+height=maxHeight;
 }
 }
-return size;
+return height;
 }
 QString HbTextItemPrivate::elideLayoutedText(const QSizeF& size, const QFontMetricsF& metrics) const
 {
 int lastVisibleLine =findIndexOfLastLineBeforeY(size.height());
 }
 return flags;
 }
-/*!
+/*
-This method check spetial case of calculating sizeHint.
+This method check spatial case of calculating sizeHint.
-By default prefferedSize returns size of text which has lots of free space.
+By default preferredSize (sizeHint(Qt::PreferredSize)) returns size of text
-But there can be situaltion that text has less avaible free width ther requred.
+which has lots of free space and it is not wrapped.
-In such cases prefered hight of HbTextItem should be recaculated because wrapping
+After size of HbTextItem is set (width is know) there can be situation
-of the line may requre more space in vertical direction.
+that text has less available width then required.
+In such cases when text wrapping is available preferred height of HbTextItem
-In such case bigger hight should be cached for sizeHint calculations.
+should be recalculated to take wrapped text into account.
 */
-bool HbTextItemPrivate::isAdjustHightNeeded(const QSizeF& newSize,
+bool HbTextItemPrivate::isAdjustHightNeeded(qreal newWidth,
-const QSizeF& prefSize)
+qreal prefHeight,
+qreal minHeight,
+qreal maxHeight)
 {
 #ifdef HB_TEXT_ITEM_LOGS
 qDebug() << "isAdjustHightNeeded for: " << q_ptr->objectName()
-<< " text=" << mText.left(20)
+<< " text=" << mText.left(KMaxLogedTextLength)
 << " adjusted=" << mAdjustedSize
-<< " pref=" << prefSize
+<< " prefHeight=" << prefHeight
-<< mTextLayout.font();
+<< " minHeight=" << minHeight
+<< " lastConstraint=" << mLastConstraint
+<< " " << mTextLayout.font();
 #endif // HB_TEXT_ITEM_LOGS
 // first check if wrapping of text is not active
 QTextOption::WrapMode wrapMode = mTextLayout.textOption().wrapMode();
 if (wrapMode==QTextOption::NoWrap
 || wrapMode==QTextOption::ManualWrap) {
 return false;
 }
+// preferred height was set from outside of this class so there is mo reson to adjust it
+if (mLastConstraint.height()>0) {
+return false;
+}
 // check if line count is fixed
 if (mMaxLines == mMinLines) {
 return false;
 }
-// check if preffered height is defined by user
-//    so check if preff height is same as value returned by sizeHint
-if (!qFuzzyCompare(prefSize.height(), mAdjustedSize.height())) {
-return false;
-}
 // check if adjusted size has been already calculated
 // new width is bigger then last estimated range of same height
-if ((mMaxWidthForAdjust>=newSize.width()
+if ((mMaxWidthForAdjust>=newWidth
 // new width is smaller then last estimated range of same height
-&& newSize.width()>=mMinWidthForAdjust)) {
+&& newWidth>=mMinWidthForAdjust)) {
 return false;
 }
 if (!mAdjustedSize.isValid()) {
 // this means that preferred size is set outside of class by setPreferredSize
 // if preconditions are met test if current hight is enough
 const QFontMetricsF metrics(mTextLayout.font());
 // heavy calculation: check if text fits in current size and cache result
-QSizeF newAdjust = metrics.boundingRect(QRectF(0, 0, newSize.width(), QWIDGETSIZE_MAX),
+QSizeF newAdjust = metrics.boundingRect(QRectF(0, 0, newWidth, QWIDGETSIZE_MAX),
 textFlagsFromTextOption(),
 mText).size();
 if (qFuzzyCompare(newAdjust.height(), mAdjustedSize.height())) {
 // height is same as last time update range of same height
-mMaxWidthForAdjust = qMax(mMaxWidthForAdjust, newSize.width());
+mMaxWidthForAdjust = qMax(mMaxWidthForAdjust, newWidth);
-mMinWidthForAdjust = qMin(mMinWidthForAdjust, newSize.width());
+mMinWidthForAdjust = qMin(mMinWidthForAdjust, newWidth);
 // and don't update geometry
 return false;
 }
 // new height was calculated create new range for which
 // current mAdjustedSize.height is valid
-mMaxWidthForAdjust = newSize.width();
+mMaxWidthForAdjust = newWidth;
 mMinWidthForAdjust = newAdjust.width();
-// store new hieght use don't change width
+// store new hieght, don't change width
 mAdjustedSize.setHeight(newAdjust.height());
-Q_ASSERT_X(mAdjustedSize.width()>=newAdjust.width(),
+Q_ASSERT_X(mLastConstraint.width()>0 || mAdjustedSize.width()>=newAdjust.width(),
 "HbTextItemPrivate::isAdjustHightNeeded",
 QString("Fail for string: \"%1\"").arg(mText).toAscii().data());
-if (respectSizeLimits(mAdjustedSize)==prefSize) {
+if (qFuzzyCompare(qBound(minHeight,
+respectHeightLimits(mAdjustedSize.height()),
+maxHeight),
+prefHeight)) {
 // updateGeometry has no effect
 return false;
 }
 // all conditions for calling updateGeometry are meet
 QSizeF HbTextItemPrivate::calculatePrefferedSize(const QSizeF& constraint) const
 {
 const QFontMetricsF metrics(mTextLayout.font());
-if (mAdjustedSize.isValid() &&
+if (mAdjustedSize.isValid() && constraint == mLastConstraint) {
-(constraint.height()<0 || qFuzzyCompare(constraint.height(), mAdjustedSize.height())) &&
-(constraint.width()<0  || qFuzzyCompare(constraint.width(), mAdjustedSize.width()))) {
 // return cached value, see more in:
 //      - HbTextItemPrivate::isAdjustHightNeeded
 //      - HbTextItem::resizeEvent
+#ifdef HB_TEXT_ITEM_LOGS
+qDebug() << "HbTextItemPrivate::calculatePrefferedSize: returning cached value: " << mAdjustedSize
+<< " font:" << mTextLayout.font()
+<< " text:" << mText.left(KMaxLogedTextLength);
+#endif
 return mAdjustedSize;
 }
+mLastConstraint = constraint;
 QSizeF maxSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
 if(constraint.width()>0) {
 maxSize.setWidth(constraint.width());
 }
 mText).size();
 mAdjustedSize = size;
 mDefaultHeight = size.height();
 mMinWidthForAdjust = size.width();
-mMaxWidthForAdjust = QWIDGETSIZE_MAX;
+mMaxWidthForAdjust = maxSize.width();
+#ifdef HB_TEXT_ITEM_LOGS
+qDebug() << "HbTextItemPrivate::calculatePrefferedSize:"
+<< " text: " << mText.left(KMaxLogedTextLength)
+<< " returnSize: " << mAdjustedSize
+<< " constraint: "  << constraint
+<< " font: " << mTextLayout.font();
+#endif
 return size;
 }
 bool HbTextItemPrivate::fadeNeeded(const QRectF& contentRect) const
 {
 }
 QRectF HbTextItemPrivate::boundingRect (const QRectF& contentsRect) const
 {
 QRectF result(layoutBoundingRect());
+if (mPaintFaded) {
+result = result.intersected(mFadeToRect);
+}
 if(q_ptr->flags().testFlag(QGraphicsItem::ItemClipsToShape)) {
-// clip
+result = result.intersected(contentsRect);
-QRectF clippedTo = contentsRect;
-qreal dx = qMin(mFadeLengthX, (qreal)0.0);
-qreal dy = qMin(mFadeLengthY, (qreal)0.0);
-clippedTo.adjust(dx, dy, -dx, -dy);
-result = result.intersected(clippedTo);
 }
 if (HbTextItemPrivate::outlinesEnabled) {
 result = result.united(contentsRect);
 }
 // check if call of updateGeometry can be ignored
 // don't call it when minimum and maximum lines are equal (height is fixed) or ...
 if ((d->mMinLines == d->mMaxLines)
 // or when preferred height is ignored
-|| (sizePolicy().verticalPolicy()&QSizePolicy::IgnoreFlag)) {
+|| (sizePolicy().verticalPolicy()&QSizePolicy::IgnoreFlag)
+// or was preferred height set from outside of this class?
-// and when preferred width is ignored or ...
+|| d->mLastConstraint.height()>0) {
+// and when preferred width is ignored
 if (sizePolicy().horizontalPolicy()&QSizePolicy::IgnoreFlag
-// or when preferred width is defined from outside
+// or was preferred width set from outside of this class?
-|| !qFuzzyCompare(preferredWidth(), d->mAdjustedSize.width())) {
+|| d->mLastConstraint.width()>0) {
-// TODO: looking for better solution since preferredWidth() can cause call of sizeHint
+#ifdef HB_TEXT_ITEM_LOGS
+qDebug() << "HbTextItem::setText: skiping updateGeometry for: "
+<< objectName() << " text:" << d->mText.left(KMaxLogedTextLength);
+#endif
 // in those cases skip updateGeometry
 return;
 }
 }
 updateGeometry();
 {
 Q_D(HbTextItem);
 Q_UNUSED(option);
 Q_UNUSED(widget);
-// optimalization:
-if (option->exposedRect.isEmpty()) {
-return;
-}
 // Save painter's state
 QPen oldPen = painter->pen();
 if (HbTextItemPrivate::outlinesEnabled){
 painter->setPen(textColor());
 Q_ASSERT(d->mPaintFaded == d->fadeNeeded(contentsRect()));
 if(d->mPaintFaded ) {
+// there is issue with restoring state of painter when
+// setClipPath is used. It is impossible to restore
+// original clipPath without save and restore whole painter
+painter->save(); // see comment above
 d->paintWithFadeEffect(painter);
+painter->restore(); // see comment above
 } else {
 d->mTextLayout.draw(painter,
 d->mOffsetPos,
 QVector<QTextLayout::FormatRange>(),
 flags().testFlag(ItemClipsToShape)?contentsRect():QRectF());
 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
 Q_D(HbTextItem);
-if (d->isAdjustHightNeeded(size(), preferredSize())) {
+if (d->isAdjustHightNeeded(size().width(),
-updateGeometry();
+preferredHeight(),
+minimumHeight(),
+maximumHeight())) {
+updateGeometry();
+#ifdef HB_TEXT_ITEM_LOGS
+qDebug() << "isAdjustHightNeeded returned true - updateGeometry was called";
+#endif // HB_TEXT_ITEM_LOGS
 }
 }
 }
 /*!
 // so updating font here (this is needed because of sizeHint adjustments).
 if (d->mTextLayout.font()!=font()) {
 #ifdef HB_TEXT_ITEM_LOGS
 qWarning() << "Font change was not recieved on time: work-around is active"
 << objectName()
-<< " test: " << d->mText.left(20)
+<< " test: " << d->mText.left(KMaxLogedTextLength)
 << " oldFont:" << d->mTextLayout.font()
 << " newFont:" << font();
 #endif // HB_TEXT_ITEM_LOGS
 const_cast<HbTextItemPrivate *>(d)->mTextLayout.setFont(font());
 switch(which) {
 case Qt::MinimumSize:
 {
 if ( !d->mText.isEmpty() ) {
 size.setWidth(MinimumWidth); // just to show something  -- should not matter in read use-case
-size = d->respectSizeLimits(size);
+size.setHeight(d->respectHeightLimits(size.height()));
 }
 break;
 }
 case Qt::PreferredSize:
 {
 if ( !effectiveOrientations.testFlag(Qt::Horizontal)
 && (d->mMinLines == d->mMaxLines) ) {
 //optimize single line if the horizontal sizeHint is ignored
-size = d->respectSizeLimits(size);
+size.setHeight(d->respectHeightLimits(size.height()));
 break;
 }
 size = d->calculatePrefferedSize(constraint);
-size = d->respectSizeLimits(size);
+size.setHeight(d->respectHeightLimits(size.height()));
 break;
 }
 default:
 size = HbWidgetBase::sizeHint(which, constraint);
 if (!d->mTextLayout.font().isCopyOf(font())) {
 #ifdef HB_TEXT_ITEM_LOGS
 qDebug() << "fontChangeEvent: " << objectName()
-<< " text: " << text().left(20)
+<< " text: " << text().left(KMaxLogedTextLength)
 << " font: " << font();
 #endif // HB_TEXT_ITEM_LOGS
 d->mTextLayout.setFont(font());
 d->clearAdjustedSizeCache();
 // is size hint adjustable?
 if (parentLayoutItem() && parentLayoutItem()->isLayout()) {
 if (d->mAdjustedSize.isValid() &&
 d->mAdjustedSize.width() > size().width()) {
 // restore default size hint
-d->mAdjustedSize = d->respectSizeLimits(
+d->mAdjustedSize.setHeight(
-QSizeF(d->mAdjustedSize.width(), d->mDefaultHeight));
+d->respectHeightLimits(d->mDefaultHeight));
 d->mMinWidthForAdjust = d->mAdjustedSize.width();
 d->mMaxWidthForAdjust = QWIDGETSIZE_MAX;
 updateGeometry();
 }

changeset 7	923ff622b8b9
parent 6	c3690ec91ef8
child 21	4633027730f5
child 34	ed14f46c0e55