File indexing completed on 2024-04-21 03:57:32

 /*
     SPDX-FileCopyrightText: 2002-2010 Anders Lund <anders@alweb.dk>
 
     Rewritten based on code of:
     SPDX-FileCopyrightText: 2002 Michael Goffioul <kdeprint@swing.be>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "printpainter.h"
 
 #include "katebuffer.h"
 #include "katedocument.h"
 #include "katehighlight.h"
 #include "katepartdebug.h"
 #include "katerenderer.h"
 #include "katetextfolding.h"
 #include "katetextlayout.h"
 #include "kateview.h"
 
 #include <KLocalizedString>
 #include <KUser>
 
 #include <QPainter>
 #include <QPrinter>
 
 using namespace KatePrinter;
 
 class KatePrinter::PageLayout
 {
 public:
     PageLayout()
         : headerTagList()
         , footerTagList()
         , selectionRange()
     {
     }
 
     uint pageWidth = 0;
     uint pageHeight = 0;
     uint headerWidth = 0;
     uint maxWidth = 0;
     uint maxHeight = 0;
     int xstart = 0; // beginning point for painting lines
     int innerMargin = 0;
 
     bool selectionOnly = false;
 
     uint firstline = 0;
     uint lastline = 0;
 
     // Header/Footer Page
     uint headerHeight = 0;
     QStringList headerTagList;
     uint footerHeight = 0;
     QStringList footerTagList;
 
     KTextEditor::Range selectionRange;
 };
 
 PrintPainter::PrintPainter(KTextEditor::DocumentPrivate *doc, KTextEditor::ViewPrivate *view)
     : m_view(view)
     , m_doc(doc)
     , m_printGuide(false)
     , m_printLineNumbers(false)
     , m_useHeader(false)
     , m_useFooter(false)
     , m_useBackground(false)
     , m_useBox(false)
     , m_useHeaderBackground(false)
     , m_useFooterBackground(false)
     , m_boxMargin(0)
     , m_boxWidth(1)
     , m_boxColor(Qt::black)
     , m_headerBackground(Qt::lightGray)
     , m_headerForeground(Qt::black)
     , m_footerBackground(Qt::lightGray)
     , m_footerForeground(Qt::black)
     , m_fhFont()
     , m_headerFormat()
     , m_footerFormat()
 {
     m_renderer = new KateRenderer(m_doc, m_view->renderer()->folding(), m_view);
     m_renderer->setPrinterFriendly(true);
 
     updateCache();
 }
 
 PrintPainter::~PrintPainter()
 {
     delete m_renderer;
 }
 
 void PrintPainter::setTextFont(const QFont &font)
 {
     m_view->rendererConfig()->setFont(font);
 }
 
 void PrintPainter::setUseBox(const bool on)
 {
     m_useBox = on;
     setBoxWidth(m_boxWidth); // reset the width
 }
 
 void PrintPainter::setBoxWidth(const int width)
 {
     if (m_useBox) {
         m_boxWidth = width;
         if (width < 1) {
             m_boxWidth = 1;
         }
     } else {
         m_boxWidth = 0;
     }
 }
 
 void PrintPainter::setBoxColor(const QColor &color)
 {
     if (color.isValid()) {
         m_boxColor = color;
     }
 }
 
 void PrintPainter::setHeaderBackground(const QColor &color)
 {
     if (color.isValid()) {
         m_headerBackground = color;
     }
 }
 
 void PrintPainter::setHeaderForeground(const QColor &color)
 {
     if (color.isValid()) {
         m_headerForeground = color;
     }
 }
 
 void PrintPainter::setFooterBackground(const QColor &color)
 {
     if (color.isValid()) {
         m_footerBackground = color;
     }
 }
 void PrintPainter::setFooterForeground(const QColor &color)
 {
     if (color.isValid()) {
         m_footerForeground = color;
     }
 }
 
 void PrintPainter::setColorScheme(const QString &scheme)
 {
     // directly set that for the renderer
     m_view->rendererConfig()->setSchema(scheme);
 
     // changed renderer requires cache updates
     updateCache();
 }
 
 void PrintPainter::updateCache()
 {
     m_fontHeight = m_renderer->fontHeight();
 
     // figure out the horizontal space required
     QString s = QStringLiteral("%1 ").arg(m_doc->lines());
     s.fill(QLatin1Char('5'), -1); // some non-fixed fonts haven't equally wide numbers
     // FIXME calculate which is actually the widest...
     m_lineNumberWidth = m_renderer->currentFontMetrics().boundingRect(s).width();
 }
 
 void PrintPainter::paint(QPrinter *printer) const
 {
     QPainter painter(printer);
     PageLayout pl;
 
     configure(printer, pl);
 
     uint lineCount = pl.firstline;
     uint y = 0;
     uint currentPage = (printer->fromPage() == 0) ? 1 : printer->fromPage();
     bool pageStarted = true;
     uint remainder = 0;
 
     auto &f = m_view->renderer()->folding();
 
     // On to draw something :-)
     while (lineCount <= pl.lastline) {
         if (y + m_fontHeight > pl.maxHeight) {
             if ((int)currentPage == printer->toPage()) { // we've reached the page break of last page to be printed
                 break;
             }
             printer->newPage();
             painter.resetTransform();
             currentPage++;
             pageStarted = true;
             y = 0;
         }
 
         if (pageStarted) {
             qCDebug(LOG_KTE) << "Starting new page," << lineCount << "lines up to now.";
             paintNewPage(painter, currentPage, y, pl);
             pageStarted = false;
             painter.translate(pl.xstart, y);
         }
 
         const bool skipLine = m_dontPrintFoldedCode && !f.isLineVisible(lineCount);
 
         if (!skipLine && m_printLineNumbers /*&& ! startCol*/) { // don't repeat!
             paintLineNumber(painter, lineCount, pl);
         }
 
         if (!skipLine) {
             paintLine(painter, lineCount, y, remainder, pl);
         }
 
         if (!remainder) {
             lineCount++;
         }
     }
 
     painter.end();
 }
 
 void PrintPainter::configure(const QPrinter *printer, PageLayout &pl) const
 {
     pl.pageHeight = printer->height();
     pl.pageWidth = printer->width();
     pl.headerWidth = printer->width();
     pl.innerMargin = m_useBox ? m_boxMargin : 6;
     pl.maxWidth = printer->width();
     pl.maxHeight = (m_useBox ? printer->height() - pl.innerMargin : printer->height());
     pl.selectionOnly = (printer->printRange() == QPrinter::Selection);
     pl.lastline = m_doc->lastLine();
 
     if (m_view && pl.selectionOnly) {
         // set a line range from the first selected line to the last
         pl.selectionRange = m_view->selectionRange();
         pl.firstline = pl.selectionRange.start().line();
         pl.lastline = pl.selectionRange.end().line();
     }
 
     if (m_printLineNumbers) {
         // a small space between the line numbers and the text
         int _adj = m_renderer->currentFontMetrics().horizontalAdvance(QStringLiteral("5"));
         // adjust available width and set horizontal start point for data
         pl.maxWidth -= m_lineNumberWidth + _adj;
         pl.xstart += m_lineNumberWidth + _adj;
     }
 
     if (m_useHeader || m_useFooter) {
         // Set up a tag map
         // This retrieves all tags, used or not, but
         // none of these operations should be expensive,
         // and searching each tag in the format strings is avoided.
         QDateTime dt = QDateTime::currentDateTime();
         std::map<QString, QString> tags;
 
         KUser u(KUser::UseRealUserID);
         tags[QStringLiteral("u")] = u.loginName();
 
         tags[QStringLiteral("d")] = QLocale().toString(dt, QLocale::ShortFormat);
         tags[QStringLiteral("D")] = QLocale().toString(dt, QLocale::LongFormat);
         tags[QStringLiteral("h")] = QLocale().toString(dt.time(), QLocale::ShortFormat);
         tags[QStringLiteral("y")] = QLocale().toString(dt.date(), QLocale::ShortFormat);
         tags[QStringLiteral("Y")] = QLocale().toString(dt.date(), QLocale::LongFormat);
         tags[QStringLiteral("f")] = m_doc->url().fileName();
         tags[QStringLiteral("U")] = m_doc->url().toString();
         if (pl.selectionOnly) {
             QString s(i18n("(Selection of) "));
             tags[QStringLiteral("f")].prepend(s);
             tags[QStringLiteral("U")].prepend(s);
         }
 
         static const QRegularExpression reTags(QStringLiteral("%([dDfUhuyY])")); // TODO check for "%%<TAG>"
 
         if (m_useHeader) {
             pl.headerHeight = QFontMetrics(m_fhFont).height();
             if (m_useBox || m_useHeaderBackground) {
                 pl.headerHeight += pl.innerMargin * 2;
             } else {
                 pl.headerHeight += 1 + QFontMetrics(m_fhFont).leading();
             }
 
             pl.headerTagList = m_headerFormat;
             QMutableStringListIterator it(pl.headerTagList);
             while (it.hasNext()) {
                 QString tag = it.next();
                 QRegularExpressionMatch match;
                 int pos = tag.indexOf(reTags, 0, &match);
                 QString rep;
                 while (pos > -1) {
                     rep = tags[match.captured(1)];
                     tag.replace((uint)pos, 2, rep);
                     pos += rep.length();
                     pos = tag.indexOf(reTags, pos, &match);
                 }
                 it.setValue(tag);
             }
         }
 
         if (m_useFooter) {
             pl.footerHeight = QFontMetrics(m_fhFont).height();
             if (m_useBox || m_useFooterBackground) {
                 pl.footerHeight += 2 * pl.innerMargin;
             } else {
                 pl.footerHeight += 1; // line only
             }
 
             pl.footerTagList = m_footerFormat;
             QMutableStringListIterator it(pl.footerTagList);
             while (it.hasNext()) {
                 QString tag = it.next();
                 QRegularExpressionMatch match;
                 int pos = tag.indexOf(reTags, 0, &match);
                 QString rep;
                 while (pos > -1) {
                     rep = tags[match.captured(1)];
                     tag.replace((uint)pos, 2, rep);
                     pos += rep.length();
                     pos = tag.indexOf(reTags, pos, &match);
                 }
                 it.setValue(tag);
             }
 
             pl.maxHeight -= pl.footerHeight;
         }
     } // if ( useHeader || useFooter )
 
     if (m_useBackground) {
         if (!m_useBox) {
             pl.xstart += pl.innerMargin;
             pl.maxWidth -= pl.innerMargin * 2;
         }
     }
 
     if (m_useBox) {
         // set maxwidth to something sensible
         pl.maxWidth -= (m_boxWidth + pl.innerMargin) * 2;
         pl.xstart += m_boxWidth + pl.innerMargin;
         // maxheight too..
         pl.maxHeight -= m_boxWidth;
     }
 
     int pageHeight = pl.maxHeight;
     if (m_useHeader) {
         pageHeight -= pl.headerHeight + pl.innerMargin;
     }
     if (m_useFooter) {
         pageHeight -= pl.footerHeight + pl.innerMargin;
     }
 
     const int linesPerPage = pageHeight / m_fontHeight;
 
     if (printer->fromPage() > 0) {
         pl.firstline = (printer->fromPage() - 1) * linesPerPage;
     }
 
     // now that we know the vertical amount of space needed,
     // it is possible to calculate the total number of pages
     // if needed, that is if any header/footer tag contains "%P".
     if (!pl.headerTagList.filter(QStringLiteral("%P")).isEmpty() || !pl.footerTagList.filter(QStringLiteral("%P")).isEmpty()) {
         qCDebug(LOG_KTE) << "'%P' found! calculating number of pages...";
 
         // calculate total layouted lines in the document
         int totalLines = 0;
         // TODO: right now ignores selection printing
         for (unsigned int i = pl.firstline; i <= pl.lastline; ++i) {
             KateLineLayout rangeptr(*m_renderer);
             rangeptr.setLine(i);
             m_renderer->layoutLine(&rangeptr, (int)pl.maxWidth, false);
             totalLines += rangeptr.viewLineCount();
         }
 
         const int totalPages = (totalLines / linesPerPage) + ((totalLines % linesPerPage) > 0 ? 1 : 0);
 
         // TODO: add space for guide if required
         //         if ( useGuide )
         //           _lt += (guideHeight + (fontHeight /2)) / fontHeight;
 
         // substitute both tag lists
         QString re(QStringLiteral("%P"));
         QStringList::Iterator it;
 
         for (it = pl.headerTagList.begin(); it != pl.headerTagList.end(); ++it) {
             it->replace(re, QString::number(totalPages));
         }
 
         for (it = pl.footerTagList.begin(); it != pl.footerTagList.end(); ++it) {
             (*it).replace(re, QString::number(totalPages));
         }
     }
 }
 
 void PrintPainter::paintNewPage(QPainter &painter, const uint currentPage, uint &y, const PageLayout &pl) const
 {
     if (m_useHeader) {
         paintHeader(painter, currentPage, y, pl);
     }
 
     if (m_useFooter) {
         paintFooter(painter, currentPage, pl);
     }
 
     if (m_useBackground) {
         paintBackground(painter, y, pl);
     }
 
     if (m_useBox) {
         paintBox(painter, y, pl);
     }
 
     if (m_printGuide && currentPage == 1) {
         paintGuide(painter, y, pl);
     }
 }
 
 void PrintPainter::paintHeader(QPainter &painter, const uint currentPage, uint &y, const PageLayout &pl) const
 {
     painter.save();
     painter.setPen(QPen(m_headerForeground, 0.5));
     painter.setFont(m_fhFont);
 
     if (m_useHeaderBackground) {
         painter.fillRect(0, 0, pl.headerWidth, pl.headerHeight, m_headerBackground);
     }
 
     if (pl.headerTagList.count() == 3) {
         int valign = (m_useBox || m_useHeaderBackground || m_useBackground) ? Qt::AlignVCenter : Qt::AlignTop;
         int align = valign | Qt::AlignLeft;
         int marg = (m_useBox || m_useHeaderBackground) ? pl.innerMargin : 0;
         if (m_useBox) {
             marg += m_boxWidth;
         }
 
         QString s;
         for (int i = 0; i < 3; i++) {
             s = pl.headerTagList[i];
             if (s.indexOf(QLatin1String("%p")) != -1) {
                 s.replace(QLatin1String("%p"), QString::number(currentPage));
             }
 
             painter.drawText(marg, 0, pl.headerWidth - (marg * 2), pl.headerHeight, align, s);
             align = valign | (i == 0 ? Qt::AlignHCenter : Qt::AlignRight);
         }
     }
 
     if (!(m_useHeaderBackground || m_useBox || m_useBackground)) { // draw a 1 px (!?) line to separate header from contents
         painter.drawLine(0, pl.headerHeight - 1, pl.headerWidth, pl.headerHeight - 1);
         // y += 1; now included in headerHeight
     }
 
     painter.restore();
 
     y += pl.headerHeight + pl.innerMargin;
 }
 
 void PrintPainter::paintFooter(QPainter &painter, const uint currentPage, const PageLayout &pl) const
 {
     painter.save();
     painter.setPen(QPen(m_footerForeground, 0.5));
     painter.setFont(m_fhFont);
 
     if (!(m_useFooterBackground || m_useBox || m_useBackground)) { // draw a 1 px (!?) line to separate footer from contents
         painter.drawLine(0, pl.pageHeight - pl.footerHeight - 1, pl.headerWidth, pl.pageHeight - pl.footerHeight - 1);
     }
     if (m_useFooterBackground) {
         painter.fillRect(0, pl.pageHeight - pl.footerHeight, pl.headerWidth, pl.footerHeight, m_footerBackground);
     }
 
     if (pl.footerTagList.count() == 3) {
         int align = Qt::AlignVCenter | Qt::AlignLeft;
         int marg = (m_useBox || m_useFooterBackground) ? pl.innerMargin : 0;
         if (m_useBox) {
             marg += m_boxWidth;
         }
 
         QString s;
         for (int i = 0; i < 3; i++) {
             s = pl.footerTagList[i];
             if (s.indexOf(QLatin1String("%p")) != -1) {
                 s.replace(QLatin1String("%p"), QString::number(currentPage));
             }
             painter.drawText(marg, pl.pageHeight - pl.footerHeight, pl.headerWidth - (marg * 2), pl.footerHeight, align, s);
             align = Qt::AlignVCenter | (i == 0 ? Qt::AlignHCenter : Qt::AlignRight);
         }
     }
     painter.restore();
 }
 
 void PrintPainter::paintGuide(QPainter &painter, uint &y, const PageLayout &pl) const
 {
     // FIXME - this may span more pages...
     // draw a box unless we have boxes, in which case we end with a box line
     int _ystart = y;
     QString _hlName = m_doc->highlight()->name();
 
     // list of highlight attributes for the legend
     const auto _attributes = m_doc->highlight()->attributesForDefinition(m_view->rendererConfig()->schema());
     const QColor _defaultPen = _attributes.at(0)->foreground().color();
 
     painter.save();
     painter.setPen(_defaultPen);
 
     int _marg = 0;
     if (m_useBox) {
         _marg += (2 * m_boxWidth) + (2 * pl.innerMargin);
     } else {
         if (m_useBackground) {
             _marg += 2 * pl.innerMargin;
         }
         _marg += 1;
         y += 1 + pl.innerMargin;
     }
 
     // draw a title string
     QFont _titleFont = m_renderer->currentFont();
     _titleFont.setBold(true);
     painter.setFont(_titleFont);
     QRect _r;
     painter.drawText(QRect(_marg, y, pl.pageWidth - (2 * _marg), pl.maxHeight - y),
                      Qt::AlignTop | Qt::AlignHCenter,
                      i18n("Typographical Conventions for %1", _hlName),
                      &_r);
     const int _w = pl.pageWidth - (_marg * 2) - (pl.innerMargin * 2);
     const int _x = _marg + pl.innerMargin;
     y += _r.height() + pl.innerMargin;
     painter.drawLine(_x, y, _x + _w, y);
     y += 1 + pl.innerMargin;
 
     int _widest(0);
     for (const KTextEditor::Attribute::Ptr &attribute : std::as_const(_attributes)) {
         const QString _name = attribute->name().section(QLatin1Char(':'), 1, 1);
         _widest = qMax(QFontMetrics(attribute->font()).boundingRect(_name).width(), _widest);
     }
 
     const int _guideCols = _w / (_widest + pl.innerMargin);
 
     // draw attrib names using their styles
     const int _cw = _w / _guideCols;
     int _i = 0;
 
     _titleFont.setUnderline(true);
     QString _currentHlName;
     for (const KTextEditor::Attribute::Ptr &attribute : std::as_const(_attributes)) {
         QString _hl = attribute->name().section(QLatin1Char(':'), 0, 0);
         QString _name = attribute->name().section(QLatin1Char(':'), 1, 1);
         if (_hl != _hlName && _hl != _currentHlName) {
             _currentHlName = _hl;
             if (_i % _guideCols) {
                 y += m_fontHeight;
             }
             y += pl.innerMargin;
             painter.setFont(_titleFont);
             painter.setPen(_defaultPen);
             painter.drawText(_x, y, _w, m_fontHeight, Qt::AlignTop, _hl + QLatin1Char(' ') + i18n("text"));
             y += m_fontHeight;
             _i = 0;
         }
 
         painter.setPen(attribute->foreground().color());
         painter.setFont(attribute->font());
 
         if (attribute->hasProperty(QTextFormat::BackgroundBrush)) {
             QRect _rect = QFontMetrics(attribute->font()).boundingRect(_name);
             _rect.moveTo(_x + ((_i % _guideCols) * _cw), y);
             painter.fillRect(_rect, attribute->background());
         }
 
         painter.drawText((_x + ((_i % _guideCols) * _cw)), y, _cw, m_fontHeight, Qt::AlignTop, _name);
 
         _i++;
         if (_i && !(_i % _guideCols)) {
             y += m_fontHeight;
         }
     }
 
     if (_i % _guideCols) {
         y += m_fontHeight; // last row not full
     }
     // draw a box around the legend
     painter.setPen(_defaultPen);
 
     if (m_useBox) {
         painter.fillRect(0, y + pl.innerMargin, pl.headerWidth, m_boxWidth, m_boxColor);
     } else {
         _marg -= 1;
         painter.drawRect(_marg, _ystart, pl.pageWidth - (2 * _marg), y - _ystart + pl.innerMargin);
     }
 
     painter.restore();
 
     y += (m_useBox ? m_boxWidth : 1) + (pl.innerMargin * 2);
 }
 
 void PrintPainter::paintBox(QPainter &painter, uint &y, const PageLayout &pl) const
 {
     painter.save();
     painter.setPen(QPen(m_boxColor, m_boxWidth));
     painter.drawRect(0, 0, pl.pageWidth, pl.pageHeight);
 
     if (m_useHeader) {
         painter.drawLine(0, pl.headerHeight, pl.headerWidth, pl.headerHeight);
     } else {
         y += pl.innerMargin;
     }
 
     if (m_useFooter) { // drawline is not trustable, grr.
         painter.fillRect(0, pl.maxHeight + pl.innerMargin, pl.headerWidth, m_boxWidth, m_boxColor);
     }
 
     painter.restore();
 }
 
 void PrintPainter::paintBackground(QPainter &painter, const uint y, const PageLayout &pl) const
 {
     // If we have a box, or the header/footer has backgrounds, we want to paint
     // to the border of those. Otherwise just the contents area.
     int _y = y;
     int _h = pl.maxHeight - y;
     if (m_useBox) {
         _y -= pl.innerMargin;
         _h += 2 * pl.innerMargin;
     } else {
         if (m_useHeaderBackground) {
             _y -= pl.innerMargin;
             _h += pl.innerMargin;
         }
         if (m_useFooterBackground) {
             _h += pl.innerMargin;
         }
     }
     painter.fillRect(0, _y, pl.pageWidth, _h, m_view->rendererConfig()->backgroundColor());
 }
 
 void PrintPainter::paintLine(QPainter &painter, const uint line, uint &y, uint &remainder, const PageLayout &pl) const
 {
     // HA! this is where we print [part of] a line ;]]
     KateLineLayout rangeptr(*m_renderer);
     rangeptr.setLine(line);
     m_renderer->layoutLine(&rangeptr, (int)pl.maxWidth, false);
 
     // selectionOnly: clip non-selection parts and adjust painter position if needed
     int _xadjust = 0;
     if (pl.selectionOnly) {
         if (m_view && m_view->blockSelection()) {
             int _x = m_renderer->cursorToX(rangeptr.viewLine(0), pl.selectionRange.start());
             int _x1 = m_renderer->cursorToX(rangeptr.viewLine(rangeptr.viewLineCount() - 1), pl.selectionRange.end());
             _xadjust = _x;
             painter.translate(-_xadjust, 0);
             painter.setClipRegion(QRegion(_x, 0, _x1 - _x, rangeptr.viewLineCount() * m_fontHeight));
 
         } else if (line == pl.firstline || line == pl.lastline) {
             QRegion region(0, 0, pl.maxWidth, rangeptr.viewLineCount() * m_fontHeight);
 
             if (line == pl.firstline) {
                 region = region.subtracted(QRegion(0, 0, m_renderer->cursorToX(rangeptr.viewLine(0), pl.selectionRange.start()), m_fontHeight));
             }
 
             if (line == pl.lastline) {
                 int _x = m_renderer->cursorToX(rangeptr.viewLine(rangeptr.viewLineCount() - 1), pl.selectionRange.end());
                 region = region.subtracted(QRegion(_x, 0, pl.maxWidth - _x, m_fontHeight));
             }
 
             painter.setClipRegion(region);
         }
     }
 
     // If the line is too long (too many 'viewlines') to fit the remaining vertical space,
     // clip and adjust the painter position as necessary
     int _lines = rangeptr.viewLineCount(); // number of "sublines" to paint.
 
     int proceedLines = _lines;
     if (remainder) {
         proceedLines = qMin((pl.maxHeight - y) / m_fontHeight, remainder);
 
         painter.translate(0, -(_lines - int(remainder)) * m_fontHeight + 1);
         painter.setClipRect(0,
                             (_lines - int(remainder)) * m_fontHeight + 1,
                             pl.maxWidth,
                             proceedLines * m_fontHeight); // ### drop the crosspatch in printerfriendly mode???
         remainder -= proceedLines;
     } else if (y + m_fontHeight * _lines > pl.maxHeight) {
         remainder = _lines - ((pl.maxHeight - y) / m_fontHeight);
         painter.setClipRect(0, 0, pl.maxWidth, (_lines - int(remainder)) * m_fontHeight + 1); // ### drop the crosspatch in printerfriendly mode???
     } else if (!pl.selectionOnly) {
         painter.setClipRegion(QRegion());
         painter.setClipping(false);
     }
 
     KateRenderer::PaintTextLineFlags flags;
     if (!m_dontPrintFoldedCode) {
         flags.setFlag(KateRenderer::PaintTextLineFlag::SkipDrawFirstInvisibleLineUnderlined);
     }
 
     m_renderer->paintTextLine(painter, &rangeptr, 0, (int)pl.maxWidth, QRectF{}, nullptr, flags);
 
     painter.setClipping(false);
     painter.translate(_xadjust, (m_fontHeight * (_lines - remainder)));
 
     y += m_fontHeight * proceedLines;
 }
 
 void PrintPainter::paintLineNumber(QPainter &painter, const uint number, const PageLayout &pl) const
 {
     const int left = ((m_useBox || m_useBackground) ? pl.innerMargin : 0) - pl.xstart;
 
     painter.save();
     painter.setFont(m_renderer->currentFont());
     painter.setPen(m_view->rendererConfig()->lineNumberColor());
     painter.drawText(left, 0, m_lineNumberWidth, m_fontHeight, Qt::AlignRight | Qt::AlignVCenter, QString::number(number + 1));
     painter.restore();
 }
 
 // END PrintPainter