void GroupedLineEdit::paintEvent(QPaintEvent *e)
{
QTextLine line = document()->findBlock(0).layout()->lineAt(0);
QPainter painter(viewport());
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillRect(0, 0, viewport()->width(), viewport()->height(), palette().base());
QVectorIterator<QColor> i(d->colors);
i.toFront();
foreach (const Private::Block &block, d->blocks) {
qreal start_x = line.cursorToX(block.start, QTextLine::Leading);
qreal end_x = line.cursorToX(block.end-1, QTextLine::Trailing);
QPainterPath path;
QRectF rectangle(
start_x - 1.0 - double(horizontalScrollBar()->value()),
1.0,
end_x - start_x + 2.0,
double(viewport()->height() - 2));
if (!i.hasNext())
i.toFront();
path.addRoundedRect(rectangle, 5.0, 5.0);
painter.setPen(i.peekNext());
if (palette().color(QPalette::Text).lightnessF() <= 0.3)
painter.setBrush(i.next().lighter());
else if (palette().color(QPalette::Text).lightnessF() <= 0.6)
painter.setBrush(i.next());
else
painter.setBrush(i.next().darker());
painter.drawPath(path);
}
QPlainTextEdit::paintEvent(e);
}
static void calculateBoundingRect( QTextDocument *document, int startPosition, int endPosition,
QRectF &rect )
{
const QTextBlock startBlock = document->findBlock( startPosition );
const QRectF startBoundingRect = document->documentLayout()->blockBoundingRect( startBlock );
const QTextBlock endBlock = document->findBlock( endPosition );
const QRectF endBoundingRect = document->documentLayout()->blockBoundingRect( endBlock );
QTextLayout *startLayout = startBlock.layout();
QTextLayout *endLayout = endBlock.layout();
int startPos = startPosition - startBlock.position();
int endPos = endPosition - endBlock.position();
const QTextLine startLine = startLayout->lineForTextPosition( startPos );
const QTextLine endLine = endLayout->lineForTextPosition( endPos );
double x = startBoundingRect.x() + startLine.cursorToX( startPos );
double y = startBoundingRect.y() + startLine.y();
double r = endBoundingRect.x() + endLine.cursorToX( endPos );
double b = endBoundingRect.y() + endLine.y() + endLine.height();
const QSizeF size = document->size();
rect = QRectF( x / size.width(), y / size.height(),
(r - x) / size.width(), (b - y) / size.height() );
}
FloatRect Font::selectionRectForComplexText(const TextRun& run, const IntPoint& pt, int h, int from, int to) const
{
const QString string = fixSpacing(qstring(run));
QTextLayout layout(string, font());
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
return FloatRect(pt.x() + x1, pt.y(), x2 - x1, h);
}
void tst_QComplexText::bidiCursor_PDF()
{
QString str = QString::fromUtf8("\342\200\252hello\342\200\254");
QTextLayout layout(str);
layout.beginLayout();
QTextLine line = layout.createLine();
layout.endLayout();
int size = str.size();
QVERIFY(line.cursorToX(size) == line.cursorToX(size - 1));
}
void SurfaceImpl::MeasureWidths(Font &font,
const char *s,
int len,
XYPOSITION *positions)
{
if (!font.GetID())
return;
SetCodec(font);
QString su = codec->toUnicode(s, len);
QTextLayout tlay(su, *FontPointer(font));
tlay.beginLayout();
QTextLine tl = tlay.createLine();
tlay.endLayout();
if (unicodeMode) {
int fit = su.size();
int ui=0;
const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
int i=0;
while (ui<fit) {
size_t lenChar = utf8LengthFromLead(us[i]);
size_t codeUnits = (lenChar < 4) ? 1 : 2;
qreal xPosition = tl.cursorToX(ui+codeUnits);
for (unsigned int bytePos=0; (bytePos<lenChar) && (i<len); bytePos++) {
positions[i++] = qRound(xPosition);
}
ui += codeUnits;
}
int lastPos = 0;
if (i > 0)
lastPos = positions[i-1];
while (i<len) {
positions[i++] = lastPos;
}
} else if (codePage) {
// DBCS
int ui = 0;
for (int i=0; i<len;) {
size_t lenChar = Platform::IsDBCSLeadByte(codePage, s[i]) ? 2 : 1;
qreal xPosition = tl.cursorToX(ui+1);
for (unsigned int bytePos=0; (bytePos<lenChar) && (i<len); bytePos++) {
positions[i++] = qRound(xPosition);
}
ui++;
}
} else {
// Single byte encoding
for (int i=0; i<len; i++) {
positions[i] = qRound(tl.cursorToX(i+1));
}
}
}
FloatRect Font::selectionRectForComplexText(const TextRun& run, const FloatPoint& pt, int h, int from, int to) const
{
String sanitized = Font::normalizeSpaces(run.characters(), run.length());
QString string = fromRawDataWithoutRef(sanitized);
QTextLayout layout(string, font());
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
return FloatRect(pt.x() + x1, pt.y(), x2 - x1, h);
}
void tst_QTextFormat::testTabsUsed()
{
QTextDocument doc;
QTextCursor cursor(&doc);
QList<QTextOption::Tab> tabs;
QTextBlockFormat format;
QTextOption::Tab tab;
tab.position = 100;
tabs.append(tab);
format.setTabPositions(tabs);
cursor.mergeBlockFormat(format);
cursor.insertText("foo\tbar");
//doc.setPageSize(QSizeF(200, 200));
doc.documentLayout()->pageCount(); // force layout;
QTextBlock block = doc.begin();
QTextLayout *layout = block.layout();
QVERIFY(layout);
QCOMPARE(layout->lineCount(), 1);
QTextLine line = layout->lineAt(0);
QCOMPARE(line.cursorToX(4), 100.);
QTextOption option = layout->textOption();
QCOMPARE(option.tabs().count(), tabs.count());
}
void GroupedLineEdit::paintEvent(QPaintEvent *e)
{
#if !defined __APPLE__
// for reasons we don't understand, yet, touching the painter
// here (even drawing the fill rect) causes the QPlainTextEdit
// paintEvent to not draw the text on MacOS.
// So as a workaround until this is better understood we need
// to disable the eye candy
QTextLine line = document()->findBlock(0).layout()->lineAt(0);
QPainter painter(viewport());
painter.setRenderHint(QPainter::Antialiasing, true);
painter.fillRect(0, 0, viewport()->width(), viewport()->height(), palette().base());
QVectorIterator<QColor> i(d->colors);
i.toFront();
foreach (const Private::Block &block, d->blocks) {
qreal start_x = line.cursorToX(block.start, QTextLine::Leading);
#if QT_VERSION >= 0x050000
qreal end_x = line.cursorToX(block.end-1, QTextLine::Trailing);
#else
qreal end_x = line.cursorToX(block.end, QTextLine::Trailing);
#endif
QPainterPath path;
QRectF rectangle(
start_x - 1.0 - double(horizontalScrollBar()->value()),
1.0,
end_x - start_x + 2.0,
double(viewport()->height() - 2));
if (!i.hasNext())
i.toFront();
path.addRoundedRect(rectangle, 5.0, 5.0);
painter.setPen(i.peekNext());
if (palette().color(QPalette::Text).lightnessF() <= 0.3)
painter.setBrush(i.next().lighter());
else if (palette().color(QPalette::Text).lightnessF() <= 0.6)
painter.setBrush(i.next());
else
painter.setBrush(i.next().darker());
painter.drawPath(path);
}
#endif
QPlainTextEdit::paintEvent(e);
}
void tst_QComplexText::bidiCursorMovement()
{
QFETCH(QString, logical);
QFETCH(int, basicDir);
QTextLayout layout(logical);
layout.setCacheEnabled(true);
QTextOption option = layout.textOption();
option.setTextDirection(basicDir == QChar::DirL ? Qt::LeftToRight : Qt::RightToLeft);
layout.setTextOption(option);
layout.setCursorMoveStyle(Qt::VisualMoveStyle);
bool moved;
int oldPos, newPos = 0;
qreal x, newX;
layout.beginLayout();
QTextLine line = layout.createLine();
layout.endLayout();
newX = line.cursorToX(0);
do {
oldPos = newPos;
x = newX;
newX = line.cursorToX(oldPos);
if (basicDir == QChar::DirL) {
QVERIFY(newX >= x);
newPos = layout.rightCursorPosition(oldPos);
} else
{
QVERIFY(newX <= x);
newPos = layout.leftCursorPosition(oldPos);
}
moved = (oldPos != newPos);
} while (moved);
}
void CodeEditor::paintEvent(QPaintEvent* event)
{
QPlainTextEdit::paintEvent(event);
QPainter painter(viewport());
painter.setPen(Qt::darkGray);
QTextBlock block = firstVisibleBlock();
QRectF rect;
do {
if (!block.isVisible())
continue;
rect = blockBoundingGeometry(block).translated(contentOffset());
QTextLine line = block.layout()->lineAt(0);
if (config->whitespaces) {
QString txt = block.text();
for (int i = 0; i < txt.length(); i++) {
// rect.x() <- учитывая горизонтальный скролинг
QPoint point(rect.x() + line.cursorToX(i), rect.y() + line.ascent());
if (txt[i] == ' ')
painter.drawText(point, QChar(0x00b7));
else if (txt[i] == '\t')
painter.drawText(point, QChar(0x21b9));
}
}
int state = block.userState();
if (!(state & Error) && state & Folded) {
QRect collapseRect(rect.x() + line.rect().x() + line.naturalTextWidth() + FONTWIDTH * 2,
rect.y() + 2, FONTWIDTH * 6, line.height() - 4);
painter.drawText(collapseRect, Qt::AlignCenter, state & Comment ? "...;" : "...)");
painter.drawRoundedRect(collapseRect, 4, 6);
}
} while ((block = block.next()).isValid() && rect.y() < viewport()->height());
}
//This is for one line of html-formatted text
qreal pixelOffsetForHtmlChar( QFont font, QString text, int index) {
if(index==-1){
index = text.length()-1;
}
QTextLayout tl(text,font);
tl.beginLayout();
QTextLine line = tl.createLine();
Q_ASSERT( line.isValid() );
line.setLineWidth(1000);
int pos = line.cursorToX(index);
tl.endLayout();
return pos;
}
QPainterPath TextEditorOverlay::createSelectionPath(const QTextCursor &begin, const QTextCursor &end,
const QRect &clip)
{
if (begin.isNull() || end.isNull() || begin.position() > end.position())
return QPainterPath();
QPointF offset = m_editor->contentOffset();
QRect viewportRect = rect();
QTextDocument *document = m_editor->document();
if (m_editor->blockBoundingGeometry(begin.block()).translated(offset).top() > clip.bottom() + 10
|| m_editor->blockBoundingGeometry(end.block()).translated(offset).bottom() < clip.top() - 10
)
return QPainterPath(); // nothing of the selection is visible
QTextBlock block = begin.block();
if (block.blockNumber() < m_editor->firstVisibleBlock().blockNumber() - 4)
block = m_editor->document()->findBlockByNumber(m_editor->firstVisibleBlock().blockNumber() - 4);
bool inSelection = false;
QVector<QRectF> selection;
if (begin.position() == end.position()) {
// special case empty selections
const QRectF blockGeometry = m_editor->blockBoundingGeometry(block);
QTextLayout *blockLayout = block.layout();
int pos = begin.position() - begin.block().position();
QTextLine line = blockLayout->lineForTextPosition(pos);
QRectF lineRect = line.naturalTextRect();
int x = line.cursorToX(pos);
lineRect.setLeft(x - m_borderWidth);
lineRect.setRight(x + m_borderWidth);
selection += lineRect.translated(blockGeometry.topLeft());
} else {
for (; block.isValid() && block.blockNumber() <= end.blockNumber(); block = block.next()) {
if (! block.isVisible())
continue;
const QRectF blockGeometry = m_editor->blockBoundingGeometry(block);
QTextLayout *blockLayout = block.layout();
QTextLine line = blockLayout->lineAt(0);
bool firstOrLastBlock = false;
int beginChar = 0;
if (!inSelection) {
if (block == begin.block()) {
beginChar = begin.positionInBlock();
line = blockLayout->lineForTextPosition(beginChar);
firstOrLastBlock = true;
}
inSelection = true;
} else {
// while (beginChar < block.length() && document->characterAt(block.position() + beginChar).isSpace())
// ++beginChar;
// if (beginChar == block.length())
// beginChar = 0;
}
int lastLine = blockLayout->lineCount()-1;
int endChar = -1;
if (block == end.block()) {
endChar = end.positionInBlock();
lastLine = blockLayout->lineForTextPosition(endChar).lineNumber();
inSelection = false;
firstOrLastBlock = true;
} else {
endChar = block.length();
while (endChar > beginChar && document->characterAt(block.position() + endChar - 1).isSpace())
--endChar;
}
QRectF lineRect = line.naturalTextRect();
if (beginChar < endChar) {
lineRect.setLeft(line.cursorToX(beginChar));
if (line.lineNumber() == lastLine)
lineRect.setRight(line.cursorToX(endChar));
selection += lineRect.translated(blockGeometry.topLeft());
for (int lineIndex = line.lineNumber()+1; lineIndex <= lastLine; ++lineIndex) {
line = blockLayout->lineAt(lineIndex);
lineRect = line.naturalTextRect();
if (lineIndex == lastLine)
lineRect.setRight(line.cursorToX(endChar));
selection += lineRect.translated(blockGeometry.topLeft());
}
} else { // empty lines
const int emptyLineSelectionSize = 16;
if (!firstOrLastBlock && !selection.isEmpty()) { // middle
lineRect.setLeft(selection.last().left());
} else if (inSelection) { // first line
lineRect.setLeft(line.cursorToX(beginChar));
} else { // last line
if (endChar == 0)
break;
lineRect.setLeft(line.cursorToX(endChar) - emptyLineSelectionSize);
}
lineRect.setRight(lineRect.left() + emptyLineSelectionSize);
selection += lineRect.translated(blockGeometry.topLeft());
}
if (!inSelection)
break;
if (blockGeometry.translated(offset).y() > 2*viewportRect.height())
break;
}
}
if (selection.isEmpty())
return QPainterPath();
QVector<QPointF> points;
const int margin = m_borderWidth/2;
const int extra = 0;
const QRectF &firstSelection = selection.at(0);
points += (firstSelection.topLeft() + firstSelection.topRight()) / 2 + QPointF(0, -margin);
points += firstSelection.topRight() + QPointF(margin+1, -margin);
points += firstSelection.bottomRight() + QPointF(margin+1, 0);
const int count = selection.count();
for (int i = 1; i < count-1; ++i) {
#define MAX3(a,b,c) qMax(a, qMax(b,c))
qreal x = MAX3(selection.at(i-1).right(),
selection.at(i).right(),
selection.at(i+1).right()) + margin;
points += QPointF(x+1, selection.at(i).top());
points += QPointF(x+1, selection.at(i).bottom());
}
const QRectF &lastSelection = selection.at(count-1);
points += lastSelection.topRight() + QPointF(margin+1, 0);
points += lastSelection.bottomRight() + QPointF(margin+1, margin+extra);
points += lastSelection.bottomLeft() + QPointF(-margin, margin+extra);
points += lastSelection.topLeft() + QPointF(-margin, 0);
for (int i = count-2; i > 0; --i) {
#define MIN3(a,b,c) qMin(a, qMin(b,c))
qreal x = MIN3(selection.at(i-1).left(),
selection.at(i).left(),
selection.at(i+1).left()) - margin;
points += QPointF(x, selection.at(i).bottom()+extra);
points += QPointF(x, selection.at(i).top());
}
points += firstSelection.bottomLeft() + QPointF(-margin, extra);
points += firstSelection.topLeft() + QPointF(-margin, -margin);
QPainterPath path;
const int corner = 4;
path.moveTo(points.at(0));
points += points.at(0);
QPointF previous = points.at(0);
for (int i = 1; i < points.size(); ++i) {
QPointF point = points.at(i);
if (point.y() == previous.y() && qAbs(point.x() - previous.x()) > 2*corner) {
QPointF tmp = QPointF(previous.x() + corner * ((point.x() > previous.x())?1:-1), previous.y());
path.quadTo(previous, tmp);
previous = tmp;
i--;
continue;
} else if (point.x() == previous.x() && qAbs(point.y() - previous.y()) > 2*corner) {
QPointF tmp = QPointF(previous.x(), previous.y() + corner * ((point.y() > previous.y())?1:-1));
path.quadTo(previous, tmp);
previous = tmp;
i--;
continue;
}
QPointF target = (previous + point) / 2;
path.quadTo(previous, target);
previous = points.at(i);
}
path.closeSubpath();
path.translate(offset);
return path;
}
void ChatLineModelItem::computeWrapList() const
{
QString text = _styledMsg.plainContents();
int length = text.length();
if (!length)
return;
QList<ChatLineModel::Word> wplist; // use a temp list which we'll later copy into a QVector for efficiency
QTextBoundaryFinder finder(QTextBoundaryFinder::Line, _styledMsg.plainContents().unicode(), length,
TextBoundaryFinderBuffer, TextBoundaryFinderBufferSize);
int idx;
int oldidx = 0;
ChatLineModel::Word word;
word.start = 0;
qreal wordstartx = 0;
QTextLayout layout(_styledMsg.plainContents());
QTextOption option;
option.setWrapMode(QTextOption::NoWrap);
layout.setTextOption(option);
layout.setAdditionalFormats(QtUi::style()->toTextLayoutList(_styledMsg.contentsFormatList(), length, messageLabel()));
layout.beginLayout();
QTextLine line = layout.createLine();
line.setNumColumns(length);
layout.endLayout();
while ((idx = finder.toNextBoundary()) >= 0 && idx <= length) {
// QTextBoundaryFinder has inconsistent behavior in Qt version up to and including 4.6.3 (at least).
// It doesn't point to the position we should break, but to the character before that.
// Unfortunately Qt decided to fix this by changing the behavior of QTBF, so now we have to add a version
// check. At the time of this writing, I'm still trying to get this reverted upstream...
//
// cf. https://bugs.webkit.org/show_bug.cgi?id=31076 and Qt commit e6ac173
static int needWorkaround = -1;
if (needWorkaround < 0) {
needWorkaround = 0;
QStringList versions = QString(qVersion()).split('.');
if (versions.count() == 3 && versions.at(0).toInt() == 4) {
if (versions.at(1).toInt() <= 6 && versions.at(2).toInt() <= 3)
needWorkaround = 1;
}
}
if (needWorkaround == 1) {
if (idx < length)
idx++;
}
if (idx == oldidx)
continue;
word.start = oldidx;
int wordend = idx;
for (; wordend > word.start; wordend--) {
if (!text.at(wordend-1).isSpace())
break;
}
qreal wordendx = line.cursorToX(wordend);
qreal trailingendx = line.cursorToX(idx);
word.endX = wordendx;
word.width = wordendx - wordstartx;
word.trailing = trailingendx - wordendx;
wordstartx = trailingendx;
wplist.append(word);
oldidx = idx;
}
// A QVector needs less space than a QList
_wrapList.resize(wplist.count());
for (int i = 0; i < wplist.count(); i++) {
_wrapList[i] = wplist.at(i);
}
}
void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to) const
{
if (to < 0)
to = run.length();
QPainter *p = ctx->platformContext();
if (ctx->textDrawingMode() & cTextFill) {
if (ctx->fillGradient()) {
QBrush brush(*ctx->fillGradient()->platformGradient());
brush.setTransform(ctx->fillGradient()->gradientSpaceTransform());
p->setPen(QPen(brush, 0));
} else if (ctx->fillPattern()) {
TransformationMatrix affine;
p->setPen(QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0));
} else
p->setPen(QColor(ctx->fillColor()));
}
if (ctx->textDrawingMode() & cTextStroke) {
if (ctx->strokeGradient()) {
QBrush brush(*ctx->strokeGradient()->platformGradient());
brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform());
p->setPen(QPen(brush, ctx->strokeThickness()));
} else if (ctx->strokePattern()) {
TransformationMatrix affine;
p->setPen(QPen(QBrush(ctx->strokePattern()->createPlatformPattern(affine)), ctx->strokeThickness()));
} else
p->setPen(QPen(QColor(ctx->strokeColor()), ctx->strokeThickness()));
}
const QString string = fixSpacing(qstring(run));
// text shadow
IntSize shadowSize;
int shadowBlur;
Color shadowColor;
bool hasShadow = ctx->textDrawingMode() == cTextFill && ctx->getShadow(shadowSize, shadowBlur, shadowColor);
if (from > 0 || to < run.length()) {
QTextLayout layout(string, font());
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
QFontMetrics fm(font());
int ascent = fm.ascent();
QRectF clip(point.x() + x1, point.y() - ascent, x2 - x1, fm.height());
if (hasShadow) {
// TODO: when blur support is added, the clip will need to account
// for the blur radius
qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
if (shadowSize.width() > 0)
dx2 = shadowSize.width();
else
dx1 = -shadowSize.width();
if (shadowSize.height() > 0)
dy2 = shadowSize.height();
else
dy1 = -shadowSize.height();
// expand the clip rect to include the text shadow as well
clip.adjust(dx1, dx2, dy1, dy2);
}
p->save();
p->setClipRect(clip.toRect());
QPointF pt(point.x(), point.y() - ascent);
if (hasShadow) {
p->save();
p->setPen(QColor(shadowColor));
p->translate(shadowSize.width(), shadowSize.height());
line.draw(p, pt);
p->restore();
}
line.draw(p, pt);
p->restore();
return;
}
p->setFont(font());
QPointF pt(point.x(), point.y());
int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
if (hasShadow) {
// TODO: text shadow blur support
p->save();
p->setPen(QColor(shadowColor));
p->translate(shadowSize.width(), shadowSize.height());
p->drawText(pt, string, flags, run.padding());
p->restore();
}
if (ctx->textDrawingMode() & cTextStroke) {
QPainterPath path;
path.addText(pt, font(), string);
p->strokePath(path, p->pen());
}
if (ctx->textDrawingMode() & cTextFill)
p->drawText(pt, string, flags, run.padding());
}
static void drawTextCommon(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to, const QFont& font, bool isComplexText)
{
if (to < 0)
to = run.length();
QPainter *p = ctx->platformContext();
QPen textFillPen;
if (ctx->textDrawingMode() & cTextFill) {
if (ctx->fillGradient()) {
QBrush brush(*ctx->fillGradient()->platformGradient());
brush.setTransform(ctx->fillGradient()->gradientSpaceTransform());
textFillPen = QPen(brush, 0);
} else if (ctx->fillPattern()) {
AffineTransform affine;
textFillPen = QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0);
} else
textFillPen = QPen(QColor(ctx->fillColor()));
}
QPen textStrokePen;
if (ctx->textDrawingMode() & cTextStroke) {
if (ctx->strokeGradient()) {
QBrush brush(*ctx->strokeGradient()->platformGradient());
brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform());
textStrokePen = QPen(brush, ctx->strokeThickness());
} else if (ctx->strokePattern()) {
AffineTransform affine;
QBrush brush(ctx->strokePattern()->createPlatformPattern(affine));
textStrokePen = QPen(brush, ctx->strokeThickness());
} else
textStrokePen = QPen(QColor(ctx->strokeColor()), ctx->strokeThickness());
}
String sanitized = Font::normalizeSpaces(String(run.characters(), run.length()));
QString string = fromRawDataWithoutRef(sanitized);
QPointF pt(point.x(), point.y());
// text shadow
IntSize shadowSize;
int shadowBlur;
Color shadowColor;
bool hasShadow = ctx->textDrawingMode() == cTextFill && ctx->getShadow(shadowSize, shadowBlur, shadowColor);
if (from > 0 || to < run.length()) {
if (isComplexText) {
QTextLayout layout(string, font);
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
QFontMetrics fm(font);
int ascent = fm.ascent();
QRectF clip(fm.boundingRect(string));
if (hasShadow) {
// TODO: when blur support is added, the clip will need to account
// for the blur radius
qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
if (shadowSize.width() > 0)
dx2 = shadowSize.width();
else
dx1 = -shadowSize.width();
if (shadowSize.height() > 0)
dy2 = shadowSize.height();
else
dy1 = -shadowSize.height();
// expand the clip rect to include the text shadow as well
clip.adjust(dx1, dx2, dy1, dy2);
}
p->save();
//p->setClipRect(clip.toRect(), Qt::IntersectClip);
pt.setY(pt.y() - ascent);
if (hasShadow) {
p->save();
p->setPen(QColor(shadowColor));
p->translate(shadowSize.width(), shadowSize.height());
line.draw(p, pt);
p->restore();
}
p->setPen(textFillPen);
line.draw(p, pt);
p->restore();
return;
}
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
int skipWidth = QFontMetrics(font).width(string, from, Qt::TextBypassShaping);
pt.setX(pt.x() + skipWidth);
string = fromRawDataWithoutRef(sanitized, from, to - from);
#endif
}
p->setFont(font);
int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
// See QWebPagePrivate::QWebPagePrivate() where the default path is set to Complex for Qt 4.6 and earlier.
if (!isComplexText)
flags |= Qt::TextBypassShaping;
#endif
QFontMetrics fm(font);
QRectF clip(pt.x(), pt.y()-fm.ascent(), fm.width(string, -1, flags), fm.height());
if (hasShadow) {
// TODO: text shadow blur support
p->save();
p->translate(shadowSize.width(), shadowSize.height());
//p->setClipRect(clip, Qt::IntersectClip);
p->setPen(QColor(shadowColor));
p->drawText(pt, string, flags, run.padding());
p->restore();
}
if (ctx->textDrawingMode() & cTextStroke) {
QPainterPath path;
path.addText(pt, font, string);
p->save();
//p->setClipRect(clip, Qt::IntersectClip);
p->setPen(textStrokePen);
p->strokePath(path, p->pen());
p->restore();
}
if (ctx->textDrawingMode() & cTextFill) {
p->save();
//p->setClipRect(clip, Qt::IntersectClip);
p->setPen(textFillPen);
p->drawText(pt, string, flags, run.padding());
p->restore();
}
}
/*
The ultimate line painting function.
Currently missing features:
- draw indent lines
*/
void KateRenderer::paintTextLine(QPainter& paint, KateLineLayoutPtr range, int xStart, int xEnd, const KTextEditor::Cursor* cursor)
{
Q_ASSERT(range->isValid());
// kDebug( 13033 )<<"KateRenderer::paintTextLine";
// font data
const QFontMetricsF &fm = config()->fontMetrics();
int currentViewLine = -1;
if (cursor && cursor->line() == range->line())
currentViewLine = range->viewLineForColumn(cursor->column());
paintTextLineBackground(paint, range, currentViewLine, xStart, xEnd);
if (range->layout()) {
bool drawSelection = m_view->selection() && showSelections() && m_view->selectionRange().overlapsLine(range->line());
// Draw selection in block selecton mode. We need 2 kinds of selections that QTextLayout::draw can't render:
// - past-end-of-line selection and
// - 0-column-wide selection (used to indicate where text will be typed)
if (drawSelection && m_view->blockSelection()) {
int selectionStartColumn = m_doc->fromVirtualColumn(range->line(), m_doc->toVirtualColumn(m_view->selectionRange().start()));
int selectionEndColumn = m_doc->fromVirtualColumn(range->line(), m_doc->toVirtualColumn(m_view->selectionRange().end()));
QBrush selectionBrush = config()->selectionColor();
if (selectionStartColumn != selectionEndColumn) {
KateTextLayout lastLine = range->viewLine(range->viewLineCount() - 1);
if (selectionEndColumn > lastLine.startCol()) {
int selectionStartX = (selectionStartColumn > lastLine.startCol()) ? cursorToX(lastLine, selectionStartColumn, true) : 0;
int selectionEndX = cursorToX(lastLine, selectionEndColumn, true);
paint.fillRect(QRect(selectionStartX - xStart, (int)lastLine.lineLayout().y(), selectionEndX - selectionStartX, lineHeight()), selectionBrush);
}
} else {
const int selectStickWidth = 2;
KateTextLayout selectionLine = range->viewLine(range->viewLineForColumn(selectionStartColumn));
int selectionX = cursorToX(selectionLine, selectionStartColumn, true);
paint.fillRect(QRect(selectionX - xStart, (int)selectionLine.lineLayout().y(), selectStickWidth, lineHeight()), selectionBrush);
}
}
QVector<QTextLayout::FormatRange> additionalFormats;
if (range->length() > 0) {
// We may have changed the pen, be absolutely sure it gets set back to
// normal foreground color before drawing text for text that does not
// set the pen color
paint.setPen(attribute(KTextEditor::HighlightInterface::dsNormal)->foreground().color());
// Draw the text :)
if (drawSelection) {
// FIXME toVector() may be a performance issue
additionalFormats = decorationsForLine(range->textLine(), range->line(), true).toVector();
range->layout()->draw(&paint, QPoint(-xStart,0), additionalFormats);
} else {
range->layout()->draw(&paint, QPoint(-xStart,0));
}
}
QBrush backgroundBrush;
bool backgroundBrushSet = false;
// Loop each individual line for additional text decoration etc.
QListIterator<QTextLayout::FormatRange> it = range->layout()->additionalFormats();
QVectorIterator<QTextLayout::FormatRange> it2 = additionalFormats;
for (int i = 0; i < range->viewLineCount(); ++i) {
KateTextLayout line = range->viewLine(i);
// Determine the background to use, if any, for the end of this view line
backgroundBrushSet = false;
while (it2.hasNext()) {
const QTextLayout::FormatRange& fr = it2.peekNext();
if (fr.start > line.endCol())
break;
if (fr.start + fr.length > line.endCol()) {
if (fr.format.hasProperty(QTextFormat::BackgroundBrush)) {
backgroundBrushSet = true;
backgroundBrush = fr.format.background();
}
goto backgroundDetermined;
}
it2.next();
}
while (it.hasNext()) {
const QTextLayout::FormatRange& fr = it.peekNext();
if (fr.start > line.endCol())
break;
if (fr.start + fr.length > line.endCol()) {
if (fr.format.hasProperty(QTextFormat::BackgroundBrush)) {
backgroundBrushSet = true;
backgroundBrush = fr.format.background();
}
break;
}
it.next();
}
backgroundDetermined:
// Draw selection or background color outside of areas where text is rendered
if (!m_printerFriendly ) {
bool draw = false;
QBrush drawBrush;
if (m_view->selection() && !m_view->blockSelection() && m_view->lineEndSelected(line.end(true))) {
draw = true;
drawBrush = config()->selectionColor();
} else if (backgroundBrushSet && !m_view->blockSelection()) {
draw = true;
drawBrush = backgroundBrush;
}
if (draw) {
int fillStartX = line.endX() - line.startX() + line.xOffset() - xStart;
int fillStartY = lineHeight() * i;
int width= xEnd - xStart - fillStartX;
int height= lineHeight();
// reverse X for right-aligned lines
if (range->layout()->textOption().alignment() == Qt::AlignRight)
fillStartX = 0;
if (width > 0) {
QRect area(fillStartX, fillStartY, width, height);
paint.fillRect(area, drawBrush);
}
}
}
// Draw indent lines
if (showIndentLines() && i == 0)
{
const qreal w = spaceWidth();
const int lastIndentColumn = range->textLine()->indentDepth(m_tabWidth);
for (int x = m_indentWidth; x < lastIndentColumn; x += m_indentWidth)
{
paintIndentMarker(paint, x * w + 1 - xStart, range->line());
}
}
// draw an open box to mark non-breaking spaces
const QString& text = range->textLine()->string();
int y = lineHeight() * i + fm.ascent() - fm.strikeOutPos();
int nbSpaceIndex = text.indexOf(nbSpaceChar, line.lineLayout().xToCursor(xStart));
while (nbSpaceIndex != -1 && nbSpaceIndex < line.endCol()) {
int x = line.lineLayout().cursorToX(nbSpaceIndex);
if (x > xEnd)
break;
paintNonBreakSpace(paint, x - xStart, y);
nbSpaceIndex = text.indexOf(nbSpaceChar, nbSpaceIndex + 1);
}
// draw tab stop indicators
if (showTabs()) {
int tabIndex = text.indexOf(tabChar, line.lineLayout().xToCursor(xStart));
while (tabIndex != -1 && tabIndex < line.endCol()) {
int x = line.lineLayout().cursorToX(tabIndex);
if (x > xEnd)
break;
paintTabstop(paint, x - xStart + spaceWidth()/2.0, y);
tabIndex = text.indexOf(tabChar, tabIndex + 1);
}
}
// draw trailing spaces
if (showTrailingSpaces()) {
int spaceIndex = line.endCol() - 1;
int trailingPos = range->textLine()->lastChar();
if (trailingPos < 0)
trailingPos = 0;
if (spaceIndex >= trailingPos) {
while (spaceIndex >= line.startCol() && text.at(spaceIndex).isSpace()) {
if (text.at(spaceIndex) != '\t' || !showTabs())
paintTrailingSpace(paint, line.lineLayout().cursorToX(spaceIndex) - xStart + spaceWidth()/2.0, y);
--spaceIndex;
}
}
}
}
// draw word-wrap-honor-indent filling
if ( (range->viewLineCount() > 1) && range->shiftX() && (range->shiftX() > xStart) )
{
if (backgroundBrushSet)
paint.fillRect(0, lineHeight(), range->shiftX() - xStart, lineHeight() * (range->viewLineCount() - 1),
backgroundBrush);
paint.fillRect(0, lineHeight(), range->shiftX() - xStart, lineHeight() * (range->viewLineCount() - 1),
QBrush(config()->wordWrapMarkerColor(), Qt::Dense4Pattern));
}
// Draw caret
if (drawCaret() && cursor && range->includesCursor(*cursor)) {
int caretWidth, lineWidth = 2;
QColor color;
QTextLine line = range->layout()->lineForTextPosition(qMin(cursor->column(), range->length()));
// Determine the caret's style
caretStyles style = caretStyle();
// Make the caret the desired width
if (style == Line) {
caretWidth = lineWidth;
} else if (line.isValid() && cursor->column() < range->length()) {
caretWidth = int(line.cursorToX(cursor->column() + 1) - line.cursorToX(cursor->column()));
if (caretWidth < 0) {
caretWidth = -caretWidth;
}
} else {
caretWidth = spaceWidth();
}
// Determine the color
if (m_caretOverrideColor.isValid()) {
// Could actually use the real highlighting system for this...
// would be slower, but more accurate for corner cases
color = m_caretOverrideColor;
} else {
// search for the FormatRange that includes the cursor
foreach (const QTextLayout::FormatRange &r, range->layout()->additionalFormats()) {
if ((r.start <= cursor->column() ) && ( (r.start + r.length) > cursor->column())) {
// check for Qt::NoBrush, as the returned color is black() and no invalid QColor
QBrush foregroundBrush = r.format.foreground();
if (foregroundBrush != Qt::NoBrush) {
color = r.format.foreground().color();
}
break;
}
}
// still no color found, fall back to default style
if (!color.isValid())
color = attribute(KTextEditor::HighlightInterface::dsNormal)->foreground().color();
}
// Clip the caret - Qt's caret has a habit of intruding onto other lines.
paint.save();
paint.setClipRect(0, line.lineNumber() * lineHeight(), xEnd - xStart, lineHeight());
switch(style) {
case Line :
paint.setPen(QPen(color, caretWidth));
break;
case Block :
// use a gray caret so it's possible to see the character
color.setAlpha(128);
paint.setPen(QPen(color, caretWidth));
break;
case Underline :
paint.setClipRect(0, lineHeight() - lineWidth, xEnd - xStart, lineWidth);
break;
case Half :
color.setAlpha(128);
paint.setPen(QPen(color, caretWidth));
paint.setClipRect(0, lineHeight() / 2, xEnd - xStart, lineHeight() / 2);
break;
}
if (cursor->column() <= range->length()) {
range->layout()->drawCursor(&paint, QPoint(-xStart,0), cursor->column(), caretWidth);
} else {
// Off the end of the line... must be block mode. Draw the caret ourselves.
const KateTextLayout& lastLine = range->viewLine(range->viewLineCount() - 1);
int x = cursorToX(lastLine, KTextEditor::Cursor(range->line(), cursor->column()), true);
if ((x >= xStart) && (x <= xEnd)) {
paint.fillRect(x - xStart, (int)lastLine.lineLayout().y(), caretWidth, lineHeight(), color);
}
}
paint.restore();
}
void Font::drawComplexText(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to) const
{
if (to < 0)
to = run.length();
QPainter *p = ctx->platformContext();
Color color = ctx->fillColor();
p->setPen(QColor(color));
QString string = qstring(run);
// text shadow
IntSize shadowSize;
int shadowBlur;
Color shadowColor;
bool hasShadow = ctx->textDrawingMode() == cTextFill && ctx->getShadow(shadowSize, shadowBlur, shadowColor);
if (from > 0 || to < run.length()) {
QTextLayout layout(string, font());
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
QFontMetrics fm(font());
int ascent = fm.ascent();
QRectF clip(point.x() + x1, point.y() - ascent, x2 - x1, fm.height());
if (hasShadow) {
// TODO: when blur support is added, the clip will need to account
// for the blur radius
qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
if (shadowSize.width() > 0)
dx2 = shadowSize.width();
else
dx1 = -shadowSize.width();
if (shadowSize.height() > 0)
dy2 = shadowSize.height();
else
dy1 = -shadowSize.height();
// expand the clip rect to include the text shadow as well
clip.adjust(dx1, dx2, dy1, dy2);
}
p->save();
p->setClipRect(clip.toRect());
QPointF pt(point.x(), point.y() - ascent);
if (hasShadow) {
p->save();
p->setPen(QColor(shadowColor));
p->translate(shadowSize.width(), shadowSize.height());
line.draw(p, pt);
p->restore();
}
line.draw(p, pt);
p->restore();
return;
}
p->setFont(font());
QPointF pt(point.x(), point.y());
int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
if (hasShadow) {
// TODO: text shadow blur support
p->save();
p->setPen(QColor(shadowColor));
p->translate(shadowSize.width(), shadowSize.height());
p->drawText(pt, string, flags, run.padding());
p->restore();
}
p->drawText(pt, string, flags, run.padding());
}
static void drawTextCommon(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to, const QFont& font, bool isComplexText)
{
if (to < 0)
to = run.length();
QPainter *p = ctx->platformContext();
QPen textFillPen;
if (ctx->textDrawingMode() & TextModeFill)
textFillPen = fillPenForContext(ctx);
QPen textStrokePen;
if (ctx->textDrawingMode() & TextModeStroke)
textStrokePen = strokePenForContext(ctx);
String sanitized = Font::normalizeSpaces(run.characters(), run.length());
QString string = fromRawDataWithoutRef(sanitized);
QPointF pt(point.x(), point.y());
if (from > 0 || to < run.length()) {
if (isComplexText) {
QTextLayout layout(string, font);
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
QFontMetrics fm(font);
int ascent = fm.ascent();
QRectF boundingRect(point.x() + x1, point.y() - ascent, x2 - x1, fm.height());
QRectF clip = boundingRect;
ContextShadow* ctxShadow = ctx->contextShadow();
if (ctxShadow->m_type != ContextShadow::NoShadow) {
qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
if (ctxShadow->offset().x() > 0)
dx2 = ctxShadow->offset().x();
else
dx1 = -ctxShadow->offset().x();
if (ctxShadow->offset().y() > 0)
dy2 = ctxShadow->offset().y();
else
dy1 = -ctxShadow->offset().y();
// expand the clip rect to include the text shadow as well
clip.adjust(dx1, dx2, dy1, dy2);
clip.adjust(-ctxShadow->m_blurDistance, -ctxShadow->m_blurDistance, ctxShadow->m_blurDistance, ctxShadow->m_blurDistance);
}
p->save();
p->setClipRect(clip.toRect(), Qt::IntersectClip);
pt.setY(pt.y() - ascent);
if (ctxShadow->m_type != ContextShadow::NoShadow) {
ContextShadow* ctxShadow = ctx->contextShadow();
if (!ctxShadow->mustUseContextShadow(ctx)) {
p->save();
p->setPen(ctxShadow->m_color);
p->translate(ctxShadow->offset());
line.draw(p, pt);
p->restore();
} else {
QPainter* shadowPainter = ctxShadow->beginShadowLayer(ctx, boundingRect);
if (shadowPainter) {
// Since it will be blurred anyway, we don't care about render hints.
shadowPainter->setFont(p->font());
shadowPainter->setPen(ctxShadow->m_color);
line.draw(shadowPainter, pt);
ctxShadow->endShadowLayer(ctx);
}
}
}
p->setPen(textFillPen);
line.draw(p, pt);
p->restore();
return;
}
int skipWidth = QFontMetrics(font).width(string, from, Qt::TextBypassShaping);
pt.setX(pt.x() + skipWidth);
string = fromRawDataWithoutRef(sanitized, from, to - from);
}
p->setFont(font);
int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
if (!isComplexText && !(ctx->textDrawingMode() & TextModeStroke))
flags |= Qt::TextBypassShaping;
QPainterPath textStrokePath;
if (ctx->textDrawingMode() & TextModeStroke)
textStrokePath.addText(pt, font, string);
ContextShadow* ctxShadow = ctx->contextShadow();
if (ctxShadow->m_type != ContextShadow::NoShadow) {
if (ctx->textDrawingMode() & TextModeFill) {
if (ctxShadow->m_type != ContextShadow::BlurShadow) {
p->save();
p->setPen(ctxShadow->m_color);
p->translate(ctxShadow->offset());
p->drawText(pt, string, flags, run.expansion());
p->restore();
} else {
QFontMetrics fm(font);
QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string, -1, flags), fm.height());
QPainter* shadowPainter = ctxShadow->beginShadowLayer(ctx, boundingRect);
if (shadowPainter) {
// Since it will be blurred anyway, we don't care about render hints.
shadowPainter->setFont(p->font());
shadowPainter->setPen(ctxShadow->m_color);
shadowPainter->drawText(pt, string, flags, run.expansion());
ctxShadow->endShadowLayer(ctx);
}
}
} else if (ctx->textDrawingMode() & TextModeStroke) {
if (ctxShadow->m_type != ContextShadow::BlurShadow) {
p->translate(ctxShadow->offset());
p->strokePath(textStrokePath, QPen(ctxShadow->m_color));
p->translate(-ctxShadow->offset());
} else {
QFontMetrics fm(font);
QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string, -1, flags), fm.height());
QPainter* shadowPainter = ctxShadow->beginShadowLayer(ctx, boundingRect);
if (shadowPainter) {
// Since it will be blurred anyway, we don't care about render hints.
shadowPainter->setFont(p->font());
shadowPainter->strokePath(textStrokePath, QPen(ctxShadow->m_color));
ctxShadow->endShadowLayer(ctx);
}
}
}
}
if (ctx->textDrawingMode() & TextModeStroke)
p->strokePath(textStrokePath, textStrokePen);
if (ctx->textDrawingMode() & TextModeFill) {
QPen previousPen = p->pen();
p->setPen(textFillPen);
p->drawText(pt, string, flags, run.expansion());
p->setPen(previousPen);
}
}
static void drawTextCommon(GraphicsContext* ctx, const TextRun& run, const FloatPoint& point, int from, int to, const QFont& font, bool isComplexText)
{
if (to < 0)
to = run.length();
QPainter *p = ctx->platformContext();
QPen textFillPen;
if (ctx->textDrawingMode() & TextModeFill) {
if (ctx->fillGradient()) {
QBrush brush(*ctx->fillGradient()->platformGradient());
brush.setTransform(ctx->fillGradient()->gradientSpaceTransform());
textFillPen = QPen(brush, 0);
} else if (ctx->fillPattern()) {
AffineTransform affine;
textFillPen = QPen(QBrush(ctx->fillPattern()->createPlatformPattern(affine)), 0);
} else
textFillPen = QPen(QColor(ctx->fillColor()));
}
QPen textStrokePen;
if (ctx->textDrawingMode() & TextModeStroke) {
if (ctx->strokeGradient()) {
QBrush brush(*ctx->strokeGradient()->platformGradient());
brush.setTransform(ctx->strokeGradient()->gradientSpaceTransform());
textStrokePen = QPen(brush, ctx->strokeThickness());
} else if (ctx->strokePattern()) {
AffineTransform affine;
QBrush brush(ctx->strokePattern()->createPlatformPattern(affine));
textStrokePen = QPen(brush, ctx->strokeThickness());
} else
textStrokePen = QPen(QColor(ctx->strokeColor()), ctx->strokeThickness());
}
String sanitized = Font::normalizeSpaces(String(run.characters(), run.length()));
QString string = fromRawDataWithoutRef(sanitized);
QPointF pt(point.x(), point.y());
if (from > 0 || to < run.length()) {
if (isComplexText) {
QTextLayout layout(string, font);
QTextLine line = setupLayout(&layout, run);
float x1 = line.cursorToX(from);
float x2 = line.cursorToX(to);
if (x2 < x1)
qSwap(x1, x2);
QFontMetrics fm(font);
int ascent = fm.ascent();
QRectF boundingRect(point.x() + x1, point.y() - ascent, x2 - x1, fm.height());
QRectF clip = boundingRect;
ContextShadow* ctxShadow = ctx->contextShadow();
if (ctxShadow->m_type != ContextShadow::NoShadow) {
qreal dx1 = 0, dx2 = 0, dy1 = 0, dy2 = 0;
if (ctxShadow->offset().x() > 0)
dx2 = ctxShadow->offset().x();
else
dx1 = -ctxShadow->offset().x();
if (ctxShadow->offset().y() > 0)
dy2 = ctxShadow->offset().y();
else
dy1 = -ctxShadow->offset().y();
// expand the clip rect to include the text shadow as well
clip.adjust(dx1, dx2, dy1, dy2);
clip.adjust(-ctxShadow->m_blurDistance, -ctxShadow->m_blurDistance, ctxShadow->m_blurDistance, ctxShadow->m_blurDistance);
}
p->save();
p->setClipRect(clip.toRect(), Qt::IntersectClip);
pt.setY(pt.y() - ascent);
if (ctxShadow->m_type != ContextShadow::NoShadow) {
ContextShadow* ctxShadow = ctx->contextShadow();
if (!ctxShadow->mustUseContextShadow(p)) {
p->save();
p->setPen(ctxShadow->m_color);
p->translate(ctxShadow->offset());
line.draw(p, pt);
p->restore();
} else {
QPainter* shadowPainter = ctxShadow->beginShadowLayer(p, boundingRect);
if (shadowPainter) {
// Since it will be blurred anyway, we don't care about render hints.
shadowPainter->setFont(p->font());
shadowPainter->setPen(ctxShadow->m_color);
line.draw(shadowPainter, pt);
ctxShadow->endShadowLayer(p);
}
}
}
p->setPen(textFillPen);
line.draw(p, pt);
p->restore();
return;
}
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
int skipWidth = QFontMetrics(font).width(string, from, Qt::TextBypassShaping);
pt.setX(pt.x() + skipWidth);
string = fromRawDataWithoutRef(sanitized, from, to - from);
#endif
}
p->setFont(font);
int flags = run.rtl() ? Qt::TextForceRightToLeft : Qt::TextForceLeftToRight;
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
// See QWebPagePrivate::QWebPagePrivate() where the default path is set to Complex for Qt 4.6 and earlier.
if (!isComplexText && !(ctx->textDrawingMode() & TextModeStroke))
flags |= Qt::TextBypassShaping;
#endif
QPainterPath textStrokePath;
if (ctx->textDrawingMode() & TextModeStroke)
textStrokePath.addText(pt, font, string);
ContextShadow* ctxShadow = ctx->contextShadow();
if (ctxShadow->m_type != ContextShadow::NoShadow) {
if (ctx->textDrawingMode() & TextModeFill) {
if (ctxShadow->m_type != ContextShadow::BlurShadow) {
p->save();
p->setPen(ctxShadow->m_color);
p->translate(ctxShadow->offset());
p->drawText(pt, string, flags, run.padding());
p->restore();
} else {
QFontMetrics fm(font);
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string, -1, flags), fm.height());
#else
QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string), fm.height());
#endif
QPainter* shadowPainter = ctxShadow->beginShadowLayer(p, boundingRect);
if (shadowPainter) {
// Since it will be blurred anyway, we don't care about render hints.
shadowPainter->setFont(p->font());
shadowPainter->setPen(ctxShadow->m_color);
shadowPainter->drawText(pt, string, flags, run.padding());
ctxShadow->endShadowLayer(p);
}
}
} else if (ctx->textDrawingMode() & TextModeStroke) {
if (ctxShadow->m_type != ContextShadow::BlurShadow) {
p->translate(ctxShadow->offset());
p->strokePath(textStrokePath, QPen(ctxShadow->m_color));
p->translate(-ctxShadow->offset());
} else {
QFontMetrics fm(font);
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string, -1, flags), fm.height());
#else
QRectF boundingRect(pt.x(), point.y() - fm.ascent(), fm.width(string), fm.height());
#endif
QPainter* shadowPainter = ctxShadow->beginShadowLayer(p, boundingRect);
if (shadowPainter) {
// Since it will be blurred anyway, we don't care about render hints.
shadowPainter->setFont(p->font());
shadowPainter->strokePath(textStrokePath, QPen(ctxShadow->m_color));
ctxShadow->endShadowLayer(p);
}
}
}
}
if (ctx->textDrawingMode() & TextModeStroke)
p->strokePath(textStrokePath, textStrokePen);
if (ctx->textDrawingMode() & TextModeFill) {
QPen previousPen = p->pen();
p->setPen(textFillPen);
p->drawText(pt, string, flags, run.padding());
p->setPen(previousPen);
}
}