1 /***************************************************************************
2 * This file is part of the Lime Report project *
3 * Copyright (C) 2015 by Alexander Arin *
4 * arin_a@bk.ru *
5 * *
6 ** GNU General Public License Usage **
7 * *
8 * This library is free software: you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation, either version 3 of the License, or *
11 * (at your option) any later version. *
12 * You should have received a copy of the GNU General Public License *
13 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
14 * *
15 ** GNU Lesser General Public License **
16 * *
17 * This library is free software: you can redistribute it and/or modify *
18 * it under the terms of the GNU Lesser General Public License as *
19 * published by the Free Software Foundation, either version 3 of the *
20 * License, or (at your option) any later version. *
21 * You should have received a copy of the GNU Lesser General Public *
22 * License along with this library. *
23 * If not, see <http://www.gnu.org/licenses/>. *
24 * *
25 * This library is distributed in the hope that it will be useful, *
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
28 * GNU General Public License for more details. *
29 ****************************************************************************/
30 #include <QPrinter>
31 #include <QPrintDialog>
32 #include <QPrinterInfo>
33 #include <QMessageBox>
34 #include <QApplication>
35 #include <QDesktopWidget>
36 #include <QFileSystemWatcher>
37 #include <QPluginLoader>
38 #include <QFileDialog>
39 #include <QGraphicsScene>
40
41 #include "time.h"
42
43 #include "lrreportengine_p.h"
44 #include "lrreportengine.h"
45
46 #include "lrpagedesignintf.h"
47 #include "lrdatasourcemanager.h"
48
49 #ifdef HAVE_REPORT_DESIGNER
50 #include "lrdatabrowser.h"
51 #include "lrreportdesignwindow.h"
52 #endif
53
54 #include "serializators/lrxmlwriter.h"
55 #include "serializators/lrxmlreader.h"
56 #include "lrreportrender.h"
57 #include "lrpreviewreportwindow.h"
58 #include "lrpreviewreportwidget.h"
59 #include "lrpreviewreportwidget_p.h"
60 #include "lrexporterintf.h"
61 #include "lrexportersfactory.h"
62
63 #ifdef BUILD_WITH_EASY_PROFILER
64 #include "easy/profiler.h"
65 #else
66 # define EASY_BLOCK(...)
67 # define EASY_END_BLOCK
68 #endif
69 #include "lrpreparedpages.h"
70
71 #ifdef HAVE_STATIC_BUILD
72 #include "lrfactoryinitializer.h"
73 #endif
74
75 namespace LimeReport{
76
77 QSettings* ReportEngine::m_settings = 0;
78
ReportEnginePrivate(QObject * parent)79 ReportEnginePrivate::ReportEnginePrivate(QObject *parent) :
80 QObject(parent), m_preparedPagesManager(new PreparedPages(&m_preparedPages)), m_fileName(""), m_settings(0), m_ownedSettings(false),
81 m_printer(new QPrinter(QPrinter::HighResolution)), m_printerSelected(false),
82 m_showProgressDialog(true), m_reportName(""), m_activePreview(0),
83 m_previewWindowIcon(":/report/images/logo32"), m_previewWindowTitle(tr("Preview")),
84 m_reportRendering(false), m_resultIsEditable(true), m_passPhrase("HjccbzHjlbyfCkjy"),
85 m_fileWatcher( new QFileSystemWatcher( this ) ), m_reportLanguage(QLocale::AnyLanguage),
86 m_previewLayoutDirection(Qt::LayoutDirectionAuto), m_designerFactory(0),
87 m_previewScaleType(FitWidth), m_previewScalePercent(0), m_startTOCPage(0),
88 m_previewPageBackgroundColor(Qt::gray),
89 m_saveToFileVisible(true), m_printToPdfVisible(true),
90 m_printVisible(true)
91 {
92 #ifdef HAVE_STATIC_BUILD
93 initResources();
94 initReportItems();
95 #ifdef HAVE_REPORT_DESIGNER
96 initObjectInspectorProperties();
97 #endif
98 initSerializators();
99 #endif
100 m_datasources = new DataSourceManager(this);
101 m_datasources->setReportSettings(&m_reportSettings);
102 scriptManager()->setDataManager(m_datasources);
103 m_scriptEngineContext = new ScriptEngineContext(this);
104
105 ICallbackDatasource* tableOfContents = m_datasources->createCallbackDatasource("tableofcontents");
106 connect(tableOfContents, SIGNAL(getCallbackData(LimeReport::CallbackInfo,QVariant&)),
107 m_scriptEngineContext->tableOfContents(), SLOT(slotOneSlotDS(LimeReport::CallbackInfo,QVariant&)));
108
109 m_datasources->setObjectName("datasources");
110 connect(m_datasources,SIGNAL(loadCollectionFinished(QString)),this,SLOT(slotDataSourceCollectionLoaded(QString)));
111 connect(m_fileWatcher,SIGNAL(fileChanged(const QString &)),this,SLOT(slotLoadFromFile(const QString &)));
112
113 QDir pluginsDir = QCoreApplication::applicationDirPath();
114 pluginsDir.cd("../lib" );
115 if (!pluginsDir.exists()){
116 pluginsDir.cd("./lib");
117 if (!pluginsDir.exists()) pluginsDir.setPath(QCoreApplication::applicationDirPath());
118 }
119
120 foreach( const QString& pluginName, pluginsDir.entryList( QDir::Files ) ) {
121 QPluginLoader loader( pluginsDir.absoluteFilePath( pluginName ) );
122 if( loader.load() ) {
123 #ifndef HAVE_REPORT_DESIGNER
124 if( LimeReportDesignerPluginInterface* designerPlugin = qobject_cast< LimeReportDesignerPluginInterface* >( loader.instance() ) ) {
125 m_designerFactory = designerPlugin;
126 break;
127 }
128 #endif
129 }
130 }
131
132 }
133
~ReportEnginePrivate()134 ReportEnginePrivate::~ReportEnginePrivate()
135 {
136 if (m_designerWindow) {
137 m_designerWindow->close();
138 }
139 if (m_activePreview){
140 m_activePreview->close();
141 }
142 foreach(PageDesignIntf* page,m_pages) delete page;
143 m_pages.clear();
144
145 foreach(ReportTranslation* translation, m_translations)
146 delete translation;
147 m_translations.clear();
148
149 if (m_ownedSettings&&m_settings) delete m_settings;
150 delete m_preparedPagesManager;
151 }
152
createElement(const QString &,const QString &)153 QObject* ReportEnginePrivate::createElement(const QString &, const QString &)
154 {
155 return appendPage();
156 }
157
elementAt(const QString &,int index)158 QObject *ReportEnginePrivate::elementAt(const QString &, int index)
159 {
160 return pageAt(index);
161 }
162
createPage(const QString & pageName,bool preview)163 PageDesignIntf *ReportEnginePrivate::createPage(const QString &pageName, bool preview)
164 {
165 PageDesignIntf* page =new PageDesignIntf();
166 page->setObjectName(pageName);
167 page->pageItem()->setObjectName("Report"+pageName);
168 if (!preview)
169 page->setReportEditor(this);
170 page->setReportSettings(&m_reportSettings);
171 return page;
172 }
173
appendPage(const QString & pageName)174 PageDesignIntf *ReportEnginePrivate::appendPage(const QString &pageName)
175 {
176 PageDesignIntf* page = createPage(pageName);
177 m_pages.append(page);
178 return page;
179 }
180
deletePage(PageDesignIntf * page)181 bool ReportEnginePrivate::deletePage(PageDesignIntf *page){
182 QList<PageDesignIntf*>::iterator it = m_pages.begin();
183 while (it != m_pages.end()){
184 if (*it == page) {
185 it = m_pages.erase(it);
186 return true;
187 } else ++it;
188 }
189 return false;
190 }
191
createPreviewPage()192 PageDesignIntf *ReportEnginePrivate::createPreviewPage()
193 {
194 return createPage("preview",true);
195 }
196
elementsCount(const QString &)197 int ReportEnginePrivate::elementsCount(const QString &)
198 {
199 return m_pages.count();
200 }
201
collectionLoadFinished(const QString &)202 void ReportEnginePrivate::collectionLoadFinished(const QString &)
203 {
204 foreach (PageDesignIntf* page, m_pages) {
205 page->setReportEditor(this);
206 page->setReportSettings(&m_reportSettings);
207 page->setSceneRect(-Const::SCENE_MARGIN,-Const::SCENE_MARGIN,
208 page->pageItem()->width()+Const::SCENE_MARGIN*2,
209 page->pageItem()->height()+Const::SCENE_MARGIN*2);
210 }
211 emit pagesLoadFinished();
212 }
213
saveError(QString message)214 void ReportEnginePrivate::saveError(QString message)
215 {
216 m_lastError = message;
217 }
218
showError(QString message)219 void ReportEnginePrivate::showError(QString message)
220 {
221 QMessageBox::critical(0,tr("Error"),message);
222 }
223
updateTranslations()224 void ReportEnginePrivate::updateTranslations()
225 {
226 foreach(ReportTranslation* translation, m_translations.values()){
227 translation->invalidatePages();
228 foreach(PageDesignIntf* page, m_pages){
229 translation->updatePageTranslation(page);
230 }
231 translation->clearInvalidPages();
232 }
233 }
234
slotDataSourceCollectionLoaded(const QString & collectionName)235 void ReportEnginePrivate::slotDataSourceCollectionLoaded(const QString &collectionName)
236 {
237 emit datasourceCollectionLoadFinished(collectionName);
238 }
239
slotPreviewWindowDestroyed(QObject * window)240 void ReportEnginePrivate::slotPreviewWindowDestroyed(QObject* window)
241 {
242 if (m_activePreview == window){
243 m_activePreview = 0;
244 }
245 }
246
slotDesignerWindowDestroyed(QObject * window)247 void ReportEnginePrivate::slotDesignerWindowDestroyed(QObject *window)
248 {
249 Q_UNUSED(window)
250 dataManager()->setDesignTime(false);
251 }
252
clearReport()253 void ReportEnginePrivate::clearReport()
254 {
255 foreach(PageDesignIntf* page,m_pages) delete page;
256 m_pages.clear();
257 foreach(ReportTranslation* reportTranslation, m_translations)
258 delete reportTranslation;
259 m_translations.clear();
260 m_datasources->clear(DataSourceManager::Owned);
261 m_fileName="";
262 m_scriptEngineContext->clear();
263 m_reportSettings.setDefaultValues();
264 emit cleared();
265 }
266
printPages(ReportPages pages,QPrinter * printer)267 bool ReportEnginePrivate::printPages(ReportPages pages, QPrinter *printer)
268 {
269 if (!printer&&!m_printerSelected){
270 QPrinterInfo pi;
271 if (!pi.defaultPrinter().isNull())
272 #ifdef HAVE_QT4
273 m_printer.data()->setPrinterName(pi.defaultPrinter().printerName());
274 #endif
275 #ifdef HAVE_QT5
276 #if (QT_VERSION >= QT_VERSION_CHECK(5, 3, 0))
277 m_printer.data()->setPrinterName(pi.defaultPrinterName());
278 #else
279 m_printer.data()->setPrinterName(pi.defaultPrinter().printerName());
280 #endif
281 #endif
282 QPrintDialog dialog(m_printer.data(),QApplication::activeWindow());
283 m_printerSelected = dialog.exec()!=QDialog::Rejected;
284 }
285 if (!printer&&!m_printerSelected) return false;
286
287 printer =(printer)?printer:m_printer.data();
288 if (printer&&printer->isValid()){
289 try{
290 if (pages.count()>0){
291 internalPrintPages(
292 pages,
293 *printer
294 );
295 }
296 } catch(ReportError &exception){
297 saveError(exception.what());
298 }
299 return true;
300 } else return false;
301 }
302
internalPrintPages(ReportPages pages,QPrinter & printer)303 void ReportEnginePrivate::internalPrintPages(ReportPages pages, QPrinter &printer)
304 {
305 int currenPage = 1;
306 m_cancelPrinting = false;
307 QMap<QString, QSharedPointer<PrintProcessor> > printProcessors;
308 printProcessors.insert("default",QSharedPointer<PrintProcessor>(new PrintProcessor(&printer)));
309
310 int pageCount = (printer.printRange() == QPrinter::AllPages) ?
311 pages.size() :
312 printer.toPage() - printer.fromPage();
313
314 emit printingStarted(pageCount);
315 foreach(PageItemDesignIntf::Ptr page, pages){
316 if ( !m_cancelPrinting &&
317 ((printer.printRange() == QPrinter::AllPages) ||
318 ( (printer.printRange()==QPrinter::PageRange) &&
319 (currenPage >= printer.fromPage()) &&
320 (currenPage <= printer.toPage())
321 ))
322 )
323 {
324 printProcessors["default"]->printPage(page);
325 emit pagePrintingFinished(currenPage);
326 QApplication::processEvents();
327 }
328
329 currenPage++;
330 }
331 emit printingFinished();
332 }
333
printPages(ReportPages pages,QMap<QString,QPrinter * > printers,bool printToAllPrinters)334 void ReportEnginePrivate::printPages(ReportPages pages, QMap<QString, QPrinter*> printers, bool printToAllPrinters)
335 {
336 if (printers.values().isEmpty()) return;
337 m_cancelPrinting = false;
338
339 QMap<QString, QSharedPointer<PrintProcessor> > printProcessors;
340 for (int i = 0; i < printers.keys().count(); ++i) {
341 printProcessors.insert(printers.keys()[i],QSharedPointer<PrintProcessor>(new PrintProcessor(printers[printers.keys()[i]])));
342 }
343
344 PrintProcessor* defaultProcessor = 0;
345 int currentPrinter = 0;
346 if (printProcessors.contains("default")) defaultProcessor = printProcessors["default"].data();
347 else defaultProcessor = printProcessors.values().at(0).data();
348
349 emit printingStarted(pages.size());
350
351 for(int i = 0; i < pages.size(); ++i){
352 if (m_cancelPrinting) break;
353 PageItemDesignIntf::Ptr page = pages.at(i);
354 if (!printToAllPrinters){
355 if (printProcessors.contains(page->printerName()))
356 printProcessors[page->printerName()]->printPage(page);
357 else defaultProcessor->printPage(page);
358 } else {
359 printProcessors.values().at(currentPrinter)->printPage(page);
360 if (currentPrinter < printers.values().count()-1)
361 currentPrinter++;
362 else currentPrinter = 0;
363 }
364 emit pagePrintingFinished(i+1);
365 QApplication::processEvents();
366 }
367
368 emit printingFinished();
369 }
370
aviableReportTranslations()371 QStringList ReportEnginePrivate::aviableReportTranslations()
372 {
373 QStringList result;
374 foreach (QLocale::Language language, aviableLanguages()){
375 result << QLocale::languageToString(language);
376 }
377 return result;
378 }
379
setReportTranslation(const QString & languageName)380 void ReportEnginePrivate::setReportTranslation(const QString &languageName)
381 {
382 foreach(QLocale::Language language, aviableLanguages()){
383 if (QLocale::languageToString(language).compare(languageName) == 0){
384 setReportLanguage(language);
385 }
386 }
387 }
388
printReport(QPrinter * printer)389 bool ReportEnginePrivate::printReport(QPrinter* printer)
390 {
391 if (!printer&&!m_printerSelected){
392 QPrinterInfo pi;
393 if (!pi.defaultPrinter().isNull())
394 #ifdef HAVE_QT4
395 m_printer.data()->setPrinterName(pi.defaultPrinter().printerName());
396 #endif
397 #ifdef HAVE_QT5
398 #if (QT_VERSION >= QT_VERSION_CHECK(5, 3, 0))
399 m_printer.data()->setPrinterName(pi.defaultPrinterName());
400 #else
401 m_printer.data()->setPrinterName(pi.defaultPrinter().printerName());
402 #endif
403 #endif
404 QPrintDialog dialog(m_printer.data(),QApplication::activeWindow());
405 m_printerSelected = dialog.exec()!=QDialog::Rejected;
406 }
407 if (!printer&&!m_printerSelected) return false;
408
409 printer =(printer)?printer:m_printer.data();
410 if (printer&&printer->isValid()){
411 try{
412 bool designTime = dataManager()->designTime();
413 dataManager()->setDesignTime(false);
414 ReportPages pages = renderToPages();
415 dataManager()->setDesignTime(designTime);
416 if (pages.count()>0){
417 internalPrintPages(pages, *printer);
418 }
419 } catch(ReportError &exception){
420 saveError(exception.what());
421 }
422 return true;
423 } else return false;
424 }
425
printReport(QMap<QString,QPrinter * > printers,bool printToAllPrinters)426 bool ReportEnginePrivate::printReport(QMap<QString, QPrinter*> printers, bool printToAllPrinters)
427 {
428 try{
429 bool designTime = dataManager()->designTime();
430 dataManager()->setDesignTime(false);
431 ReportPages pages = renderToPages();
432 dataManager()->setDesignTime(designTime);
433 if (pages.count()>0){
434 printPages(pages, printers, printToAllPrinters);
435 }
436 } catch(ReportError &exception){
437 saveError(exception.what());
438 return false;
439 }
440 return true;
441 }
442
printToFile(const QString & fileName)443 void ReportEnginePrivate::printToFile(const QString &fileName)
444 {
445 if (!fileName.isEmpty()){
446 QFile file(fileName);
447 if (file.open(QIODevice::WriteOnly)){
448 QTextStream out(&file);
449 try {
450 dataManager()->setDesignTime(false);
451 out<<renderToString();
452 dataManager()->setDesignTime(true);
453 } catch( ReportError &exception){
454 saveError(exception.what());
455 }
456 }
457 file.close();
458 }
459 }
460
printToPDF(const QString & fileName)461 bool ReportEnginePrivate::printToPDF(const QString &fileName)
462 {
463 return exportReport("PDF", fileName);
464 }
465
exportReport(QString exporterName,const QString & fileName,const QMap<QString,QVariant> & params)466 bool ReportEnginePrivate::exportReport(QString exporterName, const QString &fileName, const QMap<QString, QVariant> ¶ms)
467 {
468 QString fn = fileName;
469 if (ExportersFactory::instance().map().contains(exporterName)){
470 ReportExporterInterface* e = ExportersFactory::instance().objectCreator(exporterName)(this);
471 if (fn.isEmpty()){
472 QString defaultFileName = reportName().split(".")[0];
473 QString filter = QString("%1 (*.%2)").arg(e->exporterName()).arg(e->exporterFileExt());
474 QString fn = QFileDialog::getSaveFileName(0, tr("%1 file name").arg(e->exporterName()), defaultFileName, filter);
475 }
476 if (!fn.isEmpty()){
477 QFileInfo fi(fn);
478 if (fi.suffix().isEmpty())
479 fn += QString(".%1").arg(e->exporterFileExt());
480
481 bool designTime = dataManager()->designTime();
482 dataManager()->setDesignTime(false);
483 ReportPages pages = renderToPages();
484 dataManager()->setDesignTime(designTime);
485 bool result = e->exportPages(pages, fn, params);
486 delete e;
487 return result;
488 }
489 }
490 return false;
491 }
492
showPreviewWindow(ReportPages pages,PreviewHints hints,QPrinter * printer)493 bool ReportEnginePrivate::showPreviewWindow(ReportPages pages, PreviewHints hints, QPrinter* printer)
494 {
495 if (pages.count()>0){
496 Q_Q(ReportEngine);
497 PreviewReportWindow* w = new PreviewReportWindow(q, 0, settings());
498 w->setWindowFlags(Qt::Dialog|Qt::WindowMaximizeButtonHint|Qt::WindowCloseButtonHint| Qt::WindowMinMaxButtonsHint);
499 w->setAttribute(Qt::WA_DeleteOnClose,true);
500 w->setWindowModality(Qt::ApplicationModal);
501 //w->setWindowIcon(QIcon(":/report/images/main.ico"));
502 w->setWindowIcon(m_previewWindowIcon);
503 w->setWindowTitle(m_previewWindowTitle);
504 w->setSettings(settings());
505 w->setPages(pages);
506 w->setLayoutDirection(m_previewLayoutDirection);
507 w->setStyleSheet(styleSheet());
508 // w->setDefaultPrinter()
509
510 if (!dataManager()->errorsList().isEmpty()){
511 w->setErrorMessages(dataManager()->errorsList());
512 }
513
514 if (!hints.testFlag(PreviewBarsUserSetting)){
515 w->setMenuVisible(!hints.testFlag(HidePreviewMenuBar));
516 w->setStatusBarVisible(!hints.testFlag(HidePreviewStatusBar));
517 w->setToolBarVisible(!hints.testFlag(HidePreviewToolBar));
518 }
519
520 w->setHideResultEditButton(resultIsEditable());
521 w->setHidePrintButton(printIsVisible());
522 w->setHideSaveToFileButton(saveToFileIsVisible());
523 w->setHidePrintToPdfButton(printToPdfIsVisible());
524 w->setEnablePrintMenu(printIsVisible() || printToPdfIsVisible());
525
526 m_activePreview = w;
527
528 w->setPreviewScaleType(m_previewScaleType, m_previewScalePercent);
529
530 connect(w,SIGNAL(destroyed(QObject*)), this, SLOT(slotPreviewWindowDestroyed(QObject*)));
531 connect(w, SIGNAL(onSave(bool&, LimeReport::IPreparedPages*)),
532 this, SIGNAL(onSavePreview(bool&, LimeReport::IPreparedPages*)));
533 w->exec();
534 return true;
535 }
536 return false;
537 }
538
previewReport(PreviewHints hints)539 void ReportEnginePrivate::previewReport(PreviewHints hints)
540 {
541 previewReport(0, hints);
542 }
543
previewReport(QPrinter * printer,PreviewHints hints)544 void ReportEnginePrivate::previewReport(QPrinter* printer, PreviewHints hints)
545 {
546 try{
547 dataManager()->setDesignTime(false);
548 ReportPages pages = renderToPages();
549 dataManager()->setDesignTime(true);
550 showPreviewWindow(pages, hints, printer);
551 } catch (ReportError &exception){
552 saveError(exception.what());
553 showError(exception.what());
554 }
555 }
556
getDesignerWindow()557 ReportDesignWindowInterface*ReportEnginePrivate::getDesignerWindow()
558 {
559 if (!m_designerWindow) {
560 if (m_designerFactory){
561 m_designerWindow = m_designerFactory->getDesignerWindow(this,QApplication::activeWindow(),settings());
562 m_designerWindow->setAttribute(Qt::WA_DeleteOnClose,true);
563 m_designerWindow->setWindowIcon(QIcon(":report/images/logo32"));
564 m_designerWindow->setShowProgressDialog(m_showProgressDialog);
565 } else {
566 #ifdef HAVE_REPORT_DESIGNER
567 m_designerWindow = new LimeReport::ReportDesignWindow(this,QApplication::activeWindow(),settings());
568 m_designerWindow->setAttribute(Qt::WA_DeleteOnClose,true);
569 m_designerWindow->setWindowIcon(QIcon(":report/images/logo32"));
570 m_designerWindow->setShowProgressDialog(m_showProgressDialog);
571 #endif
572 }
573 }
574 if (m_designerWindow){
575 m_datasources->updateDatasourceModel();
576 }
577 return m_designerWindow;
578 }
579
createPreviewWidget(QWidget * parent)580 PreviewReportWidget* ReportEnginePrivate::createPreviewWidget(QWidget* parent){
581
582 Q_Q(ReportEngine);
583 PreviewReportWidget* widget = new PreviewReportWidget(q, parent);
584 try{
585 dataManager()->setDesignTime(false);
586 ReportPages pages = renderToPages();
587 dataManager()->setDesignTime(true);
588 if (pages.count()>0)
589 widget->d_ptr->setPages(pages);
590 } catch (ReportError &exception){
591 saveError(exception.what());
592 showError(exception.what());
593 }
594 return widget;
595 }
596
createPreviewScene(QObject * parent)597 PageDesignIntf* ReportEnginePrivate::createPreviewScene(QObject* parent){
598 PageDesignIntf* result = 0;
599 try {
600 ReportPages pages = renderToPages();
601 result = new PageDesignIntf(parent);
602 result->setPageItems(pages);
603 result->setItemMode(PrintMode);
604 } catch (ReportError &exception){
605 saveError(exception.what());
606 showError(exception.what());
607 }
608 return result;
609 }
610
emitSaveReport()611 bool ReportEnginePrivate::emitSaveReport()
612 {
613 bool result = false;
614 emit onSave(result);
615 return result;
616 }
617
emitSaveReportAs()618 bool ReportEnginePrivate::emitSaveReportAs()
619 {
620 bool result = false;
621 emit onSaveAs(result);
622 return result;
623 }
624
emitLoadReport()625 bool ReportEnginePrivate::emitLoadReport()
626 {
627 bool result = false;
628 emit onLoad(result);
629 return result;
630 }
631
emitSaveFinished()632 void ReportEnginePrivate::emitSaveFinished()
633 {
634 emit saveFinished();
635 }
636
emitLoadFinished()637 void ReportEnginePrivate::emitLoadFinished()
638 {
639 emit loadFinished();
640 }
641
emitPrintedToPDF(QString fileName)642 void ReportEnginePrivate::emitPrintedToPDF(QString fileName)
643 {
644 emit printedToPDF(fileName);
645 }
646
isSaved()647 bool ReportEnginePrivate::isSaved()
648 {
649 foreach (PageDesignIntf* page, m_pages) {
650 if (!page->isSaved()) return false;
651 }
652 return true;
653 }
654
setCurrentReportsDir(const QString & dirName)655 void ReportEnginePrivate::setCurrentReportsDir(const QString &dirName)
656 {
657 if (QDir(dirName).exists())
658 m_reportsDir = dirName;
659 }
660
slotLoadFromFile(const QString & fileName)661 bool ReportEnginePrivate::slotLoadFromFile(const QString &fileName)
662 {
663 EASY_BLOCK("ReportEnginePrivate::slotLoadFromFile")
664 PreviewReportWindow *currentPreview = qobject_cast<PreviewReportWindow *>(m_activePreview);
665
666 if (!QFile::exists(fileName))
667 {
668 if ( hasActivePreview() )
669 {
670 QMessageBox::information( NULL,
671 tr( "Report File Change" ),
672 tr( "The report file \"%1\" has changed names or been deleted.\n\nThis preview is no longer valid." ).arg( fileName )
673 );
674
675 clearReport();
676
677 currentPreview->close();
678 }
679
680 return false;
681 }
682
683 clearReport();
684
685 ItemsReaderIntf::Ptr reader = FileXMLReader::create(fileName);
686 reader->setPassPhrase(m_passPhrase);
687 if (reader->first()){
688 if (reader->readItem(this)){
689 m_fileName=fileName;
690 QFileInfo fi(fileName);
691 m_reportName = fi.fileName();
692
693 QString dbSettingFileName = fi.absolutePath()+"/"+fi.baseName()+".db";
694 if (QFile::exists(dbSettingFileName)){
695 QSettings dbcredentals(dbSettingFileName, QSettings::IniFormat);
696 foreach (ConnectionDesc* connection, dataManager()->conections()) {
697 if (!connection->keepDBCredentials()){
698 dbcredentals.beginGroup(connection->name());
699 connection->setUserName(dbcredentals.value("user").toString());
700 connection->setPassword(dbcredentals.value("password").toString());
701 dbcredentals.endGroup();
702 }
703 }
704 }
705 EASY_BLOCK("Connect auto connections")
706 dataManager()->connectAutoConnections();
707 EASY_END_BLOCK;
708 dropChanges();
709
710 if ( hasActivePreview() )
711 {
712 currentPreview->reloadPreview();
713 }
714 EASY_END_BLOCK;
715 return true;
716 }
717 }
718 m_lastError = reader->lastError();
719 EASY_END_BLOCK;
720 return false;
721 }
722
cancelRender()723 void ReportEnginePrivate::cancelRender()
724 {
725 if (m_reportRender)
726 m_reportRender->cancelRender();
727 m_reportRendering = false;
728 }
729
cancelPrinting()730 void ReportEnginePrivate::cancelPrinting()
731 {
732 m_cancelPrinting = true;
733 }
734
createPreviewScene(QObject * parent)735 QGraphicsScene* ReportEngine::createPreviewScene(QObject* parent){
736 Q_D(ReportEngine);
737 return d->createPreviewScene(parent);
738 }
739
designReport(bool showModal)740 void ReportEnginePrivate::designReport(bool showModal)
741 {
742 ReportDesignWindowInterface* designerWindow = getDesignerWindow();
743 if (designerWindow){
744 dataManager()->setDesignTime(true);
745 connect(designerWindow, SIGNAL(destroyed(QObject*)), this, SLOT(slotDesignerWindowDestroyed(QObject*)));
746 #ifdef Q_OS_WIN
747 designerWindow->setWindowModality(Qt::ApplicationModal);
748 #endif
749 if (!showModal){
750 designerWindow->show();;
751 } else {
752 designerWindow->showModal();
753 }
754 } else {
755 qDebug()<<(tr("Designer not found!"));
756 }
757 }
758
setSettings(QSettings * value)759 void ReportEnginePrivate::setSettings(QSettings* value)
760 {
761 if (value){
762 if (m_ownedSettings&&m_settings)
763 delete m_settings;
764 m_settings = value;
765 m_ownedSettings = false;
766 }
767 }
768
settings()769 QSettings*ReportEnginePrivate::settings()
770 {
771 if (m_settings){
772 return m_settings;
773 } else {
774 m_settings = new QSettings("LimeReport",QApplication::applicationName());
775 m_ownedSettings=true;
776 return m_settings;
777 }
778 }
779
loadFromFile(const QString & fileName,bool autoLoadPreviewOnChange)780 bool ReportEnginePrivate::loadFromFile(const QString &fileName, bool autoLoadPreviewOnChange)
781 {
782 // only watch one file at a time
783
784 if ( !m_fileWatcher->files().isEmpty() )
785 {
786 m_fileWatcher->removePaths( m_fileWatcher->files() );
787 }
788
789 if ( autoLoadPreviewOnChange )
790 {
791 m_fileWatcher->addPath( fileName );
792 }
793
794 bool result = slotLoadFromFile( fileName );
795 if (result) {
796 emit loadFinished();
797 }
798 return result;
799 }
800
loadFromByteArray(QByteArray * data,const QString & name)801 bool ReportEnginePrivate::loadFromByteArray(QByteArray* data, const QString &name){
802 clearReport();
803
804 ItemsReaderIntf::Ptr reader = ByteArrayXMLReader::create(data);
805 reader->setPassPhrase(m_passPhrase);
806 if (reader->first()){
807 if (reader->readItem(this)){
808 m_fileName = "";
809 m_reportName = name;
810 emit loadFinished();
811 return true;
812 };
813 }
814 return false;
815 }
816
loadFromString(const QString & report,const QString & name)817 bool ReportEnginePrivate::loadFromString(const QString &report, const QString &name)
818 {
819 clearReport();
820
821 ItemsReaderIntf::Ptr reader = StringXMLreader::create(report);
822 reader->setPassPhrase(m_passPhrase);
823 if (reader->first()){
824 if (reader->readItem(this)){
825 m_fileName = "";
826 m_reportName = name;
827 emit loadFinished();
828 return true;
829 };
830 }
831 return false;
832 }
833
saveToFile(const QString & fileName)834 bool ReportEnginePrivate::saveToFile(const QString &fileName)
835 {
836 if (fileName.isEmpty() & m_fileName.isEmpty()) return false;
837 QString fn = fileName.isEmpty() ? m_fileName : fileName;
838 QFileInfo fi(fn);
839
840 if (fi.suffix().isEmpty())
841 fn+=".lrxml";
842
843 QString dbSettingFileName = fi.absolutePath()+"/"+fi.baseName()+".db";
844 QSettings dbcredentals(dbSettingFileName, QSettings::IniFormat);
845
846 foreach (ConnectionDesc* connection, dataManager()->conections()) {
847 if (!connection->keepDBCredentials()){
848 dbcredentals.beginGroup(connection->name());
849 dbcredentals.setValue("user",connection->userName());
850 dbcredentals.setValue("password",connection->password());
851 dbcredentals.endGroup();
852 connection->setPassword("");
853 connection->setUserName("");
854 }
855 }
856
857 QScopedPointer< ItemsWriterIntf > writer(new XMLWriter());
858 writer->setPassPhrase(m_passPhrase);
859 writer->putItem(this);
860 m_fileName=fn;
861 bool saved = writer->saveToFile(fn);
862
863 foreach (ConnectionDesc* connection, dataManager()->conections()) {
864 if (!connection->keepDBCredentials()){
865 dbcredentals.beginGroup(connection->name());
866 connection->setUserName(dbcredentals.value("user").toString());
867 connection->setPassword(dbcredentals.value("password").toString());
868 dbcredentals.endGroup();
869 }
870 }
871
872 if (saved){
873 foreach(PageDesignIntf* page, m_pages){
874 page->setToSaved();
875 }
876 }
877 dropChanges();
878 return saved;
879 }
880
saveToByteArray()881 QByteArray ReportEnginePrivate::saveToByteArray()
882 {
883 QScopedPointer< ItemsWriterIntf > writer(new XMLWriter());
884 writer->setPassPhrase(m_passPhrase);
885 writer->putItem(this);
886 QByteArray result = writer->saveToByteArray();
887 if (!result.isEmpty()){
888 foreach(PageDesignIntf* page, m_pages){
889 page->setToSaved();
890 }
891 }
892 dropChanges();
893 return result;
894 }
895
saveToString()896 QString ReportEnginePrivate::saveToString(){
897 QScopedPointer< ItemsWriterIntf > writer(new XMLWriter());
898 writer->setPassPhrase(m_passPhrase);
899 writer->putItem(this);
900 QString result = writer->saveToString();
901 if (!result.isEmpty()){
902 foreach(PageDesignIntf* page, m_pages){
903 page->setToSaved();
904 }
905 }
906 dropChanges();
907 return result;
908 }
909
isNeedToSave()910 bool ReportEnginePrivate::isNeedToSave()
911 {
912 foreach(PageDesignIntf* page, m_pages){
913 if (page->isHasChanges()) return true;
914 }
915 if (dataManager()->hasChanges()){
916 return true;
917 }
918 if (scriptContext()->hasChanges())
919 return true;
920 return false;
921 }
922
renderToString()923 QString ReportEnginePrivate::renderToString()
924 {
925 LimeReport::ReportRender render;
926 updateTranslations();
927 dataManager()->connectAllDatabases();
928 dataManager()->setDesignTime(false);
929 if (m_pages.count()){
930 render.setDatasources(dataManager());
931 render.setScriptContext(scriptContext());
932 return render.renderPageToString(m_pages.at(0)->pageItem());
933 } else return QString();
934
935 }
936
previewScaleType()937 ScaleType ReportEnginePrivate::previewScaleType()
938 {
939 return m_previewScaleType;
940 }
941
previewScalePercent()942 int ReportEnginePrivate::previewScalePercent()
943 {
944 return m_previewScalePercent;
945 }
946
setPreviewScaleType(const ScaleType & scaleType,int percent)947 void ReportEnginePrivate::setPreviewScaleType(const ScaleType &scaleType, int percent)
948 {
949 m_previewScaleType = scaleType;
950 m_previewScalePercent = percent;
951 }
952
addWatermark(const WatermarkSetting & watermarkSetting)953 void ReportEnginePrivate::addWatermark(const WatermarkSetting &watermarkSetting)
954 {
955 m_watermarks.append(watermarkSetting);
956 }
957
clearWatermarks()958 void ReportEnginePrivate::clearWatermarks()
959 {
960 m_watermarks.clear();
961 }
962
getPageByName(const QString & pageName)963 PageItemDesignIntf* ReportEnginePrivate::getPageByName(const QString& pageName)
964 {
965 foreach(PageItemDesignIntf* page, m_renderingPages){
966 if ( page->objectName().compare(pageName, Qt::CaseInsensitive) == 0)
967 return page;
968 }
969 return 0;
970 }
971
preparedPages()972 IPreparedPages *ReportEnginePrivate::preparedPages(){
973 return m_preparedPagesManager;
974 }
975
showPreparedPages(PreviewHints hints)976 bool ReportEnginePrivate::showPreparedPages(PreviewHints hints)
977 {
978 return showPreparedPages(0, hints);
979 }
980
showPreparedPages(QPrinter * defaultPrinter,PreviewHints hints)981 bool ReportEnginePrivate::showPreparedPages(QPrinter* defaultPrinter, PreviewHints hints)
982 {
983 return showPreviewWindow(m_preparedPages, hints, defaultPrinter);
984 }
985
prepareReportPages()986 bool ReportEnginePrivate::prepareReportPages()
987 {
988 try{
989 dataManager()->setDesignTime(false);
990 m_preparedPages = renderToPages();
991 dataManager()->setDesignTime(true);
992 } catch (ReportError &exception){
993 saveError(exception.what());
994 showError(exception.what());
995 return false;
996 }
997 return !m_preparedPages.isEmpty();
998 }
999
printPreparedPages()1000 bool ReportEnginePrivate::printPreparedPages()
1001 {
1002 return printPages(m_preparedPages, 0);
1003 }
1004
previewLayoutDirection()1005 Qt::LayoutDirection ReportEnginePrivate::previewLayoutDirection()
1006 {
1007 return m_previewLayoutDirection;
1008 }
1009
setPreviewLayoutDirection(const Qt::LayoutDirection & layoutDirection)1010 void ReportEnginePrivate::setPreviewLayoutDirection(const Qt::LayoutDirection& layoutDirection)
1011 {
1012 m_previewLayoutDirection = layoutDirection;
1013 }
1014
setPassPhrase(const QString & passPhrase)1015 void ReportEnginePrivate::setPassPhrase(const QString &passPhrase)
1016 {
1017 m_passPhrase = passPhrase;
1018 }
1019
reorderPages(const QList<PageDesignIntf * > & reorderedPages)1020 void ReportEnginePrivate::reorderPages(const QList<PageDesignIntf *>& reorderedPages)
1021 {
1022 m_pages.clear();
1023 foreach(PageDesignIntf* page, reorderedPages){
1024 m_pages.append(page);
1025 }
1026 }
1027
clearSelection()1028 void ReportEnginePrivate::clearSelection()
1029 {
1030 foreach (PageDesignIntf* page, m_pages) {
1031 foreach(QGraphicsItem* item, page->selectedItems()){
1032 item->setSelected(false);
1033 }
1034 }
1035 }
1036
addTranslationLanguage(QLocale::Language language)1037 bool ReportEnginePrivate::addTranslationLanguage(QLocale::Language language)
1038 {
1039 if (!m_translations.keys().contains(language)){
1040 ReportTranslation* translation = 0;
1041 if (!m_translations.contains(QLocale::AnyLanguage)){
1042 translation = new ReportTranslation(QLocale::AnyLanguage,m_pages);
1043 m_translations.insert(QLocale::AnyLanguage,translation);
1044 }
1045 translation = new ReportTranslation(language,m_pages);
1046 m_translations.insert(language, translation);
1047 return true;
1048 } else {
1049 m_lastError = tr("Language %1 already exists").arg(QLocale::languageToString(language));
1050 return false;
1051 }
1052 }
1053
removeTranslationLanguage(QLocale::Language language)1054 bool ReportEnginePrivate::removeTranslationLanguage(QLocale::Language language)
1055 {
1056 return m_translations.remove(language) != 0;
1057 }
1058
activateLanguage(QLocale::Language language)1059 void ReportEnginePrivate::activateLanguage(QLocale::Language language)
1060 {
1061 if (!m_translations.keys().contains(language)) return;
1062 ReportTranslation* translation = m_translations.value(language);
1063
1064 foreach(PageTranslation* pageTranslation, translation->pagesTranslation()){
1065 PageItemDesignIntf* page = getPageByName(pageTranslation->pageName);
1066 if (page){
1067 foreach(ItemTranslation* itemTranslation, pageTranslation->itemsTranslation){
1068 BaseDesignIntf* item = page->childByName(itemTranslation->itemName);
1069 if (item) {
1070 foreach(PropertyTranslation* propertyTranslation, itemTranslation->propertyesTranslation){
1071 if (propertyTranslation->checked)
1072 item->setProperty(propertyTranslation->propertyName.toLatin1(), propertyTranslation->value);
1073 }
1074 }
1075 }
1076 }
1077 }
1078 }
1079
designerLanguages()1080 QList<QLocale::Language> ReportEnginePrivate::designerLanguages()
1081 {
1082
1083 QList<QLocale::Language> result;
1084 emit getAvailableDesignerLanguages(&result);
1085 return result;
1086 }
1087
currentDesignerLanguage()1088 QLocale::Language ReportEnginePrivate::currentDesignerLanguage()
1089 {
1090 QLocale::Language result = emit getCurrentDefaultDesignerLanguage();
1091 return result;
1092 }
1093
setCurrentDesignerLanguage(QLocale::Language language)1094 void ReportEnginePrivate::setCurrentDesignerLanguage(QLocale::Language language)
1095 {
1096 m_currentDesignerLanguage = language;
1097 emit currentDefaultDesignerLanguageChanged(language);
1098 }
1099
styleSheet() const1100 QString ReportEnginePrivate::styleSheet() const
1101 {
1102 return m_styleSheet;
1103 }
1104
setStyleSheet(const QString & styleSheet)1105 void ReportEnginePrivate::setStyleSheet(const QString &styleSheet)
1106 {
1107 m_styleSheet = styleSheet;
1108 }
1109
setReportLanguage(QLocale::Language language)1110 bool ReportEnginePrivate::setReportLanguage(QLocale::Language language){
1111 m_reportLanguage = language;
1112 if (!m_translations.keys().contains(language)) return false;
1113 // activateLanguage(language);
1114 return true;
1115 }
1116
aviableLanguages()1117 QList<QLocale::Language> ReportEnginePrivate::aviableLanguages()
1118 {
1119 return m_translations.keys();
1120 }
1121
reportTranslation(QLocale::Language language)1122 ReportTranslation*ReportEnginePrivate::reportTranslation(QLocale::Language language)
1123 {
1124 return m_translations.value(language);
1125 }
1126
resultIsEditable() const1127 bool ReportEnginePrivate::resultIsEditable() const
1128 {
1129 return m_resultIsEditable;
1130 }
1131
setResultEditable(bool value)1132 void ReportEnginePrivate::setResultEditable(bool value)
1133 {
1134 m_resultIsEditable = value;
1135 }
1136
saveToFileIsVisible() const1137 bool ReportEnginePrivate::saveToFileIsVisible() const
1138 {
1139 return m_saveToFileVisible;
1140 }
1141
setSaveToFileVisible(bool value)1142 void ReportEnginePrivate::setSaveToFileVisible(bool value)
1143 {
1144 m_saveToFileVisible = value;
1145 }
1146
printToPdfIsVisible() const1147 bool ReportEnginePrivate::printToPdfIsVisible() const
1148 {
1149 return m_printToPdfVisible;
1150 }
1151
setPrintToPdfVisible(bool value)1152 void ReportEnginePrivate::setPrintToPdfVisible(bool value)
1153 {
1154 m_printToPdfVisible = value;
1155 }
1156
printIsVisible() const1157 bool ReportEnginePrivate::printIsVisible() const
1158 {
1159 return m_printVisible;
1160 }
1161
setPrintVisible(bool value)1162 void ReportEnginePrivate::setPrintVisible(bool value)
1163 {
1164 m_printVisible = value;
1165 }
1166
suppressFieldAndVarError() const1167 bool ReportEnginePrivate::suppressFieldAndVarError() const
1168 {
1169 return m_reportSettings.suppressAbsentFieldsAndVarsWarnings();
1170 }
1171
setSuppressFieldAndVarError(bool suppressFieldAndVarError)1172 void ReportEnginePrivate::setSuppressFieldAndVarError(bool suppressFieldAndVarError)
1173 {
1174 m_reportSettings.setSuppressAbsentFieldsAndVarsWarnings(suppressFieldAndVarError);
1175 }
1176
isBusy()1177 bool ReportEnginePrivate::isBusy()
1178 {
1179 return m_reportRendering;
1180 }
1181
previewWindowTitle() const1182 QString ReportEnginePrivate::previewWindowTitle() const
1183 {
1184 return m_previewWindowTitle;
1185 }
1186
setPreviewWindowTitle(const QString & previewWindowTitle)1187 void ReportEnginePrivate::setPreviewWindowTitle(const QString &previewWindowTitle)
1188 {
1189 m_previewWindowTitle = previewWindowTitle;
1190 }
1191
previewWindowPageBackground()1192 QColor ReportEnginePrivate::previewWindowPageBackground()
1193 {
1194 return m_previewPageBackgroundColor;
1195 }
1196
setPreviewWindowPageBackground(QColor color)1197 void ReportEnginePrivate::setPreviewWindowPageBackground(QColor color)
1198 {
1199 m_previewPageBackgroundColor = color;
1200 }
1201
previewWindowIcon() const1202 QIcon ReportEnginePrivate::previewWindowIcon() const
1203 {
1204 return m_previewWindowIcon;
1205 }
1206
setPreviewWindowIcon(const QIcon & previewWindowIcon)1207 void ReportEnginePrivate::setPreviewWindowIcon(const QIcon &previewWindowIcon)
1208 {
1209 m_previewWindowIcon = previewWindowIcon;
1210 }
1211
createRenderingPage(PageItemDesignIntf * page)1212 PageItemDesignIntf* ReportEnginePrivate::createRenderingPage(PageItemDesignIntf* page){
1213 PageItemDesignIntf* result = dynamic_cast<PageItemDesignIntf*>(page->cloneItem(page->itemMode()));
1214 ICollectionContainer* co = dynamic_cast<ICollectionContainer*>(result);
1215 if (co) co->collectionLoadFinished("children");
1216 return result;
1217 }
1218
initReport()1219 void ReportEnginePrivate::initReport()
1220 {
1221 for(int index = 0; index < pageCount(); ++index){
1222 PageDesignIntf* page = pageAt(index);
1223 if (page != 0){
1224 foreach (BaseDesignIntf* item, page->pageItem()->childBaseItems()) {
1225 IPainterProxy *proxyItem = dynamic_cast<IPainterProxy *>(item);
1226 if (proxyItem){
1227 proxyItem->setExternalPainter(this);
1228 }
1229 }
1230 }
1231 }
1232 }
1233
paintByExternalPainter(const QString & objectName,QPainter * painter,const QStyleOptionGraphicsItem * options)1234 void ReportEnginePrivate::paintByExternalPainter(const QString& objectName, QPainter* painter, const QStyleOptionGraphicsItem* options)
1235 {
1236 emit externalPaint(objectName, painter, options);
1237 }
1238
createWatermark(PageDesignIntf * page,WatermarkSetting watermarkSetting)1239 BaseDesignIntf* ReportEnginePrivate::createWatermark(PageDesignIntf* page, WatermarkSetting watermarkSetting)
1240 {
1241
1242 WatermarkHelper watermarkHelper(watermarkSetting);
1243
1244 BaseDesignIntf* watermark = page->addReportItem("TextItem", watermarkHelper.mapToPage(*page->pageItem()), watermarkHelper.sceneSize());
1245 if (watermark){
1246 watermark->setProperty("content", watermarkSetting.text());
1247 watermark->setProperty("font",watermarkSetting.font());
1248 watermark->setProperty("watermark",true);
1249 watermark->setProperty("itemLocation",1);
1250 watermark->setProperty("foregroundOpacity", watermarkSetting.opacity());
1251 watermark->setProperty("fontColor", watermarkSetting.color());
1252 }
1253 return watermark;
1254
1255 }
1256
clearRenderingPages()1257 void ReportEnginePrivate::clearRenderingPages(){
1258 qDeleteAll(m_renderingPages.begin(), m_renderingPages.end());
1259 m_renderingPages.clear();
1260 }
1261
renderToPages()1262 ReportPages ReportEnginePrivate::renderToPages()
1263 {
1264 int startTOCPage = -1;
1265 int pageAfterTOCIndex = -1;
1266
1267 if (m_reportRendering) return ReportPages();
1268 initReport();
1269 m_reportRender = ReportRender::Ptr(new ReportRender);
1270 updateTranslations();
1271 connect(m_reportRender.data(),SIGNAL(pageRendered(int)),
1272 this, SIGNAL(renderPageFinished(int)));
1273
1274 if (m_pages.count()){
1275
1276 #ifdef HAVE_UI_LOADER
1277 m_scriptEngineContext->initDialogs();
1278 #endif
1279 ReportPages result;
1280 m_reportRendering = true;
1281 m_reportRender->setDatasources(dataManager());
1282 m_reportRender->setScriptContext(scriptContext());
1283 clearRenderingPages();
1284 foreach (PageDesignIntf* page, m_pages) {
1285
1286 QVector<BaseDesignIntf*> watermarks;
1287 if (!m_watermarks.isEmpty()){
1288 foreach(WatermarkSetting watermarkSetting, m_watermarks){
1289 watermarks.append(createWatermark(page, watermarkSetting));
1290 }
1291 }
1292
1293 PageItemDesignIntf* rp = createRenderingPage(page->pageItem());
1294
1295
1296 qDeleteAll(watermarks.begin(),watermarks.end());
1297 watermarks.clear();
1298
1299 m_renderingPages.append(rp);
1300 scriptContext()->baseDesignIntfToScript(rp->objectName(), rp);
1301 }
1302
1303 scriptContext()->qobjectToScript("engine",this);
1304 #ifdef USE_QTSCRIPTENGINE
1305 ScriptEngineManager::instance().scriptEngine()->pushContext();
1306 #endif
1307 if (m_scriptEngineContext->runInitScript()){
1308
1309 dataManager()->clearErrors();
1310 dataManager()->connectAllDatabases();
1311 dataManager()->setDesignTime(false);
1312 dataManager()->updateDatasourceModel();
1313
1314 activateLanguage(m_reportLanguage);
1315 emit renderStarted();
1316 m_scriptEngineContext->setReportPages(&result);
1317
1318 for(int i = 0; i < m_renderingPages.count(); ++i){
1319 PageItemDesignIntf* page = m_renderingPages.at(i);
1320 if (!page->isTOC() && page->isPrintable()){
1321 page->setReportSettings(&m_reportSettings);
1322 result.append(m_reportRender->renderPageToPages(page));
1323 } else {
1324 startTOCPage = result.count();
1325 pageAfterTOCIndex = i+1;
1326 m_reportRender->createTOCMarker(page->resetPageNumber());
1327 }
1328 }
1329
1330 for (int i=0; i<m_renderingPages.count(); ++i){
1331 PageItemDesignIntf* page = m_renderingPages.at(i);
1332 if (page->isTOC()){
1333 page->setReportSettings(&m_reportSettings);
1334 if (i < m_renderingPages.count()){
1335 PageItemDesignIntf* secondPage = 0;
1336 if ( m_renderingPages.count() > (pageAfterTOCIndex))
1337 secondPage = m_renderingPages.at(pageAfterTOCIndex);
1338 ReportPages pages = m_reportRender->renderTOC(
1339 page,
1340 true,
1341 secondPage && secondPage->resetPageNumber()
1342 );
1343 for (int j=0; j<pages.count(); ++j){
1344 result.insert(startTOCPage+j,pages.at(j));
1345 }
1346
1347 } else {
1348 result.append(m_reportRender->renderPageToPages(page));
1349 }
1350 }
1351 }
1352
1353 m_reportRender->secondRenderPass(result);
1354
1355 emit renderFinished();
1356 m_reportRender.clear();
1357 clearRenderingPages();
1358 }
1359 m_reportRendering = false;
1360
1361 #ifdef USE_QTSCRIPTENGINE
1362 ScriptEngineManager::instance().scriptEngine()->popContext();
1363 #endif
1364 return result;
1365 } else {
1366 return ReportPages();
1367 }
1368 }
1369
lastError()1370 QString ReportEnginePrivate::lastError()
1371 {
1372 return m_lastError;
1373 }
1374
ReportEngine(QObject * parent)1375 ReportEngine::ReportEngine(QObject *parent)
1376 : QObject(parent), d_ptr(new ReportEnginePrivate()), m_showDesignerModal(true)
1377 {
1378 Q_D(ReportEngine);
1379 d->q_ptr=this;
1380 connect(d, SIGNAL(renderStarted()), this, SIGNAL(renderStarted()));
1381 connect(d, SIGNAL(renderPageFinished(int)),
1382 this, SIGNAL(renderPageFinished(int)));
1383 connect(d, SIGNAL(renderFinished()), this, SIGNAL(renderFinished()));
1384
1385 connect(d, SIGNAL(printingStarted(int)), this, SIGNAL(printingStarted(int)));
1386 connect(d, SIGNAL(pagePrintingFinished(int)),
1387 this, SIGNAL(pagePrintingFinished(int)));
1388 connect(d, SIGNAL(printingFinished()), this, SIGNAL(printingFinished()));
1389
1390 connect(d, SIGNAL(onSave(bool&)), this, SIGNAL(onSave(bool&)));
1391 connect(d, SIGNAL(onSaveAs(bool&)), this, SIGNAL(onSaveAs(bool&)));
1392 connect(d, SIGNAL(onLoad(bool&)), this, SIGNAL(onLoad(bool&)));
1393 connect(d, SIGNAL(saveFinished()), this, SIGNAL(saveFinished()));
1394 connect(d, SIGNAL(loadFinished()), this, SIGNAL(loadFinished()));
1395 connect(d, SIGNAL(cleared()), this, SIGNAL(cleared()));
1396 connect(d, SIGNAL(printedToPDF(QString)), this, SIGNAL(printedToPDF(QString)));
1397
1398 connect(d, SIGNAL(getAvailableDesignerLanguages(QList<QLocale::Language>*)),
1399 this, SIGNAL(getAvailableDesignerLanguages(QList<QLocale::Language>*)));
1400 connect(d, SIGNAL(currentDefaultDesignerLanguageChanged(QLocale::Language)),
1401 this, SIGNAL(currentDefaultDesignerLanguageChanged(QLocale::Language)));
1402 connect(d, SIGNAL(getCurrentDefaultDesignerLanguage()),
1403 this, SIGNAL(getCurrentDefaultDesignerLanguage()));
1404
1405 connect(d, SIGNAL(externalPaint(const QString&, QPainter*, const QStyleOptionGraphicsItem*)),
1406 this, SIGNAL(externalPaint(const QString&, QPainter*, const QStyleOptionGraphicsItem*)));
1407 connect(d, SIGNAL(onSavePreview(bool&, LimeReport::IPreparedPages*)),
1408 this, SIGNAL(onSavePreview(bool&, LimeReport::IPreparedPages*)));
1409 }
1410
~ReportEngine()1411 ReportEngine::~ReportEngine()
1412 {
1413 delete d_ptr;
1414 }
1415
printReport(QPrinter * printer)1416 bool ReportEngine::printReport(QPrinter *printer)
1417 {
1418 Q_D(ReportEngine);
1419 return d->printReport(printer);
1420 }
1421
printReport(QMap<QString,QPrinter * > printers,bool printToAllPrinters)1422 bool ReportEngine::printReport(QMap<QString, QPrinter*> printers, bool printToAllPrinters)
1423 {
1424 Q_D(ReportEngine);
1425 return d->printReport(printers, printToAllPrinters);
1426 }
1427
printPages(ReportPages pages,QPrinter * printer)1428 bool ReportEngine::printPages(ReportPages pages, QPrinter *printer){
1429 Q_D(ReportEngine);
1430 return d->printPages(pages,printer);
1431 }
1432
printToFile(const QString & fileName)1433 void ReportEngine::printToFile(const QString &fileName)
1434 {
1435 Q_D(ReportEngine);
1436 d->printToFile(fileName);
1437 }
1438
printToPDF(const QString & fileName)1439 bool ReportEngine::printToPDF(const QString &fileName)
1440 {
1441 Q_D(ReportEngine);
1442 return d->printToPDF(fileName);
1443 }
1444
exportReport(QString exporterName,const QString & fileName,const QMap<QString,QVariant> & params)1445 bool ReportEngine::exportReport(QString exporterName, const QString &fileName, const QMap<QString, QVariant> ¶ms)
1446 {
1447 Q_D(ReportEngine);
1448 return d->exportReport(exporterName, fileName, params);
1449 }
1450
previewReport(PreviewHints hints)1451 void ReportEngine::previewReport(PreviewHints hints)
1452 {
1453 Q_D(ReportEngine);
1454 if (m_settings)
1455 d->setSettings(m_settings);
1456 d->previewReport(hints);
1457 }
1458
previewReport(QPrinter * printer,PreviewHints hints)1459 void ReportEngine::previewReport(QPrinter *printer, PreviewHints hints)
1460 {
1461 Q_D(ReportEngine);
1462 if (m_settings)
1463 d->setSettings(m_settings);
1464 d->previewReport(printer, hints);
1465 }
1466
designReport()1467 void ReportEngine::designReport()
1468 {
1469 Q_D(ReportEngine);
1470 if (m_settings)
1471 d->setSettings(m_settings);
1472 d->designReport(showDesignerModal());
1473 }
1474
getDesignerWindow()1475 ReportDesignWindowInterface* ReportEngine::getDesignerWindow()
1476 {
1477 Q_D(ReportEngine);
1478 return d->getDesignerWindow();
1479 }
1480
createPreviewWidget(QWidget * parent)1481 PreviewReportWidget* ReportEngine::createPreviewWidget(QWidget *parent)
1482 {
1483 Q_D(ReportEngine);
1484 return d->createPreviewWidget(parent);
1485 }
1486
setPreviewWindowTitle(const QString & title)1487 void ReportEngine::setPreviewWindowTitle(const QString &title)
1488 {
1489 Q_D(ReportEngine);
1490 d->setPreviewWindowTitle(title);
1491 }
1492
setPreviewWindowIcon(const QIcon & icon)1493 void ReportEngine::setPreviewWindowIcon(const QIcon &icon)
1494 {
1495 Q_D(ReportEngine);
1496 d->setPreviewWindowIcon(icon);
1497 }
1498
setPreviewPageBackgroundColor(QColor color)1499 void ReportEngine::setPreviewPageBackgroundColor(QColor color)
1500 {
1501 Q_D(ReportEngine);
1502 d->setPreviewWindowPageBackground(color);
1503 }
1504
setResultEditable(bool value)1505 void ReportEngine::setResultEditable(bool value)
1506 {
1507 Q_D(ReportEngine);
1508 d->setResultEditable(value);
1509 }
1510
resultIsEditable()1511 bool ReportEngine::resultIsEditable()
1512 {
1513 Q_D(ReportEngine);
1514 return d->resultIsEditable();
1515 }
1516
setSaveToFileVisible(bool value)1517 void ReportEngine::setSaveToFileVisible(bool value)
1518 {
1519 Q_D(ReportEngine);
1520 d->setSaveToFileVisible(value);
1521 }
1522
saveToFileIsVisible()1523 bool ReportEngine::saveToFileIsVisible()
1524 {
1525 Q_D(ReportEngine);
1526 return d->saveToFileIsVisible();
1527 }
1528
setPrintToPdfVisible(bool value)1529 void ReportEngine::setPrintToPdfVisible(bool value)
1530 {
1531 Q_D(ReportEngine);
1532 d->setPrintToPdfVisible(value);
1533 }
1534
printToPdfIsVisible()1535 bool ReportEngine::printToPdfIsVisible()
1536 {
1537 Q_D(ReportEngine);
1538 return d->printToPdfIsVisible();
1539 }
1540
setPrintVisible(bool value)1541 void ReportEngine::setPrintVisible(bool value)
1542 {
1543 Q_D(ReportEngine);
1544 d->setPrintVisible(value);
1545 }
1546
printIsVisible()1547 bool ReportEngine::printIsVisible()
1548 {
1549 Q_D(ReportEngine);
1550 return d->printIsVisible();
1551 }
1552
isBusy()1553 bool ReportEngine::isBusy()
1554 {
1555 Q_D(ReportEngine);
1556 return d->isBusy();
1557 }
1558
setPassPhrase(QString & passPhrase)1559 void ReportEngine::setPassPhrase(QString &passPhrase)
1560 {
1561 Q_D(ReportEngine);
1562 d->setPassPhrase(passPhrase);
1563 }
1564
availableLanguages()1565 QList<QLocale::Language> ReportEngine::availableLanguages()
1566 {
1567 Q_D(ReportEngine);
1568 return d->aviableLanguages();
1569 }
1570
setReportLanguage(QLocale::Language language)1571 bool ReportEngine::setReportLanguage(QLocale::Language language)
1572 {
1573 Q_D(ReportEngine);
1574 return d->setReportLanguage(language);
1575 }
1576
previewLayoutDirection()1577 Qt::LayoutDirection ReportEngine::previewLayoutDirection()
1578 {
1579 Q_D(ReportEngine);
1580 return d->previewLayoutDirection();
1581 }
1582
setPreviewLayoutDirection(const Qt::LayoutDirection & previewLayoutDirection)1583 void ReportEngine::setPreviewLayoutDirection(const Qt::LayoutDirection& previewLayoutDirection)
1584 {
1585 Q_D(ReportEngine);
1586 d->setPreviewLayoutDirection(previewLayoutDirection);
1587 }
1588
designerLanguages()1589 QList<QLocale::Language> ReportEngine::designerLanguages()
1590 {
1591 Q_D(ReportEngine);
1592 return d->designerLanguages();
1593 }
1594
currentDesignerLanguage()1595 QLocale::Language ReportEngine::currentDesignerLanguage()
1596 {
1597 Q_D(ReportEngine);
1598 return d->currentDesignerLanguage();
1599 }
1600
previewScaleType()1601 ScaleType ReportEngine::previewScaleType()
1602 {
1603 Q_D(ReportEngine);
1604 return d->previewScaleType();
1605 }
1606
previewScalePercent()1607 int ReportEngine::previewScalePercent()
1608 {
1609 Q_D(ReportEngine);
1610 return d->previewScalePercent();
1611 }
1612
setPreviewScaleType(const ScaleType & previewScaleType,int percent)1613 void ReportEngine::setPreviewScaleType(const ScaleType &previewScaleType, int percent)
1614 {
1615 Q_D(ReportEngine);
1616 d->setPreviewScaleType(previewScaleType, percent);
1617 }
1618
addWatermark(const WatermarkSetting & watermarkSetting)1619 void ReportEngine::addWatermark(const WatermarkSetting &watermarkSetting)
1620 {
1621 Q_D(ReportEngine);
1622 d->addWatermark(watermarkSetting);
1623 }
1624
clearWatermarks()1625 void ReportEngine::clearWatermarks()
1626 {
1627 Q_D(ReportEngine);
1628 d->clearWatermarks();
1629 }
1630
preparedPages()1631 IPreparedPages *ReportEngine::preparedPages()
1632 {
1633 Q_D(ReportEngine);
1634 return d->preparedPages();
1635 }
1636
showPreparedPages(PreviewHints hints)1637 bool ReportEngine::showPreparedPages(PreviewHints hints)
1638 {
1639 Q_D(ReportEngine);
1640 return d->showPreparedPages(hints);
1641 }
1642
prepareReportPages()1643 bool ReportEngine::prepareReportPages()
1644 {
1645 Q_D(ReportEngine);
1646 return d->prepareReportPages();
1647 }
1648
printPreparedPages()1649 bool ReportEngine::printPreparedPages()
1650 {
1651 Q_D(ReportEngine);
1652 return d->printPreparedPages();
1653 }
1654
setShowProgressDialog(bool value)1655 void ReportEngine::setShowProgressDialog(bool value)
1656 {
1657 Q_D(ReportEngine);
1658 d->setShowProgressDialog(value);
1659 }
1660
isShowProgressDialog()1661 bool ReportEngine::isShowProgressDialog()
1662 {
1663 Q_D(ReportEngine);
1664 return d->isShowProgressDialog();
1665 }
1666
dataManager()1667 IDataSourceManager *ReportEngine::dataManager()
1668 {
1669 Q_D(ReportEngine);
1670 return d->dataManagerIntf();
1671 }
1672
scriptManager()1673 IScriptEngineManager *ReportEngine::scriptManager()
1674 {
1675 Q_D(ReportEngine);
1676 return d->scriptManagerIntf();
1677 }
1678
loadFromFile(const QString & fileName,bool autoLoadPreviewOnChange)1679 bool ReportEngine::loadFromFile(const QString &fileName, bool autoLoadPreviewOnChange)
1680 {
1681 Q_D(ReportEngine);
1682 return d->loadFromFile(fileName, autoLoadPreviewOnChange);
1683 }
1684
loadFromByteArray(QByteArray * data)1685 bool ReportEngine::loadFromByteArray(QByteArray* data){
1686 Q_D(ReportEngine);
1687 return d->loadFromByteArray(data);
1688 }
1689
loadFromString(const QString & data)1690 bool ReportEngine::loadFromString(const QString &data)
1691 {
1692 Q_D(ReportEngine);
1693 return d->loadFromString(data);
1694 }
1695
reportFileName()1696 QString ReportEngine::reportFileName()
1697 {
1698 Q_D(ReportEngine);
1699 return d->reportFileName();
1700 }
1701
setReportFileName(const QString & fileName)1702 void ReportEngine::setReportFileName(const QString &fileName)
1703 {
1704 Q_D(ReportEngine);
1705 return d->setReportFileName(fileName);
1706 }
1707
saveToFile(const QString & fileName)1708 bool ReportEngine::saveToFile(const QString &fileName)
1709 {
1710 Q_D(ReportEngine);
1711 return d->saveToFile(fileName);
1712 }
1713
saveToByteArray()1714 QByteArray ReportEngine::saveToByteArray()
1715 {
1716 Q_D(ReportEngine);
1717 return d->saveToByteArray();
1718 }
1719
saveToString()1720 QString ReportEngine::saveToString()
1721 {
1722 Q_D(ReportEngine);
1723 return d->saveToString();
1724 }
1725
lastError()1726 QString ReportEngine::lastError()
1727 {
1728 Q_D(ReportEngine);
1729 return d->lastError();
1730 }
1731
setCurrentReportsDir(const QString & dirName)1732 void ReportEngine::setCurrentReportsDir(const QString &dirName)
1733 {
1734 Q_D(ReportEngine);
1735 return d->setCurrentReportsDir(dirName);
1736 }
1737
setReportName(const QString & name)1738 void ReportEngine::setReportName(const QString &name)
1739 {
1740 Q_D(ReportEngine);
1741 return d->setReportName(name);
1742 }
1743
reportName()1744 QString ReportEngine::reportName()
1745 {
1746 Q_D(ReportEngine);
1747 return d->reportName();
1748 }
1749
cancelRender()1750 void ReportEngine::cancelRender()
1751 {
1752 Q_D(ReportEngine);
1753 d->cancelRender();
1754 }
1755
cancelPrinting()1756 void ReportEngine::cancelPrinting()
1757 {
1758 Q_D(ReportEngine);
1759 d->cancelPrinting();
1760 }
1761
ReportEngine(ReportEnginePrivate & dd,QObject * parent)1762 ReportEngine::ReportEngine(ReportEnginePrivate &dd, QObject *parent)
1763 :QObject(parent), d_ptr(&dd), m_showDesignerModal(true)
1764 {
1765 Q_D(ReportEngine);
1766 d->q_ptr=this;
1767 connect(d, SIGNAL(renderStarted()), this, SIGNAL(renderStarted()));
1768 connect(d, SIGNAL(renderPageFinished(int)),
1769 this, SIGNAL(renderPageFinished(int)));
1770 connect(d, SIGNAL(renderFinished()), this, SIGNAL(renderFinished()));
1771 }
1772
showDesignerModal() const1773 bool ReportEngine::showDesignerModal() const
1774 {
1775 return m_showDesignerModal;
1776 }
1777
setShowDesignerModal(bool showDesignerModal)1778 void ReportEngine::setShowDesignerModal(bool showDesignerModal)
1779 {
1780 m_showDesignerModal = showDesignerModal;
1781 }
1782
scriptManager()1783 ScriptEngineManager*LimeReport::ReportEnginePrivate::scriptManager(){
1784 ScriptEngineManager::instance().setContext(scriptContext());
1785 ScriptEngineManager::instance().setDataManager(dataManager());
1786 return &ScriptEngineManager::instance();
1787 }
1788
PrintProcessor(QPrinter * printer)1789 PrintProcessor::PrintProcessor(QPrinter* printer)
1790 : m_printer(printer), m_painter(0), m_firstPage(true)
1791 {m_renderPage.setItemMode(PrintMode);}
1792
1793
printPage(PageItemDesignIntf::Ptr page)1794 bool PrintProcessor::printPage(PageItemDesignIntf::Ptr page)
1795 {
1796 if (!m_firstPage && !m_painter->isActive()) return false;
1797 PageDesignIntf* backupPage = dynamic_cast<PageDesignIntf*>(page->scene());
1798
1799 //LimeReport::PageDesignIntf m_renderPage;
1800 //m_renderPage.setItemMode(PrintMode);
1801
1802 QPointF backupPagePos = page->pos();
1803 page->setPos(0,0);
1804 m_renderPage.setPageItem(page);
1805 m_renderPage.setSceneRect(m_renderPage.pageItem()->mapToScene(m_renderPage.pageItem()->rect()).boundingRect());
1806 initPrinter(m_renderPage.pageItem());
1807
1808 if (!m_firstPage){
1809 m_printer->newPage();
1810 } else {
1811 m_painter = new QPainter(m_printer);
1812 if (!m_painter->isActive()) return false;
1813 m_firstPage = false;
1814 }
1815
1816 qreal leftMargin, topMargin, rightMargin, bottomMargin;
1817 m_printer->getPageMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin, QPrinter::Millimeter);
1818
1819 QRectF printerPageRect = m_printer->pageRect(QPrinter::Millimeter);
1820 printerPageRect = QRectF(0,0,(printerPageRect.size().width() + rightMargin + leftMargin) * page->unitFactor(),
1821 (printerPageRect.size().height() + bottomMargin +topMargin) * page->unitFactor());
1822
1823 if (page->printBehavior() == PageItemDesignIntf::Split && m_printer->pageSize() != static_cast<QPrinter::PageSize>(page->pageSize()) &&
1824 printerPageRect.width() < page->geometry().width())
1825 {
1826 qreal pageWidth = page->geometry().width();
1827 qreal pageHeight = page->geometry().height();
1828 QRectF currentPrintingRect = printerPageRect;
1829 qreal curHeight = 0;
1830 qreal curWidth = 0;
1831 bool first = true;
1832 while (pageHeight > 0){
1833 while (curWidth < pageWidth){
1834 if (!first) m_printer->newPage(); else first = false;
1835 m_renderPage.render(m_painter, m_printer->pageRect(), currentPrintingRect);
1836 currentPrintingRect.adjust(printerPageRect.size().width(), 0, printerPageRect.size().width(), 0);
1837 curWidth += printerPageRect.size().width();
1838
1839 }
1840 pageHeight -= printerPageRect.size().height();
1841 curHeight += printerPageRect.size().height();
1842 currentPrintingRect = printerPageRect;
1843 currentPrintingRect.adjust(0, curHeight, 0, curHeight);
1844 curWidth = 0;
1845 }
1846
1847 } else {
1848 m_renderPage.render(m_painter);
1849 }
1850 page->setPos(backupPagePos);
1851 m_renderPage.removePageItem(page);
1852 if (backupPage) backupPage->reactivatePageItem(page);
1853 return true;
1854 }
1855
initPrinter(PageItemDesignIntf * page)1856 void PrintProcessor::initPrinter(PageItemDesignIntf* page)
1857 {
1858 if (page->oldPrintMode()){
1859 m_printer->setPageMargins(page->leftMargin(),
1860 page->topMargin(),
1861 page->rightMargin(),
1862 page->bottomMargin(),
1863 QPrinter::Millimeter);
1864 m_printer->setOrientation(static_cast<QPrinter::Orientation>(page->pageOrientation()));
1865 QSizeF pageSize = (page->pageOrientation()==PageItemDesignIntf::Landscape)?
1866 QSizeF(page->sizeMM().height(),page->sizeMM().width()):
1867 page->sizeMM();
1868 m_printer->setPaperSize(pageSize,QPrinter::Millimeter);
1869 } else {
1870 m_printer->setFullPage(page->fullPage());
1871 m_printer->setOrientation(static_cast<QPrinter::Orientation>(page->pageOrientation()));
1872 if (page->pageSize()==PageItemDesignIntf::Custom){
1873 QSizeF pageSize = (page->pageOrientation()==PageItemDesignIntf::Landscape)?
1874 QSizeF(page->sizeMM().height(),page->sizeMM().width()):
1875 page->sizeMM();
1876 if (page->getSetPageSizeToPrinter() || m_printer->outputFormat() == QPrinter::PdfFormat)
1877 m_printer->setPaperSize(pageSize,QPrinter::Millimeter);
1878 } else {
1879 if (page->getSetPageSizeToPrinter() || m_printer->outputFormat() == QPrinter::PdfFormat)
1880 m_printer->setPaperSize(static_cast<QPrinter::PageSize>(page->pageSize()));
1881 }
1882 }
1883 }
1884
x() const1885 qreal ItemGeometry::x() const
1886 {
1887 return m_x;
1888 }
1889
setX(const qreal & x)1890 void ItemGeometry::setX(const qreal &x)
1891 {
1892 m_x = x;
1893 }
1894
y() const1895 qreal ItemGeometry::y() const
1896 {
1897 return m_y;
1898 }
1899
setY(const qreal & y)1900 void ItemGeometry::setY(const qreal &y)
1901 {
1902 m_y = y;
1903 }
1904
width() const1905 qreal ItemGeometry::width() const
1906 {
1907 return m_width;
1908 }
1909
setWidth(const qreal & width)1910 void ItemGeometry::setWidth(const qreal &width)
1911 {
1912 m_width = width;
1913 }
1914
height() const1915 qreal ItemGeometry::height() const
1916 {
1917 return m_height;
1918 }
1919
setHeight(const qreal & height)1920 void ItemGeometry::setHeight(const qreal &height)
1921 {
1922 m_height = height;
1923 }
1924
type() const1925 ItemGeometry::Type ItemGeometry::type() const
1926 {
1927 return m_type;
1928 }
1929
setType(const Type & type)1930 void ItemGeometry::setType(const Type &type)
1931 {
1932 m_type = type;
1933 }
1934
anchor() const1935 Qt::Alignment ItemGeometry::anchor() const
1936 {
1937 return m_anchor;
1938 }
1939
setAnchor(const Qt::Alignment & anchor)1940 void ItemGeometry::setAnchor(const Qt::Alignment &anchor)
1941 {
1942 m_anchor = anchor;
1943 }
1944
text() const1945 QString WatermarkSetting::text() const
1946 {
1947 return m_text;
1948 }
1949
setText(const QString & text)1950 void WatermarkSetting::setText(const QString &text)
1951 {
1952 m_text = text;
1953 }
1954
font() const1955 QFont WatermarkSetting::font() const
1956 {
1957 return m_font;
1958 }
1959
setFont(const QFont & font)1960 void WatermarkSetting::setFont(const QFont &font)
1961 {
1962 m_font = font;
1963 }
1964
opacity() const1965 int WatermarkSetting::opacity() const
1966 {
1967 return m_opacity;
1968 }
1969
setOpacity(const int & opacity)1970 void WatermarkSetting::setOpacity(const int &opacity)
1971 {
1972 m_opacity = opacity;
1973 }
1974
geometry() const1975 ItemGeometry WatermarkSetting::geometry() const
1976 {
1977 return m_geometry;
1978 }
1979
setGeometry(const ItemGeometry & geometry)1980 void WatermarkSetting::setGeometry(const ItemGeometry &geometry)
1981 {
1982 m_geometry = geometry;
1983 }
1984
color() const1985 QColor WatermarkSetting::color() const
1986 {
1987 return m_color;
1988 }
1989
setColor(const QColor & color)1990 void WatermarkSetting::setColor(const QColor &color)
1991 {
1992 m_color = color;
1993 }
1994
sceneX()1995 qreal WatermarkHelper::sceneX()
1996 {
1997 return valueToPixels(m_watermark.geometry().x());
1998 }
1999
sceneY()2000 qreal WatermarkHelper::sceneY()
2001 {
2002 return valueToPixels(m_watermark.geometry().y());
2003 }
2004
sceneWidth()2005 qreal WatermarkHelper::sceneWidth()
2006 {
2007 return valueToPixels(m_watermark.geometry().width());
2008 }
2009
sceneHeight()2010 qreal WatermarkHelper::sceneHeight()
2011 {
2012 return valueToPixels(m_watermark.geometry().height());
2013 }
2014
scenePos()2015 QPointF WatermarkHelper::scenePos()
2016 {
2017 return (QPointF(sceneX(), sceneY()));
2018 }
2019
sceneSize()2020 QSizeF WatermarkHelper::sceneSize()
2021 {
2022 return (QSizeF(sceneWidth(), sceneHeight()));
2023 }
2024
mapToPage(const PageItemDesignIntf & page)2025 QPointF WatermarkHelper::mapToPage(const PageItemDesignIntf &page)
2026 {
2027 qreal startX = 0;
2028 qreal startY = 0;
2029
2030 if ( m_watermark.geometry().anchor() & Qt::AlignLeft){
2031 startX = 0;
2032 } else if ( m_watermark.geometry().anchor() & Qt::AlignRight){
2033 startX = page.geometry().width();
2034 } else {
2035 startX = page.geometry().width() / 2;
2036 }
2037
2038 if ( m_watermark.geometry().anchor() & Qt::AlignTop){
2039 startY = 0;
2040 } else if (m_watermark.geometry().anchor() & Qt::AlignBottom){
2041 startY = page.geometry().height();
2042 } else {
2043 startY = page.geometry().height() / 2;
2044 }
2045
2046 return QPointF(startX + sceneX(), startY + sceneY());
2047 }
2048
valueToPixels(qreal value)2049 qreal WatermarkHelper::valueToPixels(qreal value)
2050 {
2051 switch (m_watermark.geometry().type()) {
2052 case LimeReport::ItemGeometry::Millimeters:
2053 return value * Const::mmFACTOR;
2054 case LimeReport::ItemGeometry::Pixels:
2055 return value;
2056 }
2057 }
2058
2059
2060 }// namespace LimeReport
2061
2062