FCL/sf/mw/hb: comparison src/hbwidgets/editors/hbabstractedit

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include "hbvalidator.h"
 #include "hbmenu.h"
 #include "hbselectioncontrol_p.h"
 #include "hbcolorscheme.h"
 #include "hbsmileyengine_p.h"
-#include "hbtextmeasurementutility_p.h"
+#ifdef HB_TEXT_MEASUREMENT_UTILITY
-#include "hbfeaturemanager_r.h"
+#include "hbtextmeasurementutility_r.h"
+#include "hbtextmeasurementutility_r_p.h"
+#endif
 #include "hbinputeditorinterface.h"
 #include "hbinputvkbhost.h"
 #include "hbinputmethod.h"
 #include "hbinputfocusobject.h"
+#include "hbtapgesture.h"
+#include "hbpangesture.h"
+#include "hbnamespace_p.h"
+#include "hbwidgetfeedback.h"
 #include <QValidator>
 #include <QTextLayout>
 #include <QTextBlock>
 #include <QPainter>
 #include <QtDebug>
 #include <QClipboard>
 #include <QInputContext>
 #include <QRegExp>
+#include <QGraphicsScene>
+namespace {
+static const int DOUBLE_TAP_DELAY = 400;
+}
 static inline bool firstFramePosLessThanCursorPos(QTextFrame *frame, int position)
 {
 return frame->firstPosition() < position;
 }
 r |= frame->document()->documentLayout()->frameBoundingRect(*it);
 }
 return r;
 }
+class HbEditScrollArea: public HbScrollArea
+{
+public:
+explicit HbEditScrollArea(HbAbstractEdit* edit, QGraphicsItem* parent = 0):HbScrollArea(parent), mEdit(edit) {}
+virtual ~HbEditScrollArea() {}
+void resizeEvent(QGraphicsSceneResizeEvent *event)
+{
+HbScrollArea::resizeEvent(event);
+mEdit->updatePrimitives();
+}
+private:
+HbAbstractEdit* mEdit;
+};
 class HbEditItem : public HbWidget
 {
 public:
 HbEditItem(HbAbstractEdit *parent) : HbWidget(parent), edit(parent)
 {
-	setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
+setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
-};
+}
-virtual ~HbEditItem() {};
+virtual ~HbEditItem() {}
 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
 {
 Q_UNUSED(widget)
 HbAbstractEditPrivate::HbAbstractEditPrivate () :
 HbWidgetPrivate(),
 doc(0),
 placeholderDoc(0),
+previousCursorAnchor(-1),
+previousCursorPosition(-1),
 validator(0),
 imEditInProgress(false),
 imPosition(0),
 imAdded(0),
 imRemoved(0),
 interactionFlags(Qt::TextEditorInteraction),
 tapPosition(-1, -1),
 cursorOn(false),
+tapCounter(0),
+showContextMenu(false),
 preeditCursor(0),
 preeditCursorVisible(true),
 apiCursorVisible(true),
 canvas(0),
 scrollArea(0),
 scrollable(false),
 hadSelectionOnMousePress(false),
 selectionControl(0),
+enableSelectionControl(true),
 acceptSignalContentsChange(true),
 acceptSignalContentsChanged(true),
 validRevision(0),
 wasGesture(false),
 smileysEnabled(false),
 smileyEngine(0),
 formatDialog(0),
-updatePrimitivesInProgress(false)
+updatePrimitivesInProgress(false),
+enableMagnifier(true),
+cursorType(CursorTypeBlinking)
 {
 }
 HbAbstractEditPrivate::~HbAbstractEditPrivate ()
 {
 void HbAbstractEditPrivate::init()
 {
 Q_Q(HbAbstractEdit);
 canvas = new HbEditItem(q);
-canvas->setSizePolicy(QSizePolicy::Ignored,QSizePolicy::Ignored);
+q->setFlag(QGraphicsItem::ItemAcceptsInputMethod);
 setContent(Qt::RichText, QString());
 QTextOption textOption = doc->defaultTextOption();
 textOption.setTextDirection(q->layoutDirection());
 doc->setDefaultTextOption(textOption);
 doc->setUndoRedoEnabled(interactionFlags & Qt::TextEditable);
 updatePaletteFromTheme();
-scrollArea = new HbScrollArea(q);
+scrollArea = new HbEditScrollArea(q,q);
 scrollArea->setClampingStyle(HbScrollArea::StrictClamping);
 scrollArea->setFrictionEnabled(true);
 scrollArea->setScrollDirections(Qt::Vertical);
 scrollArea->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
 scrollArea->setContentWidget(canvas);
+canvas->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 scrollArea->setFlag(QGraphicsItem::ItemIsFocusable, false);
 QObject::connect(scrollArea, SIGNAL(scrollingStarted()), q, SLOT(_q_scrollStarted()));
 QObject::connect(scrollArea, SIGNAL(scrollingEnded()), q, SLOT(_q_scrollEnded()));
-QObject::connect(q, SIGNAL(selectionChanged(QTextCursor,QTextCursor)), q, SLOT(_q_selectionChanged()));
+QObject::connect(q, SIGNAL(selectionChanged(const QTextCursor&,const QTextCursor&)), q, SLOT(_q_selectionChanged(const QTextCursor&,const QTextCursor&)));
 HbStyle::setItemName(scrollArea, QString("text"));
 // These are the default values which are then overridden in subclasses
 // and when different options are enabled.
 q->setFlag(QGraphicsItem::ItemIsFocusable);
-q->setFlag(QGraphicsItem::ItemAcceptsInputMethod);
 q->setFlag(QGraphicsItem::ItemSendsScenePositionChanges);
 q->setFlag(QGraphicsItem::ItemHasNoContents, false);
 q->setFocusPolicy(Qt::StrongFocus);
 q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 Q_Q(HbAbstractEdit);
 // for localization text support
 QString txt( text );
 #ifdef HB_TEXT_MEASUREMENT_UTILITY
-if ( HbFeatureManager::instance()->featureStatus( HbFeatureManager::TextMeasurement ) ) {
+if (HbTextMeasurementUtility::instance()->locTestMode()) {
 if (text.endsWith(QChar(LOC_TEST_END))) {
 int index = text.indexOf(QChar(LOC_TEST_START));
 q->setProperty( HbTextMeasurementUtilityNameSpace::textIdPropertyName,
 text.mid(index + 1, text.indexOf(QChar(LOC_TEST_END)) - index - 1) );
 txt = text.left(index);
 doc->setModified(false);
 ensureCursorVisible();
-smileyEngineInstance()->setDocument(doc);
 if(q->isSmileysEnabled()) {
 smileyEngineInstance()->insertSmileys();
 }
 }
 differenceSelection.setPosition(cursor.position(), QTextCursor::KeepAnchor);
 canvas->update(selectionRect(differenceSelection));
 } else {
 if (!oldSelection.isNull())
 canvas->update(selectionRect(oldSelection) | cursorRectPlusUnicodeDirectionMarkers(oldSelection.position()));
-canvas->update(selectionRect() | cursorRectPlusUnicodeDirectionMarkers(cursor.position()));
+canvas->update(selectionRect(cursor) | cursorRectPlusUnicodeDirectionMarkers(cursor.position()));
 }
 }
 void HbAbstractEditPrivate::updateCurrentCharFormat()
 {
 QRectF HbAbstractEditPrivate::cursorRectPlusUnicodeDirectionMarkers(int position) const
 {
 return rectForPositionInCanvasCoords(position,QTextLine::Leading).adjusted(-4, 0, 4, 0);
 }
-void HbAbstractEditPrivate::setBlinkingCursorEnabled(bool enable)
+void HbAbstractEditPrivate::updateCursorType()
+{
+updateCursorType(hasInputFocus());
+}
+void HbAbstractEditPrivate::updateCursorType(bool hasInputFocus)
+{
+CursorType type = hasInputFocus?CursorTypeBlinking:CursorTypeNone;
+if (hasInputFocus) {
+if (cursor.hasSelection()) {
+type = CursorTypeNone;
+} else if (selectionControl && selectionControl->isVisible()) {
+type = CursorTypeStill;
+}
+}
+setCursorType(type);
+}
+void HbAbstractEditPrivate::setCursorType(CursorType type)
 {
 Q_Q(HbAbstractEdit);
-if (enable && QApplication::cursorFlashTime() > 0)
+if (cursorType != type) {
-cursorBlinkTimer.start(QApplication::cursorFlashTime() / 2, q);
+cursorType = type;
-else
-cursorBlinkTimer.stop();
+if (cursorType == CursorTypeBlinking && QApplication::cursorFlashTime() > 0)
+cursorBlinkTimer.start(QApplication::cursorFlashTime() / 2, q);
-cursorOn = enable;
+else
+cursorBlinkTimer.stop();
-repaintCursor();
+cursorOn = (cursorType != CursorTypeNone);
+repaintCursor();
+}
+}
+void HbAbstractEditPrivate::setCursorColor(const QColor& color)
+{
+cursorColor = color;
 }
 void HbAbstractEditPrivate::repaintCursor()
 {
 canvas->update(cursorRectPlusUnicodeDirectionMarkers(cursor.position()));
 void HbAbstractEditPrivate::ensurePositionVisible(int position)
 {
 if (scrollArea && scrollable) {
 QRectF rect = rectForPositionInCanvasCoords(position, QTextLine::Leading);
-rect.adjust(0, -doc->documentMargin(), 0, doc->documentMargin());
+qreal docMargin = doc->documentMargin();
+rect.adjust(0, -docMargin, 0, docMargin);
 // TODO: it seems that scrollArea->ensureVisible() expects the point
 //       in its content coordinates. Probably it should use viewport
 //       coordinates i.e. its own item coordinate system
 //QRectF recScroll = canvas->mapToItem(scrollArea, rect).boundingRect();
+const QTextBlock block = doc->findBlock(position);
+if (block.isValid()) {
+const QTextLayout *layout = block.layout();
+if(layout->preeditAreaText().length()) {
+// Adjust cursor rect so that predictive text will be also visible
+int preeditStart = layout->preeditAreaPosition();
+int preeditStop = preeditStart+layout->preeditAreaText().length();
+QTextLine line = layout->lineForTextPosition(preeditStart);
+qreal preeditWidth = qAbs(line.cursorToX(preeditStop)-line.cursorToX(preeditStart));
+// rect.adjust(0,0,preeditWidth*0.5,0);
+rect.setWidth(rect.width()+preeditWidth*0.5);
+}
+}
 scrollArea->ensureVisible(rect.center(), rect.width(), rect.height()/2);
 }
 }
 void HbAbstractEditPrivate::ensureCursorVisible()
 void HbAbstractEditPrivate::setTextInteractionFlags(Qt::TextInteractionFlags flags)
 {
 if (flags == interactionFlags)
 return;
 interactionFlags = flags;
-if (hasInputFocus()) {
-setBlinkingCursorEnabled(flags & Qt::TextEditable);
-}
 }
 void HbAbstractEditPrivate::_q_updateRequest(QRectF rect)
 {
 canvas->update(rect);
 validateAndCorrect();
 }
 updateCurrentCharFormat();
 emit q->contentsChanged();
+canvas->setPreferredSize(calculatePreferredDocSize());
 acceptSignalContentsChanged = true; // end of prevent recurence
 }
 }
 imRemoved = charsRemoved;
 imAdded = charsAdded;
 }
 }
-void HbAbstractEditPrivate::_q_selectionChanged()
+void HbAbstractEditPrivate::_q_selectionChanged(const QTextCursor& oldSelection, const QTextCursor& newSelection)
 {
 Q_Q(HbAbstractEdit);
-if (cursor.hasSelection()) {
+if (newSelection.hasSelection()) {
 selectionControl = HbSelectionControl::attachEditor(q);
-selectionControl->showHandles();
+selectionControl->setMagnifierEnabled(q->isSelectionControlEnabled()&&enableMagnifier);
+if (q->isSelectionControlEnabled()) {
+selectionControl->showHandles();
+}
 } else if (selectionControl){
-selectionControl->hideHandles();
+if (q->isReadOnly()) {
+selectionControl->hideHandles();
+}
+selectionControl->updatePrimitives();
 }
-QTextCursor oldSelection(selectionCursor);
+updateCursorType();
-selectionCursor = cursor;
 repaintOldAndNewSelection(oldSelection);
 }
 void HbAbstractEditPrivate::_q_scrollStarted()
 {
 }
 if (!selectionCursor.hasSelection() && !cursor.hasSelection()) {
 return;
 }
 }
 emit q->selectionChanged(selectionCursor, cursor);
+selectionCursor = cursor;
 }
 void HbAbstractEditPrivate::acceptKeyPressEvent(QKeyEvent *event)
 {
 event->accept();
-cursorOn = true;
 ensureCursorVisible();
 updateCurrentCharFormat();
 }
 selection.format.setForeground(ctx.palette.brush(cg, QPalette::HighlightedText));
 HbStyleOption opt;
 q->initStyleOption(&opt);
-		if (qApp->style()->styleHint(QStyle::SH_RichText_FullWidthSelection, &opt, 0)) {
+if (qApp->style()->styleHint(QStyle::SH_RichText_FullWidthSelection, &opt, 0)) {
 selection.format.setProperty(QTextFormat::FullWidthSelection, true);
 }
 ctx.selections.append(selection);
 }
 }
 return r;
 }
-QRectF HbAbstractEditPrivate::selectionRect() const
-{
-return selectionRect(selectionCursor);
-}
 QRectF HbAbstractEditPrivate::rectForPositionInCanvasCoords(int position, QTextLine::Edge edge) const
 {
 Q_Q(const HbAbstractEdit);
 cursorWidth + w, line.height());
 } else {
 r = QRectF(layoutPos.x(), layoutPos.y(), cursorWidth, 10); // #### correct height
 }
-if(layout->preeditAreaText().length()) {
-r.adjust(0,0,q->blockBoundingRect(block).width()/2,0);
-}
 return r;
 }
 /*
 Returns the viewport rectangle in editor coordinate system.
 {
 QRectF viewRect = scrollArea->geometry();
 qreal margin = doc->documentMargin();
 viewRect.adjust(0,margin,0,-margin);
 return viewRect;
+}
+/*
+Returns the constrained hit test point in editor coordinate system.
+*/
+QPointF HbAbstractEditPrivate::constrainHitTestPoint(const QPointF& point)
+{
+QRectF viewRect = viewPortRect();
+// Constrain hitTestPos within docRect with 1 top/bottom margins.
+QPointF hitTestPos = QPointF(qMin(qMax(point.x(),viewRect.left()),viewRect.right()),
+qMin(qMax(point.y(),viewRect.top()+1),viewRect.bottom()-1));
+return hitTestPos;
 }
 int HbAbstractEditPrivate::contentLength() const
 {
 QTextBlock block = doc->lastBlock();
 bool HbAbstractEditPrivate::isCursorVisible() const
 {
 return preeditCursorVisible && apiCursorVisible;
 }
+/*
+base implementation of void gestureEvent(QGestureEvent* event) designed to be used by widgets
+that delegate gesture event to the editor. Client widgets calling this method should pass themselves
+as parameter in widget. If widget is 0 it is assumed that it is called by this HbAbstractEdit object.
+*/
+void HbAbstractEditPrivate::gestureEvent(QGestureEvent* event, HbWidget* widget)
+{
+Q_Q(HbAbstractEdit);
+bool ownEvent = !widget;
+if(HbTapGesture *tap = qobject_cast<HbTapGesture*>(event->gesture(Qt::TapGesture))) {
+// QTapGesture::position() is in screen coordinates and thus
+// needs to be transformed into items own coordinate system.
+// The QGestureEvent knows the viewport through which the gesture
+// was triggered.
+QPointF pos = q->mapFromScene(event->mapToGraphicsScene(tap->position()));
+pos = constrainHitTestPoint(pos);
+switch(tap->state()) {
+case Qt::GestureStarted:
+if (tapCounter == 0) {
+tapPosition = pos;
+}
+HbWidgetFeedback::triggered(q, Hb::InstantPressed);
+if (!doubleTapTimer.isActive()) {
+doubleTapTimer.start(DOUBLE_TAP_DELAY,q);
+}
+break;
+case Qt::GestureUpdated:
+if(q->isReadOnly() && tap->tapStyleHint() == HbTapGesture::TapAndHold && !cursor.hasSelection() && ownEvent &&
+contextMenuShownOn.testFlag(Hb::ShowTextContextMenuOnLongPress)) {
+q->showContextMenu(q->mapToScene(tapPosition));
+doubleTapTimer.stop();
+tapCounter = 0;
+}
+break;
+case Qt::GestureFinished:
+tapCounter++;
+// if doubleTapTimer is already triggered
+if (!doubleTapTimer.isActive()){
+if (ownEvent){
+tapGesture(tapPosition,false);
+} else {
+if (contextMenuShownOn.testFlag(Hb::ShowTextContextMenuOnSelectionClicked)) {
+q->showContextMenu(q->mapToScene(tapPosition));
+}
+}
+tapCounter = 0;
+showContextMenu = false;
+} else {
+// if tapCounter is 1 the doubleTapTimer is still active so delay showing the context menu
+if (tapCounter == 1){
+if (ownEvent){
+tapGesture(tapPosition,true);
+} else {
+showContextMenu = true;
+}
+}
+// if tapCounter is 2 the tap gesture is double-tap cancel showing the context menu
+else if (tapCounter == 2) {
+doubleTapTimer.stop();
+tapCounter = 0;
+showContextMenu = false;
+if (contextMenuShownOn.testFlag(Hb::ShowTextContextMenuOnSelectionClicked) ||
+contextMenuShownOn.testFlag(Hb::ShowTextContextMenuOnLongPress)) {
+q->selectClickedWord();
+}
+}
+}
+HbWidgetFeedback::triggered(q, Hb::InstantReleased);
+break;
+case Qt::GestureCanceled:
+doubleTapTimer.stop();
+tapCounter = 0;
+break;
+default:
+break;
+}
+event->accept();
+} else {
+event->ignore();
+}
+}
 void HbAbstractEditPrivate::sendMouseEventToInputContext(const QPointF &tapPos) const
 {
 Q_Q(const HbAbstractEdit);
 {
 Q_Q(HbAbstractEdit);
 doc = newDoc;
 cursor = QTextCursor(doc);
+if(smileysEnabled) {
+smileyEngineInstance()->setDocument(doc);
+}
 QObject::connect(doc, SIGNAL(contentsChanged()), q, SLOT(_q_contentsChanged()));
 QObject::connect(doc, SIGNAL(contentsChange(int, int, int)), q, SLOT(_q_contentsChange(int, int, int)));
 QObject::connect(doc, SIGNAL(documentLayoutChanged()), q, SLOT(documentLayoutChanged()));
 QObject::connect(doc, SIGNAL(blockCountChanged(int)), q, SLOT(blockCountChanged(int)));
 doc->setModified(false);
 q->documentLayoutChanged();
 }
-void HbAbstractEditPrivate::longTapGesture(const QPointF &point)
+void HbAbstractEditPrivate::tapGesture(const QPointF &point, bool delayMenu)
 {
 Q_Q(HbAbstractEdit);
-if(contextMenuShownOn.testFlag(Hb::ShowTextContextMenuOnLongPress)) {
-int cursorPos = hitTest(point, Qt::FuzzyHit);
-if (cursorPos == -1)
-return;
-// don't do anything if longpress inside the selection
-if (cursor.hasSelection()
-&& cursorPos >= cursor.selectionStart()
-&& cursorPos <= cursor.selectionEnd()){
-return;
-}
-q->showContextMenu(q->mapToScene(point));
-}
-}
-void HbAbstractEditPrivate::tapGesture(const QPointF &point)
-{
-Q_Q(HbAbstractEdit);
-if (interactionFlags & Qt::NoTextInteraction)
-return;
 bool removeSelection = (hitTest(point, Qt::ExactHit) == -1);
 if (removeSelection && cursor.hasSelection()) {
-const QTextCursor oldCursor = cursor;
 cursor.clearSelection();
-emit q->selectionChanged(oldCursor, cursor);
+selectionChanged();
 }
 int newCursorPos = hitTest(point, Qt::FuzzyHit);
 if (cursor.hasSelection() &&
 newCursorPos >= cursor.selectionStart() &&
 newCursorPos <= cursor.selectionEnd()){
 // we have a selection under mouse click
 if (contextMenuShownOn.testFlag(Hb::ShowTextContextMenuOnSelectionClicked)) {
-q->showContextMenu(q->mapToScene(point));
+if (delayMenu) {
-}
+showContextMenu = true;
 } else {
+q->showContextMenu(q->mapToScene(point));
+}
+}
+} else {
 // Currently focused widget to listen to InputContext before updating the cursor position
 sendMouseEventToInputContext(point);
-// translate the point to have the Y ccordinate inside the viewport
-QPointF translatedPoint(point);
-if(translatedPoint.y() < viewPortRect().top()) {
-translatedPoint.setY(viewPortRect().top() + 1);
-} else if(translatedPoint.y() > viewPortRect().bottom()){
-translatedPoint.setY(viewPortRect().bottom() - 1);
-}
 // need to get the cursor position again since input context can change the document
-newCursorPos = hitTest(translatedPoint, Qt::FuzzyHit);
+newCursorPos = hitTest(point, Qt::FuzzyHit);
 setCursorPosition(newCursorPos);
 if (interactionFlags & Qt::TextEditable) {
 updateCurrentCharFormat();
 }
-QString anchor(q->anchorAt(translatedPoint));
+// workaround for a Qt crash
-if(!anchor.isEmpty()) {
+// If there preedit are isn't empty the QTextDocumentLayout::anchorAt crashes
-emit q->anchorTapped(anchor);
+if (cursor.block().layout()->preeditAreaText().isEmpty()) {
-}
+QString anchor(q->anchorAt(point));
+if(!anchor.isEmpty()) {
+emit q->anchorTapped(anchor);
+}
+}
+}
+if(!q->isReadOnly()) {
+if (selectionControl && hasInputFocus() && isCursorVisible()) {
+if (q->isSelectionControlEnabled()) {
+selectionControl->showHandles();
+}
+updateCursorType();
+}
+openInputPanel();
 }
 }
 {
 wasGesture = true;
 }
-void HbAbstractEditPrivate::drawSelectionEdges(QPainter *painter, QAbstractTextDocumentLayout::PaintContext ctx)
+void HbAbstractEditPrivate::drawCursor(QPainter *painter, QAbstractTextDocumentLayout::PaintContext ctx)
 {
-if (cursor.hasSelection() && selectionControl && selectionControl->isVisible()){
+// save painter state
-painter->setPen(ctx.palette.color(QPalette::Text));
+QPen oldPen = painter->pen();
-painter->setBrush(ctx.palette.color(QPalette::Text));
+QBrush oldBrush = painter->brush();
-painter->drawRect(rectForPositionInCanvasCoords(cursor.selectionStart(), QTextLine::Leading));
-painter->drawRect(rectForPositionInCanvasCoords(cursor.selectionEnd(), QTextLine::Trailing));
+// Draw cursor
-}
+if (ctx.cursorPosition != -1) {
+painter->setPen(cursorColor);
+painter->setBrush(cursorColor);
+painter->drawRect(rectForPositionInCanvasCoords(ctx.cursorPosition, QTextLine::Leading));
+}
+// restore painter state
+painter->setPen(oldPen);
+painter->setBrush(oldBrush);
 }
 /*
 * Prepares the document for pasting. Derived classes can override this method,
 * e.g. HbLineEdit clears the document before pasting when in password edit mode
 return false;
 }
 void HbAbstractEditPrivate::setInputFocusEnabled(bool enable)
 {
-QGraphicsItem *focusItem = focusPrimitive(HbWidget::FocusHighlightActive);
+setFocusHighlightVisible(HbWidget::FocusHighlightActive, enable);
-if (focusItem) {
+if (!enable && selectionControl && !cursor.hasSelection()) {
-focusItem->setVisible(enable);
+selectionControl->hideHandles();
 }
+updateCursorType(enable);
-setBlinkingCursorEnabled(enable);
 repaintOldAndNewSelection(selectionCursor);
 }
+QSizeF HbAbstractEditPrivate::calculatePreferredDocSize() const
+{
+if (doc->isEmpty()) {
+QFontMetricsF metrics(doc->defaultFont());
+qreal margins = doc->documentMargin()*2.0;
+QSizeF result(5+margins, metrics.height()+margins);
+if (placeholderDoc) {
+result = result.expandedTo(placeholderDoc->size());
+}
+return result;
+}
+QTextBlock block = doc->begin();
+qreal prefWidth = 5; // minimum value 5
+while (block.isValid()) {
+const QTextLayout *layout = block.layout();
+prefWidth = qMax(layout->maximumWidth() + layout->position().x(),
+prefWidth);
+block=block.next();
+}
+prefWidth += doc->documentMargin(); // only once since position was added
+// so it is already contains right margin
+return QSizeF(prefWidth, doc->size().height());
+}
 #include "moc_hbabstractedit.cpp"

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9