KD Reports API Documentation  2.0
KDReportsReport.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** This file is part of the KD Reports library.
4 **
5 ** SPDX-FileCopyrightText: 2007-2022 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
6 **
7 ** SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDAB-KDReports OR LicenseRef-KDAB-KDReports-US
8 **
9 ** Licensees holding valid commercial KD Reports licenses may use this file in
10 ** accordance with the KD Reports Commercial License Agreement provided with
11 ** the Software.
12 **
13 ** Contact info@kdab.com if any conditions of this licensing are not clear to you.
14 **
15 ****************************************************************************/
16 
17 #include "KDReportsReport.h"
18 #include "KDReportsReport_p.h"
19 #include "KDReportsElement.h"
20 #include "KDReportsHeader.h"
22 #include "KDReportsMainTable.h"
25 #include "KDReportsXmlParser_p.h"
26 
27 #include <QAbstractTextDocumentLayout>
28 #include <QApplication>
29 #include <QDebug>
30 #include <QDomDocument>
31 #include <QDomElement>
32 #include <QFile>
33 #include <QMap>
34 #include <QPainter>
35 #include <QPointer>
36 #include <QPrintDialog>
37 #include <QProgressDialog>
38 #include <QStyle>
39 #include <QStyleOption>
40 #include <QThread>
41 
42 #include <memory>
43 
44 QT_BEGIN_NAMESPACE
45 Q_GUI_EXPORT extern int qt_defaultDpi(); // This is what QTextDocument uses...
46 QT_END_NAMESPACE
47 
49  : m_layoutWidth(0)
50  , m_endlessPrinterWidth(0)
51  , m_orientation(QPageLayout::Portrait)
52  , m_pageSize(QPageSize::A4)
53  , m_marginTop(20.0)
54  , // warning, defaults are duplicated in KDReportsXmlParser.cpp
55  m_marginLeft(20.0)
56  , m_marginBottom(20.0)
57  , m_marginRight(20.0)
58  , m_headerBodySpacing(0)
59  , m_footerBodySpacing(0)
60  , m_headers()
61  , m_footers()
62  , m_watermarkRotation(0)
63  , m_watermarkColor(QColor(204, 204, 204))
64  , m_watermarkFont(QFont(QStringLiteral("Helvetica"), 48))
65  , m_watermarkImage()
66  ,
67 #if 0
68  m_numHorizontalPages( 1 ),
69  m_numVerticalPages( 0 ),
70  m_scaleFontsBy( 1.0 ),
71  m_autoScale( false ),
72  m_tableBreakingPageOrder( KDReports::Report::DownThenRight ),
73 #endif
74  m_firstPageNumber(1)
75  , m_pageContentSizeDirty(true)
76  , m_xmlElementHandler(nullptr)
77  , m_currentRow(-1)
78  , m_currentModel(nullptr)
79  , m_reportMode(KDReports::Report::WordProcessing)
80  , m_layout(new TextDocReportLayout(report))
81  , m_mainTable(new MainTable)
82  , q(report)
83 {
84 }
85 
87 {
88  delete m_layout;
89  delete m_mainTable;
90 }
91 
93 {
94  return m_layoutWidth > 0;
95 }
96 
98 {
99  // determine m_paperSize from m_pageSize if needed
100  if (m_paperSize.isEmpty()) {
101  const auto mmSize = m_pageSize.size(QPageSize::Millimeter);
102  m_paperSize = QSizeF{mmToPixels(mmSize.width()), mmToPixels(mmSize.height())};
103  if (m_orientation == QPageLayout::Landscape) {
104  m_paperSize.transpose();
105  }
106  }
107  // qDebug() << "m_paperSize=" << m_paperSize;
108  return m_paperSize;
109 }
110 
112 {
113  // We need to do a layout if
114  // m_pageContentSizeDirty is true, i.e. page size has changed etc.
115  if (m_pageContentSizeDirty) {
116  if (!wantEndlessPrinting()) {
117  setPaperSizeFromPrinter(paperSize());
118  } else {
119  // Get the document to fit into one page
120  Q_ASSERT(m_layoutWidth != 0);
121  qreal textDocWidth = m_layoutWidth - mmToPixels(m_marginLeft + m_marginRight);
122  m_paperSize = layoutAsOnePage(textDocWidth);
123 
124  qDebug() << "setPaperSizeFromPrinter: endless printer. m_layoutWidth=" << m_layoutWidth << "textDocWidth=" << textDocWidth << "single page has size" << m_paperSize << "pixels";
125 
126  /* cppcheck-suppress assertWithSideEffect */
127  Q_ASSERT(m_layout->numberOfPages() == 1);
128  }
129  // at this point m_pageContentSizeDirty has been set to false in all cases
130  }
131 
132  m_layout->ensureLayouted();
133 }
134 
135 // The height of the text doc, by calculation. Adjusted by caller, if negative.
137 {
138  qreal textDocHeight = paperSize().height() - mmToPixels(m_marginTop + m_marginBottom);
139  const qreal headerHeight = m_headers.height();
140  textDocHeight -= headerHeight;
141  textDocHeight -= mmToPixels(m_headerBodySpacing);
142  const qreal footerHeight = m_footers.height();
143  textDocHeight -= mmToPixels(m_footerBodySpacing);
144  textDocHeight -= footerHeight;
145  // qDebug() << "pageContent height (pixels): paper size" << m_paperSize.height() << "minus margins" << mmToPixels( m_marginTop + m_marginBottom )
146  // << "minus headerHeight" << headerHeight << "minus footerHeight" << footerHeight << "and spacings =" << textDocHeight;
147  return textDocHeight;
148 }
149 
151 {
152  const bool skip = rawMainTextDocHeight() <= 0;
153  if (skip) {
154  qDebug() << "Not enough height for headers and footers in this page size, hiding headers and footers.";
155  }
156  return skip;
157 }
158 
160 {
161  const qreal height = rawMainTextDocHeight();
162  const bool skip = height <= 0;
163  if (skip) {
164  qreal textDocHeight = paperSize().height() - mmToPixels(m_marginTop + m_marginBottom);
165  textDocHeight -= mmToPixels(m_headerBodySpacing);
166  textDocHeight -= mmToPixels(m_footerBodySpacing);
167  return textDocHeight;
168  }
169  return height;
170 }
171 
173 {
174  const int left = qRound(mmToPixels(m_marginLeft));
175  const int top = qRound(mmToPixels(m_marginTop));
176  const int headerHeightWithSpacing = qRound((skipHeadersFooters() ? 0 : m_headers.height()) + mmToPixels(m_headerBodySpacing));
177  const int textDocWidth = qRound(m_paperSize.width() - mmToPixels(m_marginLeft + m_marginRight));
178  const int textDocHeight = qRound(mainTextDocHeight());
179  return {left, top + headerHeightWithSpacing, textDocWidth, textDocHeight};
180 }
181 
182 /*
183  [top margin]
184  [header]
185  [m_headerBodySpacing]
186  [body]
187  [m_footerBodySpacing]
188  [footer]
189  [bottom margin]
190  */
192 {
193  Q_ASSERT(!wantEndlessPrinting()); // call ensureLayouted instead!
194 
195  m_paperSize = paperSize;
196  const qreal marginsInPixels = mmToPixels(m_marginLeft + m_marginRight);
197  qreal textDocWidth = m_paperSize.width() - marginsInPixels;
198 
199  m_headers.layoutWithTextWidth(textDocWidth);
200  m_footers.layoutWithTextWidth(textDocWidth);
201 
202  const qreal textDocHeight = mainTextDocHeight();
203 
204  // Font scaling
205  // Problem: how to re-implement this without a layout document?
206  // We would risk cumulating rounding problems...?
207  // ### 2nd problem: what about fonts in headers and footers? shouldn't they scale too?
208  // if ( m_scaleFontsBy != 1.0 )
209  // m_textDocument.scaleFontsBy( m_scaleFontsBy );
210 
211  m_layout->setPageContentSize(QSizeF(textDocWidth, textDocHeight));
212 
213  m_pageContentSizeDirty = false;
214 }
215 
216 KDReports::Header *KDReports::HeaderMap::headerForPage(int pageNumber /* 1-based */, int pageCount) const
217 {
218  Header *firstPageHeader = nullptr;
219  Header *lastPageHeader = nullptr;
220  Header *evenPagesHeader = nullptr;
221  Header *oddPagesHeader = nullptr;
222  for (const_iterator it = begin(); it != end(); ++it) {
223  const KDReports::HeaderLocations loc = it.key();
224  Header *const h = it.value();
225  if (loc & KDReports::FirstPage)
226  firstPageHeader = h;
227  if (loc & KDReports::LastPage)
228  lastPageHeader = h;
229  if (loc & KDReports::EvenPages)
230  evenPagesHeader = h;
231  if (loc & KDReports::OddPages)
232  oddPagesHeader = h;
233  }
234  if (pageNumber == 1 && firstPageHeader)
235  return firstPageHeader;
236  if (pageNumber == pageCount && lastPageHeader)
237  return lastPageHeader;
238  if (pageNumber & 1) // odd
239  return oddPagesHeader;
240  else // even
241  return evenPagesHeader;
242 }
243 
244 //@cond PRIVATE
245 KDReports::HeaderLocations KDReports::HeaderMap::headerLocation(Header *header) const
246 {
247  for (const_iterator it = begin(); it != end(); ++it) {
248  const KDReports::HeaderLocations loc = it.key();
249  Header *const h = it.value();
250  if (h == header) {
251  return loc;
252  }
253  }
254  KDReports::HeaderLocations loc;
255  return loc;
256 }
257 
258 void KDReports::ReportPrivate::paintPage(int pageNumber, QPainter &painter)
259 {
260  ensureLayouted();
261 
262  const int pageCount = m_layout->numberOfPages();
263  KDReports::Header *header = m_headers.headerForPage(pageNumber + 1, pageCount);
264  if (header) {
265  header->preparePaintingPage(pageNumber + m_firstPageNumber - 1);
266  }
267  KDReports::Header *footer = m_footers.headerForPage(pageNumber + 1, pageCount);
268  if (footer) {
269  footer->preparePaintingPage(pageNumber + m_firstPageNumber - 1);
270  }
271 
272  const QRect textDocRect = mainTextDocRect();
273  const bool skipHeadersFooters = this->skipHeadersFooters();
274 
275  /*qDebug() << "paintPage: in pixels: top=" << top << " headerHeight=" << headerHeightWithSpacing
276  << " textDoc size:" << textDocRect.size()
277  << " bottom=" << bottom << " footerHeight=" << footerHeight;*/
278 
279  if (!m_watermarkText.isEmpty()) {
280  painter.save();
281  painter.translate(textDocRect.center());
282  painter.rotate(m_watermarkRotation);
283  painter.setFont(m_watermarkFont);
284  painter.setPen(m_watermarkColor);
285  const QSize textSize(painter.fontMetrics().size(Qt::TextSingleLine, m_watermarkText));
286  const QRect textRect(-textSize.width() / 2, -textSize.height() / 2, textSize.width(), textSize.height());
287  painter.drawText(textRect, Qt::AlignCenter, m_watermarkText);
288  painter.restore();
289  }
290 
291  if (!m_watermarkImage.isNull()) {
292  // We paint it without scaling it, for better quality.
293  // But this means the actual size depends on the zoom level or printer resolution...
294  //
295  // It also means the image could end up being bigger than the page, and we don't want that.
296  // So we scale down if necessary. But never up.
297  QImage img = m_watermarkImage;
298  if (m_watermarkImage.width() > textDocRect.width() || m_watermarkImage.height() > textDocRect.height()) {
299  // should probably be cached?
300  img = m_watermarkImage.scaled(textDocRect.size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
301  }
302  const QRect imageRect = QStyle::alignedRect(Qt::LeftToRight, Qt::AlignCenter, img.size(), textDocRect);
303  // qDebug() << "textDocRect=" << textDocRect << "size=" << img.size() << "-> imageRect=" << imageRect;
304  painter.drawImage(imageRect.topLeft(), img);
305  }
306 
307  painter.save();
308  // painter.setClipRect( textDocRect, Qt::IntersectClip ); // triggers a Qt-Windows bug when printing
309  painter.setClipRect(textDocRect);
310  painter.translate(textDocRect.topLeft());
311  m_layout->paintPageContent(pageNumber, painter);
312  painter.restore();
313 
314  QAbstractTextDocumentLayout::PaintContext ctx;
315  ctx.palette.setColor(QPalette::Text, Qt::black);
316  if (header && !skipHeadersFooters) {
317  painter.save();
318  const int top = qRound(mmToPixels(m_marginTop));
319  painter.translate(textDocRect.left(), top);
320  ctx.clip = painter.clipRegion().boundingRect();
321  header->doc().contentDocument().documentLayout()->draw(&painter, ctx);
322  painter.restore();
323  }
324  if (footer && !skipHeadersFooters) {
325  painter.save();
326  const int bottom = qRound(mmToPixels(m_marginBottom));
327  const int footerHeight = qRound(m_footers.height());
328  painter.translate(textDocRect.left(), m_paperSize.height() - bottom - footerHeight);
329  ctx.clip = painter.clipRegion().boundingRect();
330  footer->doc().contentDocument().documentLayout()->draw(&painter, ctx);
331  painter.restore();
332  }
333 }
334 //@endcond
335 
337 {
338  m_headers.layoutWithTextWidth(docWidth);
339  m_footers.layoutWithTextWidth(docWidth);
340 
341  const qreal docHeight = m_layout->layoutAsOnePage(docWidth);
342 
343  qreal pageWidth = docWidth + mmToPixels(m_marginLeft + m_marginRight);
344  qreal pageHeight = docHeight + mmToPixels(m_marginTop + m_marginBottom);
345  pageHeight += m_headers.height();
346  pageHeight += m_footers.height();
347 
348  m_pageContentSizeDirty = false;
349 
350  // qDebug() << "One-page document is" << pageWidth << "x" << pageHeight;
351  return QSizeF(pageWidth, pageHeight);
352 }
353 
355 {
356  m_pageContentSizeDirty = true;
357 }
358 
359 bool KDReports::ReportPrivate::doPrint(QPrinter *printer, QWidget *parent)
360 {
361  // caller has to ensure that we have been layouted for this printer already
362  const int pageCount = m_layout->numberOfPages();
363  std::unique_ptr<QProgressDialog> dialog;
364  if (QThread::currentThread() == qApp->thread()) {
365  dialog.reset(new QProgressDialog(QObject::tr("Printing"), QObject::tr("Cancel"), 0, pageCount, parent));
366  dialog->setWindowModality(Qt::ApplicationModal);
367  }
368  QPainter painter;
369  if (!painter.begin(printer)) {
370  qWarning() << "QPainter failed to initialize on the given printer";
371  return false;
372  }
373 
374  int fromPage = 0;
375  int toPage = pageCount;
376  if (printer->printRange() == QPrinter::PageRange) {
377  fromPage = printer->fromPage() - 1; // it starts at 1
378  toPage = printer->toPage(); // -1 because it starts at 1, and +1 because of '<'
379  if (toPage == 0)
380  toPage = pageCount;
381  }
382 
383  bool firstPage = true;
384  for (int pageIndex = fromPage; pageIndex < toPage; ++pageIndex) {
385  if (dialog) {
386  dialog->setValue(pageIndex);
387  if (dialog->wasCanceled())
388  break;
389  }
390 
391  if (!firstPage)
392  printer->newPage();
393 
394  paintPage(pageIndex, painter);
395  firstPage = false;
396  }
397 
398  return true;
399 }
400 
401 #ifndef NDEBUG
403 {
404  // for calling from gdb
405 
406  QFile html(QFile::decodeName(fileName) + QStringLiteral(".html"));
407  Q_ASSERT(html.open(QIODevice::WriteOnly));
408  const QString htmlText = m_layout->toHtml();
409  html.write(htmlText.toUtf8());
410  html.close();
411 
412  bool oldLayoutDirty = true;
413  m_pageContentSizeDirty = false;
414  QPrinter printer;
415  q->setupPrinter(&printer);
416  printer.setOutputFileName(QFile::decodeName(fileName));
417  doPrint(&printer, nullptr);
418  printer.setOutputFileName(QString());
419  m_pageContentSizeDirty = oldLayoutDirty;
420 }
421 #endif
422 
423 typedef QMap<QString, QAbstractItemModel *> ModelMap;
424 Q_GLOBAL_STATIC(ModelMap, globalModelMap)
425 
426 QAbstractItemModel *KDReports::modelForKey(const QString &key)
427 {
428  return globalModelMap()->value(key, 0);
429 }
430 
432 {
433  return paperSize().width() - mmToPixels(m_marginLeft + m_marginRight);
434 }
435 
437 {
438  if (m_reportMode == KDReports::Report::WordProcessing)
439  return static_cast<TextDocReportLayout *>(m_layout)->builder();
440  return nullptr;
441 }
442 
444 
446  : QObject(parent)
447  , d(new ReportPrivate(this))
448 {
449  setPageSize(QPageSize::A4);
450 }
451 
453 {
454  delete d;
455 }
456 
458 {
459  if (d->m_reportMode != WordProcessing) {
460  qWarning("KDReports: addInlineElement is only supported in WordProcessing mode");
461  } else {
462  d->builder()->addInlineElementPublic(element);
463  // don't add anything else here, it won't be called from the xml parser
464  }
465 }
466 
467 void KDReports::Report::addElement(const Element &element, Qt::AlignmentFlag horizontalAlignment, const QColor &backgroundColor)
468 {
469  if (d->m_reportMode != WordProcessing) {
470  qWarning("KDReports: addElement is only supported in WordProcessing mode");
471  } else {
472  d->builder()->addBlockElementPublic(element, horizontalAlignment, backgroundColor);
473  // don't add anything else here, it won't be called from the xml parser
474  }
475 }
476 
478 {
479  if (d->m_reportMode != WordProcessing) {
480  qWarning("KDReports: addVerticalSpacing is only supported in WordProcessing mode");
481  } else {
482  d->builder()->addVerticalSpacingPublic(space);
483  }
484 }
485 
486 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
487 void KDReports::Report::setPageSize(QPrinter::PageSize size)
488 {
489  setPageSize(static_cast<QPageSize::PageSizeId>(size));
490 }
491 #endif
492 
493 void KDReports::Report::setPageSize(QPageSize::PageSizeId size)
494 {
495  setPageSize(QPageSize{size});
496 }
497 
498 void KDReports::Report::setPageSize(const QPageSize &size)
499 {
500  d->m_pageSize = size;
501  d->m_paperSize = QSizeF();
502  d->m_pageContentSizeDirty = true;
503 }
504 
506 {
507  qreal factor = 1.0;
508  switch (unit) {
509  case QPrinter::DevicePixel:
510  break;
511  case QPrinter::Millimeter:
512  factor = mmToPixels(1.0);
513  break;
514  case QPrinter::Point:
515  factor = 72.0 * qt_defaultDpi();
516  break;
517  case QPrinter::Inch:
518  factor = qt_defaultDpi();
519  break;
520  default:
521  qWarning("Unsupported printer unit %d", unit);
522  }
523  d->m_paperSize = QSizeF(paperSize.width() * factor, paperSize.height() * factor);
524  d->m_pageContentSizeDirty = true;
525 }
526 
527 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
528 QPrinter::PageSize KDReports::Report::pageSize() const
529 {
530  return static_cast<QPrinter::PageSize>(d->m_pageSize.id());
531 }
532 #else
534 {
535  return d->m_pageSize;
536 }
537 #endif
538 
539 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
540 void KDReports::Report::setOrientation(QPrinter::Orientation orientation)
541 {
542  d->m_orientation = static_cast<QPageLayout::Orientation>(orientation);
543  d->m_paperSize = QSizeF();
544  d->m_pageContentSizeDirty = true;
545 }
546 
547 QPrinter::Orientation KDReports::Report::orientation() const
548 {
549  return static_cast<QPrinter::Orientation>(d->m_orientation);
550 }
551 #endif
552 
553 void KDReports::Report::setPageOrientation(QPageLayout::Orientation orientation)
554 {
555  d->m_orientation = orientation;
556  d->m_paperSize = QSizeF();
557  d->m_pageContentSizeDirty = true;
558 }
559 
560 QPageLayout::Orientation KDReports::Report::pageOrientation() const
561 {
562  return d->m_orientation;
563 }
564 
565 void KDReports::Report::setMargins(qreal top, qreal left, qreal bottom, qreal right)
566 {
567  d->m_marginTop = top;
568  d->m_marginLeft = left;
569  d->m_marginBottom = bottom;
570  d->m_marginRight = right;
571 
572  // We'll need to call setPaperSizeFromPrinter, to update % sizes in all text documents.
573  d->m_pageContentSizeDirty = true;
574 }
575 
576 void KDReports::Report::getMargins(qreal *top, qreal *left, qreal *bottom, qreal *right) const
577 {
578  *top = d->m_marginTop;
579  *left = d->m_marginLeft;
580  *bottom = d->m_marginBottom;
581  *right = d->m_marginRight;
582 }
583 
585 {
586  d->m_marginLeft = left;
587 
588  // We'll need to call setPaperSizeFromPrinter, to update % sizes in all text documents.
589  d->m_pageContentSizeDirty = true;
590 }
591 
593 {
594  return d->m_marginLeft;
595 }
596 
598 {
599  d->m_marginRight = right;
600 
601  // We'll need to call setPaperSizeFromPrinter, to update % sizes in all text documents.
602  d->m_pageContentSizeDirty = true;
603 }
604 
606 {
607  return d->m_marginRight;
608 }
609 
611 {
612  d->m_marginTop = top;
613 
614  // We'll need to call setPaperSizeFromPrinter, to update % sizes in all text documents.
615  d->m_pageContentSizeDirty = true;
616 }
617 
619 {
620  return d->m_marginTop;
621 }
622 
624 {
625  d->m_marginBottom = bottom;
626 
627  // We'll need to call setPaperSizeFromPrinter, to update % sizes in all text documents.
628  d->m_pageContentSizeDirty = true;
629 }
630 
632 {
633  return d->m_marginBottom;
634 }
635 
637 {
638  if (widthMM) {
639  d->m_endlessPrinterWidth = widthMM;
640  d->m_layoutWidth = mmToPixels(widthMM);
641  d->m_pageContentSizeDirty = true;
642  d->ensureLayouted();
643  } else {
644  d->m_layoutWidth = 0;
645  d->m_pageContentSizeDirty = true;
646  // caller will call setPageSize...
647  }
648 }
649 
650 void KDReports::Report::paintPage(int pageNumber, QPainter &painter)
651 {
652  d->paintPage(pageNumber, painter);
653 }
654 
656 {
657  d->ensureLayouted();
658  return d->m_layout->numberOfPages();
659 }
660 
662 {
663  qDebug() << asHtml();
664 }
665 
666 QString KDReports::Report::asHtml() const
667 {
668  return d->m_layout->toHtml();
669 }
670 
672 {
673  QPrinter printer;
674  setupPrinter(&printer);
675  QPointer<QPrintDialog> dialog = new QPrintDialog(&printer, parent);
676  dialog->setMinMax(1, numberOfPages());
677  bool ok = false;
678  if (dialog->exec() == QDialog::Accepted) {
679  // Well, the user can modify the page size in the printer dialog too - ensure layout matches
680  d->ensureLayouted();
681  ok = d->doPrint(&printer, parent);
682  }
683  delete dialog;
684  return ok;
685 }
686 
687 bool KDReports::Report::print(QPrinter *printer, QWidget *parent)
688 {
689  // save the old page size
690  const auto savePageSize = pageSize();
691  if (d->wantEndlessPrinting()) {
692  // ensure that the printer is set up with the right size
693  d->ensureLayouted();
694  // was: printer->setPaperSize(d->m_paperSize, QPrinter::DevicePixel);
695  printer->setPageSize(QPageSize(d->m_paperSize * pixelsToPointsMultiplier(printer->resolution()), QPageSize::Point));
696 
697  } else {
698  // ensure that the layout matches the printer
699  d->setPaperSizeFromPrinter(printer->pageLayout().fullRectPixels(printer->resolution()).size());
700  }
701 
702  printer->setFullPage(true);
703 
704  // don't call ensureLayouted here, it would use the wrong printer!
705 
706  const bool ret = d->doPrint(printer, parent);
707 
708  // Reset the page size
709  setPageSize(savePageSize);
710 
711  return ret;
712 }
713 
714 bool KDReports::Report::exportToFile(const QString &fileName, QWidget *parent)
715 {
716  d->ensureLayouted();
717  QPrinter printer;
718  printer.setOutputFileName(fileName); // must be done before setupPrinter, since it affects DPI
719  setupPrinter(&printer);
720  const bool ret = d->doPrint(&printer, parent);
721  printer.setOutputFileName(QString());
722  return ret;
723 }
724 
725 bool KDReports::Report::exportToHtml(const QString &fileName)
726 {
727  const QString html = asHtml();
728  QFile file(fileName);
729  if (file.open(QIODevice::WriteOnly)) {
730  file.write(html.toUtf8());
731  d->m_layout->finishHtmlExport();
732  return true;
733  }
734  return false;
735 }
736 
737 bool KDReports::Report::exportToImage(QSize size, const QString &fileName, const char *format)
738 {
739  // Get the document to fit into one page
740 
741  const auto savePageSize = pageSize();
742  const qreal saveLayoutWidth = d->m_layoutWidth;
743  d->m_layoutWidth = d->m_layout->idealWidth() + mmToPixels(d->m_marginLeft + d->m_marginRight);
744  d->m_pageContentSizeDirty = true;
745  d->ensureLayouted();
746 
747  const qreal zoomFactor = qMin((qreal)size.width() / d->m_paperSize.width(), (qreal)size.height() / d->m_paperSize.height());
748  // qDebug() << "zoomFactor=" << zoomFactor;
749 
750  QImage image(size, QImage::Format_ARGB32_Premultiplied);
751  image.fill(Qt::white);
752 
753  QPainter painter;
754  if (!painter.begin(&image)) {
755  qWarning() << "QPainter failed to initialize on the given image of size" << size;
756  return false;
757  }
758  painter.setRenderHint(QPainter::Antialiasing);
759  painter.setRenderHint(QPainter::SmoothPixmapTransform);
760  painter.fillRect(QRectF(0, 0, size.width(), size.height()), QBrush(Qt::white));
761  painter.scale(zoomFactor, zoomFactor);
762  d->paintPage(0, painter);
763 
764  // restore textdoc size and header widths
765  d->m_layoutWidth = saveLayoutWidth;
766  setPageSize(savePageSize); // redo layout
767  qDebug() << "Saving pixmap" << image.size() << "into" << fileName << "with format" << format;
768  return image.save(fileName, format);
769 }
770 
772 {
773  if (!d->m_headers.contains(hl))
774  d->m_headers.insert(hl, new Header(this));
775  return *d->m_headers.value(hl);
776 }
777 
778 void KDReports::Report::setHeaderLocation(HeaderLocations hl, Header *header)
779 {
780  // Remove old entry for this header
781  HeaderLocations loc = d->m_headers.headerLocation(header);
782  d->m_headers.remove(loc);
783  d->m_headers.insert(hl, header);
784 }
785 
787 {
788  if (!d->m_footers.contains(hl))
789  d->m_footers.insert(hl, new Header(this));
790  return *d->m_footers.value(hl);
791 }
792 
793 void KDReports::Report::setFooterLocation(HeaderLocations hl, Footer *footer)
794 {
795  // Remove old entry for this header
796  HeaderLocations loc = d->m_footers.headerLocation(footer);
797  d->m_footers.remove(loc);
798  d->m_footers.insert(hl, footer);
799 }
800 
801 bool KDReports::Report::loadFromXML(QIODevice *iodevice, ErrorDetails *details)
802 {
803  QDomDocument doc;
804  // Read document from the QIODevice, check for errors
805 
806  // We need to be able to see the space in <text> </text>, this is why
807  // we activate the "report-whitespace-only-CharData" feature.
808  // Unfortunately this leads to lots of whitespace text nodes in between real
809  // elements in the rest of the document, watch out for that.
810  if (iodevice->isOpen())
811  iodevice->reset(); // need to do that to allow consecutive calls of loadFromXML()
812  else
813  iodevice->open(QIODevice::ReadOnly);
814 
815  QString errorMsg;
816  int errorLine = 0;
817  int errorColumn = 0;
818  bool ret = doc.setContent(iodevice, true, &errorMsg, &errorLine, &errorColumn);
819  if (!ret) {
820  if (details) {
821  details->setLine(errorLine);
822  details->setColumn(errorColumn);
823  details->setDriverMessage(errorMsg);
824  } else
825  qWarning("Malformed XML read in KDReports::Report::loadFromXML(): error message = %s, error line = %d, error column = %d", qPrintable(errorMsg), errorLine, errorColumn);
826  return false;
827  }
828  return loadFromXML(doc, details);
829 }
830 
831 bool KDReports::Report::loadFromXML(const QDomDocument &doc, ErrorDetails *details)
832 {
833  XmlParser parser(d->m_textValues, d->m_imageValues, d->m_xmlElementHandler, this, details);
834  d->m_pageContentSizeDirty = true;
835  return parser.processDocument(doc, d->builder());
836 }
837 
838 void KDReports::Report::associateModel(const QString &modelKey, QAbstractItemModel *model)
839 {
840  globalModelMap()->insert(modelKey, model);
841 }
842 
843 KDReports::TextDocument &KDReports::Report::doc() const
844 {
845  Q_ASSERT(d->m_reportMode == WordProcessing);
846  return static_cast<TextDocReportLayout *>(d->m_layout)->textDocument();
847 }
848 
850 {
851  d->builder()->contentDocumentCursor().beginEditBlock();
852 }
853 
855 {
856  d->builder()->contentDocumentCursor().endEditBlock();
857 }
858 
859 QString KDReports::Report::anchorAt(int pageNumber, QPoint pos) const
860 {
861  const QRect textDocRect = d->mainTextDocRect();
862  const QPoint textPos = pos - textDocRect.topLeft();
863  return d->m_layout->anchorAt(pageNumber, textPos);
864 }
865 
866 void KDReports::Report::setWatermarkText(const QString &text, int rotation, const QColor &color, const QFont &font)
867 {
868  d->m_watermarkText = text;
869  d->m_watermarkRotation = rotation;
870  d->m_watermarkColor = color;
871  d->m_watermarkFont = font;
872 }
873 
875 {
876  return d->m_watermarkText;
877 }
878 
880 {
881  return d->m_watermarkRotation;
882 }
883 
885 {
886  return d->m_watermarkColor;
887 }
888 
890 {
891  return d->m_watermarkFont;
892 }
893 
894 void KDReports::Report::setWatermarkPixmap(const QPixmap &pixmap, bool autoGrayOut)
895 {
896  QPixmap pix(pixmap);
897  if (autoGrayOut) {
898  QStyleOption opt(0);
899  opt.palette = QApplication::palette();
900  pix = qApp->style()->generatedIconPixmap(QIcon::Disabled, pixmap, &opt);
901  }
902  setWatermarkImage(pix.toImage());
903 }
904 
906 {
907  return QPixmap::fromImage(d->m_watermarkImage);
908 }
909 
910 void KDReports::Report::setWatermarkImage(const QImage &image)
911 {
912  d->m_watermarkImage = image;
913 }
914 
916 {
917  return d->m_watermarkImage;
918 }
919 
921 {
922  d->builder()->addPageBreakPublic();
923 }
924 
925 void KDReports::Report::associateTextValue(const QString &id, const QString &value)
926 {
927  d->m_layout->updateTextValue(id, value); // in case the document is built already
928  d->m_headers.updateTextValue(id, value);
929  d->m_footers.updateTextValue(id, value);
930  d->m_textValues.insert(id, value); // in case the document isn't built yet
931 }
932 
933 void KDReports::Report::associateImageValue(const QString &id, const QPixmap &value)
934 {
935  d->m_imageValues.insert(id, value.toImage());
936 }
937 
938 void KDReports::Report::associateImageValue(const QString &id, const QImage &value)
939 {
940  d->m_imageValues.insert(id, value);
941 }
942 
944 {
945  return d->paperSize();
946 }
947 
948 void KDReports::Report::addFragment(const QTextDocumentFragment &fragment)
949 {
950  d->builder()->insertFragmentPublic(fragment);
951 }
952 
953 void KDReports::Report::setDefaultFont(const QFont &font)
954 {
955  d->m_layout->setDefaultFont(font);
956  d->m_pageContentSizeDirty = true;
957 }
958 
960 {
961  return d->m_layout->defaultFont();
962 }
963 
965 {
966  d->m_headerBodySpacing = spacing;
967  d->m_pageContentSizeDirty = true;
968 }
969 
971 {
972  return d->m_headerBodySpacing;
973 }
974 
976 {
977  d->m_footerBodySpacing = spacing;
978  d->m_pageContentSizeDirty = true;
979 }
980 
982 {
983  return d->m_footerBodySpacing;
984 }
985 
986 void KDReports::Report::scaleTo(int numPagesHorizontally, int numPagesVertically)
987 {
988  d->m_layout->scaleTo(numPagesHorizontally, numPagesVertically);
989 }
990 
992 {
993  return d->m_layout->maximumNumberOfPagesForHorizontalScaling();
994 }
995 
997 {
998  return d->m_layout->maximumNumberOfPagesForVerticalScaling();
999 }
1000 
1002 {
1003  d->m_layout->setFixedRowHeight(mmToPixels(mm));
1004 }
1005 
1007 {
1008  d->m_layout->setUserRequestedFontScalingFactor(factor);
1009 }
1010 
1012 {
1013  return d->m_layout->userRequestedFontScalingFactor();
1014 }
1015 
1017 {
1018  return maximumNumberOfPagesForHorizontalScaling() != 1 || maximumNumberOfPagesForVerticalScaling() > 0;
1019 }
1020 
1022 {
1023  if (d->m_reportMode != SpreadSheet) {
1024  qWarning("setTableBreakingPageOrder is only supported in SpreadSheet mode");
1025  } else {
1026  mainTable()->setTableBreakingPageOrder(pageOrder);
1027  }
1028 }
1029 
1031 {
1032  if (d->m_reportMode != SpreadSheet) {
1033  qWarning("tableBreakingPageOrder is only supported in SpreadSheet mode");
1034  return DownThenRight;
1035  } else {
1036  return mainTable()->tableBreakingPageOrder();
1037  }
1038 }
1039 
1041 {
1042  if (d->m_reportMode == WordProcessing)
1043  doc().regenerateAutoTables();
1044 }
1045 
1046 void KDReports::Report::regenerateAutoTableForModel(QAbstractItemModel *model)
1047 {
1048  if (d->m_reportMode == WordProcessing)
1049  doc().regenerateAutoTableForModel(model);
1050 }
1051 
1053 {
1054  if (d->m_reportMode == WordProcessing)
1055  return doc().autoTableElements();
1057 }
1058 
1060 {
1061  d->m_xmlElementHandler = handler;
1062 }
1063 
1064 void KDReports::Report::setCurrentRow(const QAbstractItemModel *model, int row)
1065 {
1066  d->m_currentModel = model;
1067  d->m_currentRow = row;
1068 }
1069 
1070 void KDReports::Report::setDocumentName(const QString &name)
1071 {
1072  d->m_documentName = name;
1073 }
1074 
1075 QString KDReports::Report::documentName() const
1076 {
1077  return d->m_documentName;
1078 }
1079 
1081 {
1082  d->builder()->setTabPositions(tabs);
1083 }
1084 
1085 void KDReports::Report::setParagraphMargins(qreal left, qreal top, qreal right, qreal bottom)
1086 {
1087  d->builder()->setParagraphMargins(left, top, right, bottom);
1088 }
1089 
1091 {
1092  if (d->m_reportMode != reportMode) {
1093  d->m_reportMode = reportMode;
1094  delete d->m_layout;
1095  switch (reportMode) {
1096  case WordProcessing:
1097  d->m_layout = new TextDocReportLayout(this);
1098  break;
1099  case SpreadSheet:
1100  auto *sslayout = new SpreadsheetReportLayout(this);
1101  d->m_layout = sslayout;
1102  mainTable()->setLayout(sslayout);
1103  break;
1104  };
1105  }
1106 }
1107 
1109 {
1110  return d->m_reportMode;
1111 }
1112 
1114 {
1115  Q_ASSERT(d->m_reportMode == SpreadSheet);
1116  return d->m_mainTable;
1117 }
1118 
1120 {
1121  QTextOption::Tab tab;
1122  tab.position = -1;
1123  tab.type = QTextOption::RightTab;
1124  tab.delimiter = QChar::fromLatin1('P'); // a bit hackish, but this is how we tell TextDocumentData::updatePercentSize
1125  return tab;
1126 }
1127 
1129 {
1130  QTextOption::Tab tab;
1131  tab.position = -1;
1132  tab.type = QTextOption::CenterTab;
1133  tab.delimiter = QChar::fromLatin1('P'); // a bit hackish, but this is how we tell TextDocumentData::updatePercentSize
1134  return tab;
1135 }
1136 
1137 KDReports::HeaderLocations KDReports::Report::headerLocation(KDReports::Header *header) const
1138 {
1139  return d->m_headers.headerLocation(header);
1140 }
1141 
1142 KDReports::HeaderLocations KDReports::Report::footerLocation(KDReports::Footer *footer) const
1143 {
1144  return d->m_footers.headerLocation(footer);
1145 }
1146 
1148 {
1149  return d->builder()->currentPosition();
1150 }
1151 
1153 {
1154  d->m_firstPageNumber = num;
1155 }
1156 
1158 {
1159  return d->m_firstPageNumber;
1160 }
1161 
1162 void KDReports::Report::setupPrinter(QPrinter *printer)
1163 {
1164  printer->setFullPage(true);
1165  printer->setPageOrientation(d->m_orientation);
1166  // was: printer->setPaperSize(rawPaperSize(d->m_pageSize, printer), QPrinter::DevicePixel);
1167  printer->setPageSize(d->m_pageSize);
1168  printer->setDocName(d->m_documentName);
1169 }
KDReports::Report::anchorAt
QString anchorAt(int pageNumber, QPoint pos) const
Definition: KDReportsReport.cpp:859
KDReports::ReportPrivate::headerChanged
void headerChanged()
Definition: KDReportsReport.cpp:354
KDReports::ReportBuilder
Definition: KDReportsReportBuilder_p.h:41
KDReports::Report::setFooterLocation
void setFooterLocation(HeaderLocations hl, Footer *footer)
Definition: KDReportsReport.cpp:793
KDReports::ErrorDetails::setLine
void setLine(int line)
Definition: KDReportsErrorDetails.cpp:65
KDReports::Report::associateImageValue
void associateImageValue(const QString &id, const QPixmap &value)
Definition: KDReportsReport.cpp:933
KDReports::ReportPrivate::paintPage
void paintPage(int pageNumber, QPainter &painter)
KDReports::Report::setHeaderBodySpacing
void setHeaderBodySpacing(qreal spacing)
Definition: KDReportsReport.cpp:964
KDReports::Report::watermarkFont
QFont watermarkFont() const
Definition: KDReportsReport.cpp:889
KDReports::Report::setWatermarkText
void setWatermarkText(const QString &text, int rotation=0, const QColor &color=QColor(204, 204, 204), const QFont &font=QFont(QStringLiteral("Helvetica"), 48))
Definition: KDReportsReport.cpp:866
KDReports::Report::regenerateAutoTableForModel
void regenerateAutoTableForModel(QAbstractItemModel *model)
Definition: KDReportsReport.cpp:1046
KDReports::XmlParser
Definition: KDReportsXmlParser_p.h:52
KDReports::Report::setWatermarkPixmap
void setWatermarkPixmap(const QPixmap &pixmap, bool autoGrayOut=true)
Definition: KDReportsReport.cpp:894
KDReports::Report::setDefaultFont
void setDefaultFont(const QFont &font)
Definition: KDReportsReport.cpp:953
KDReports::modelForKey
QAbstractItemModel * modelForKey(const QString &key)
Definition: KDReportsReport.cpp:426
KDReports::Report::beginEdit
void beginEdit()
Definition: KDReportsReport.cpp:849
KDReportsSpreadsheetReportLayout_p.h
KDReports::Report::setTableBreakingPageOrder
void setTableBreakingPageOrder(TableBreakingPageOrder pageOrder)
Definition: KDReportsReport.cpp:1021
KDReports::Report::pageOrientation
QPageLayout::Orientation pageOrientation() const
Definition: KDReportsReport.cpp:560
KDReports::Report::loadFromXML
bool loadFromXML(QIODevice *iodevice, ErrorDetails *details=nullptr)
Definition: KDReportsReport.cpp:801
KDReports::ReportPrivate::~ReportPrivate
~ReportPrivate()
Definition: KDReportsReport.cpp:86
KDReports::Report::footerLocation
KDReports::HeaderLocations footerLocation(KDReports::Footer *footer) const
Definition: KDReportsReport.cpp:1142
KDReports::Report::addPageBreak
void addPageBreak()
Definition: KDReportsReport.cpp:920
KDReportsMainTable.h
KDReports::Report::setReportMode
void setReportMode(ReportMode reportMode)
Definition: KDReportsReport.cpp:1090
KDReports::Report::paintPage
void paintPage(int pageNumber, QPainter &painter)
Definition: KDReportsReport.cpp:650
KDReports::Report::headerLocation
KDReports::HeaderLocations headerLocation(Header *header) const
Definition: KDReportsReport.cpp:1137
KDReports::Report::setFontScalingFactor
void setFontScalingFactor(qreal factor)
Scale the fonts in the document by a given factor.
Definition: KDReportsReport.cpp:1006
KDReportsReport_p.h
KDReports::Report::setHeaderLocation
void setHeaderLocation(HeaderLocations hl, Header *header)
Definition: KDReportsReport.cpp:778
KDReportsTextDocReportLayout_p.h
KDReports::Report::topPageMargins
qreal topPageMargins() const
Definition: KDReportsReport.cpp:618
KDReports::Report::addInlineElement
void addInlineElement(const Element &element)
Definition: KDReportsReport.cpp:457
KDReports::Report::exportToImage
bool exportToImage(QSize size, const QString &fileName, const char *format)
Definition: KDReportsReport.cpp:737
KDReports::Report::print
bool print(QPrinter *printer, QWidget *parent=nullptr)
Definition: KDReportsReport.cpp:687
KDReports::Report::regenerateAutoTables
void regenerateAutoTables()
Definition: KDReportsReport.cpp:1040
KDReports::Report::endEdit
void endEdit()
Definition: KDReportsReport.cpp:854
KDReports::Report::setBottomPageMargin
void setBottomPageMargin(qreal bottom)
Definition: KDReportsReport.cpp:623
KDReports::FirstPage
@ FirstPage
The first page of the report.
Definition: KDReportsReport.h:63
QList
Definition: KDReportsAbstractTableElement.h:25
KDReports::Report::setMargins
void setMargins(qreal top, qreal left, qreal bottom, qreal right)
Definition: KDReportsReport.cpp:565
KDReports::Element
Definition: KDReportsElement.h:39
KDReports::Report::watermarkColor
QColor watermarkColor() const
Definition: KDReportsReport.cpp:884
KDReports::TextDocument::contentDocument
QTextDocument & contentDocument()
Definition: KDReportsTextDocument.cpp:43
KDReports::ReportPrivate::builder
ReportBuilder * builder() const
Definition: KDReportsReport.cpp:436
KDReports::Report::maximumNumberOfPagesForVerticalScaling
int maximumNumberOfPagesForVerticalScaling() const
Definition: KDReportsReport.cpp:996
KDReports::Report::exportToFile
bool exportToFile(const QString &fileName, QWidget *parent=nullptr)
Definition: KDReportsReport.cpp:714
KDReports::Report::setCurrentRow
void setCurrentRow(const QAbstractItemModel *model, int row)
Definition: KDReportsReport.cpp:1064
KDReports::Report::middleAlignedTab
static QTextOption::Tab middleAlignedTab()
Definition: KDReportsReport.cpp:1128
KDReports::ReportPrivate::debugLayoutToPdf
void debugLayoutToPdf(const char *fileName)
Definition: KDReportsReport.cpp:402
KDReports::ErrorDetails::setColumn
void setColumn(int column)
Definition: KDReportsErrorDetails.cpp:71
KDReports::ReportPrivate
Definition: KDReportsReport_p.h:107
ModelMap
QMap< QString, QAbstractItemModel * > ModelMap
Definition: KDReportsReport.cpp:423
KDReports::Report::setLeftPageMargin
void setLeftPageMargin(qreal left)
Definition: KDReportsReport.cpp:584
KDReports::XmlElementHandler
Definition: KDReportsXmlElementHandler.h:84
KDReports::Report
Definition: KDReportsReport.h:80
KDReportsXmlParser_p.h
KDReportsElement.h
KDReports::Report::watermarkImage
QImage watermarkImage() const
Definition: KDReportsReport.cpp:915
KDReports::Report::documentName
QString documentName
Definition: KDReportsReport.h:83
KDReports::TextDocument
Definition: KDReportsTextDocument_p.h:55
KDReports::ReportPrivate::doPrint
bool doPrint(QPrinter *printer, QWidget *parent)
Definition: KDReportsReport.cpp:359
KDReports::Report::setWatermarkImage
void setWatermarkImage(const QImage &image)
Definition: KDReportsReport.cpp:910
KDReports::Report::getMargins
void getMargins(qreal *top, qreal *left, qreal *bottom, qreal *right) const
Definition: KDReportsReport.cpp:576
KDReports::Report::firstPageNumber
int firstPageNumber() const
Definition: KDReportsReport.cpp:1157
KDReports::TextDocReportLayout
Definition: KDReportsTextDocReportLayout_p.h:40
KDReports::Report::setXmlElementHandler
void setXmlElementHandler(KDReports::XmlElementHandler *handler)
Definition: KDReportsReport.cpp:1059
KDReportsReport.h
KDReports::ReportPrivate::mainTextDocHeight
qreal mainTextDocHeight() const
Definition: KDReportsReport.cpp:159
KDReportsHeader.h
KDReports::ReportPrivate::mainTextDocRect
QRect mainTextDocRect() const
Definition: KDReportsReport.cpp:172
KDReports::EvenPages
@ EvenPages
The even pages of the report: 2, 4, 6 etc.
Definition: KDReportsReport.h:64
KDReports::Unit
Unit
Definition: KDReportsUnit.h:39
KDReports::Report::exportToHtml
bool exportToHtml(const QString &fileName)
Definition: KDReportsReport.cpp:725
KDReports::OddPages
@ OddPages
The odd pages of the report: 1 (unless FirstPage has its own header), 3, 5, 7 etc.
Definition: KDReportsReport.h:65
KDReports::ReportPrivate::skipHeadersFooters
bool skipHeadersFooters() const
Definition: KDReportsReport.cpp:150
KDReports::Report::~Report
~Report() override
Definition: KDReportsReport.cpp:452
KDReports::SpreadsheetReportLayout
Definition: KDReportsSpreadsheetReportLayout_p.h:43
KDReports::Report::setPaperSize
void setPaperSize(QSizeF paperSize, QPrinter::Unit unit)
Definition: KDReportsReport.cpp:505
KDReports::Report::watermarkText
QString watermarkText() const
Definition: KDReportsReport.cpp:874
KDReports::Report::footerBodySpacing
qreal footerBodySpacing() const
Definition: KDReportsReport.cpp:981
qt_defaultDpi
QT_BEGIN_NAMESPACE Q_GUI_EXPORT int qt_defaultDpi()
KDReports::Report::numberOfPages
int numberOfPages() const
Definition: KDReportsReport.cpp:655
KDReports::Report::leftPageMargins
qreal leftPageMargins() const
Definition: KDReportsReport.cpp:592
KDReports::Report::setRightPageMargin
void setRightPageMargin(qreal right)
Definition: KDReportsReport.cpp:597
KDReports::Report::watermarkPixmap
QPixmap watermarkPixmap() const
Definition: KDReportsReport.cpp:905
KDReports::ReportPrivate::ReportPrivate
ReportPrivate(Report *report)
Definition: KDReportsReport.cpp:48
KDReports::HeaderMap::headerForPage
Header * headerForPage(int pageNumber, int pageCount) const
Definition: KDReportsReport.cpp:216
KDReports::LastPage
@ LastPage
The last page of the report.
Definition: KDReportsReport.h:66
KDReports::Report::Report
Report(QObject *parent=nullptr)
Definition: KDReportsReport.cpp:445
KDReports::Report::setPageOrientation
void setPageOrientation(QPageLayout::Orientation orientation)
Definition: KDReportsReport.cpp:553
KDReports::ReportPrivate::paperSize
QSizeF paperSize() const
Definition: KDReportsReport.cpp:97
KDReports::Report::setTabPositions
void setTabPositions(const QList< QTextOption::Tab > &tabs)
Definition: KDReportsReport.cpp:1080
KDReports::ReportPrivate::textDocumentWidth
qreal textDocumentWidth() const
Definition: KDReportsReport.cpp:431
KDReports::Report::addFragment
void addFragment(const QTextDocumentFragment &fragment)
Definition: KDReportsReport.cpp:948
KDReports::Report::addVerticalSpacing
void addVerticalSpacing(qreal space)
Definition: KDReportsReport.cpp:477
KDReports::Report::mainTable
MainTable * mainTable() const
Definition: KDReportsReport.cpp:1113
KDReports::ReportPrivate::layoutAsOnePage
QSizeF layoutAsOnePage(qreal docWidth)
Definition: KDReportsReport.cpp:336
KDReports::Report::tableBreakingPageOrder
TableBreakingPageOrder tableBreakingPageOrder() const
Definition: KDReportsReport.cpp:1030
KDReports::Report::addElement
void addElement(const Element &element, Qt::AlignmentFlag horizontalAlignment=Qt::AlignLeft, const QColor &backgroundColor=QColor())
Definition: KDReportsReport.cpp:467
KDReports::Report::watermarkRotation
int watermarkRotation() const
Definition: KDReportsReport.cpp:879
KDReports::Report::setTopPageMargin
void setTopPageMargin(qreal top)
Definition: KDReportsReport.cpp:610
KDReports::Report::scaleTo
void scaleTo(int numPagesHorizontally, int numPagesVertically)
Ensure that the report fits into a number of pages.
Definition: KDReportsReport.cpp:986
KDReports::mmToPixels
KDREPORTS_EXPORT qreal mmToPixels(qreal mm)
Definition: KDReportsLayoutHelper.cpp:23
KDReports::Report::isTableBreakingEnabled
bool isTableBreakingEnabled() const
Definition: KDReportsReport.cpp:1016
KDReports::Report::WordProcessing
@ WordProcessing
Definition: KDReportsReport.h:96
KDReports::Report::pageSize
QPageSize pageSize() const
Definition: KDReportsReport.cpp:533
KDReports::Report::currentPosition
int currentPosition() const
Definition: KDReportsReport.cpp:1147
KDReports::Report::headerBodySpacing
qreal headerBodySpacing() const
Definition: KDReportsReport.cpp:970
KDReports::Report::paperSize
QSizeF paperSize() const
Definition: KDReportsReport.cpp:943
KDReportsLayoutHelper_p.h
KDReports::HeaderMap::headerLocation
KDReports::HeaderLocations headerLocation(Header *header) const
KDReports::XmlParser::processDocument
bool processDocument(const QDomDocument &document, KDReports::ReportBuilder *builder)
Definition: KDReportsXmlParser.cpp:147
KDReports::Report::associateModel
void associateModel(const QString &modelKey, QAbstractItemModel *model)
Definition: KDReportsReport.cpp:838
KDReports::Report::footer
Footer & footer(HeaderLocations hl=AllPages)
Definition: KDReportsReport.cpp:786
KDReports::Report::setDocumentName
void setDocumentName(const QString &name)
Definition: KDReportsReport.cpp:1070
KDReports::Report::ReportMode
ReportMode
Definition: KDReportsReport.h:96
KDReports::Report::rightAlignedTab
static QTextOption::Tab rightAlignedTab()
Definition: KDReportsReport.cpp:1119
KDReports::MainTable
Definition: KDReportsMainTable.h:57
KDReports::Report::associateTextValue
void associateTextValue(const QString &id, const QString &value)
Definition: KDReportsReport.cpp:925
KDReports::Report::bottomPageMargins
qreal bottomPageMargins() const
Definition: KDReportsReport.cpp:631
KDReports::ReportPrivate::setPaperSizeFromPrinter
void setPaperSizeFromPrinter(QSizeF paperSize)
Definition: KDReportsReport.cpp:191
KDReports::Report::dump
void dump() const
Definition: KDReportsReport.cpp:661
KDReports::Report::setFixedRowHeight
void setFixedRowHeight(qreal mm)
Definition: KDReportsReport.cpp:1001
KDReports::Report::printWithDialog
bool printWithDialog(QWidget *parent)
Definition: KDReportsReport.cpp:671
KDReports::Report::rightPageMargins
qreal rightPageMargins() const
Definition: KDReportsReport.cpp:605
KDReports::ErrorDetails
Definition: KDReportsErrorDetails.h:44
KDReports::Report::setParagraphMargins
void setParagraphMargins(qreal left, qreal top, qreal right, qreal bottom)
Definition: KDReportsReport.cpp:1085
KDReports::Report::defaultFont
QFont defaultFont() const
Definition: KDReportsReport.cpp:959
KDReports::Report::setWidthForEndlessPrinter
void setWidthForEndlessPrinter(qreal widthMM)
Definition: KDReportsReport.cpp:636
KDReports::Header
Definition: KDReportsHeader.h:49
KDReports::ErrorDetails::setDriverMessage
void setDriverMessage(const QString &message)
Definition: KDReportsErrorDetails.cpp:77
KDReports::ReportPrivate::ensureLayouted
void ensureLayouted()
Definition: KDReportsReport.cpp:111
KDReports::Report::autoTableElements
QList< KDReports::AutoTableElement * > autoTableElements() const
Definition: KDReportsReport.cpp:1052
KDReports::Report::header
Header & header(HeaderLocations hl=AllPages)
Definition: KDReportsReport.cpp:771
KDReports::Report::fontScalingFactor
qreal fontScalingFactor() const
Definition: KDReportsReport.cpp:1011
KDReports::ReportPrivate::rawMainTextDocHeight
qreal rawMainTextDocHeight() const
Definition: KDReportsReport.cpp:136
KDReports::Report::setPageSize
void setPageSize(QPageSize::PageSizeId size)
Definition: KDReportsReport.cpp:493
KDReports::Report::TableBreakingPageOrder
TableBreakingPageOrder
Definition: KDReportsReport.h:611
KDReports::ReportPrivate::wantEndlessPrinting
bool wantEndlessPrinting() const
Definition: KDReportsReport.cpp:92
KDReports::Report::maximumNumberOfPagesForHorizontalScaling
int maximumNumberOfPagesForHorizontalScaling() const
Definition: KDReportsReport.cpp:991
KDReports
Definition: KDReportsAbstractReportLayout_p.h:30
KDReports::Report::setFooterBodySpacing
void setFooterBodySpacing(qreal spacing)
Definition: KDReportsReport.cpp:975
KDReports::Report::reportMode
ReportMode reportMode() const
Definition: KDReportsReport.cpp:1108
KDReports::pixelsToPointsMultiplier
KDREPORTS_EXPORT qreal pixelsToPointsMultiplier(double resolution)
Definition: KDReportsLayoutHelper.cpp:29
KDReports::Report::setFirstPageNumber
void setFirstPageNumber(int num)
Definition: KDReportsReport.cpp:1152

© 2007-2021 Klarälvdalens Datakonsult AB (KDAB)
"The Qt, C++ and OpenGL Experts"
https://www.kdab.com/
https://www.kdab.com/development-resources/qt-tools/kd-reports/
Generated on Sat Jan 8 2022 02:38:32 for KD Reports API Documentation by doxygen 1.8.17