0
0
mirror of https://github.com/fralx/LimeReport.git synced 2024-12-24 00:33:02 +03:00
LimeReport/limereport/lrreportdesignwidget.cpp
Андрей Лухнов 0fca7169d3 Define code style and format all source file using clang-format-14
except those placed in 3rdparty directories.
2024-09-19 21:09:38 +03:00

1312 lines
42 KiB
C++

/***************************************************************************
* This file is part of the Lime Report project *
* Copyright (C) 2021 by Alexander Arin *
* arin_a@bk.ru *
* *
** GNU General Public License Usage **
* *
* This library is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
** GNU Lesser General Public License **
* *
* This library is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of the *
* License, or (at your option) any later version. *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library. *
* If not, see <http://www.gnu.org/licenses/>. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
****************************************************************************/
#include "lrreportdesignwidget.h"
#include "dialogdesigner/lrdialogdesigner.h"
#include "lrbasedesignintf.h"
#include "lrreportengine_p.h"
#include "lrsettingdialog.h"
#include "scripteditor/lrscripteditor.h"
#include "serializators/lrxmlreader.h"
#include "serializators/lrxmlwriter.h"
#include "translationeditor/translationeditor.h"
#include <QApplication>
#include <QDebug>
#include <QDockWidget>
#include <QFileDialog>
#include <QMessageBox>
#include <QObject>
#include <QTabWidget>
#include <QVBoxLayout>
#include <QtXml>
namespace LimeReport {
// ReportDesignIntf
ReportDesignWidget::ReportDesignWidget(ReportEnginePrivateInterface* report, QSettings* settings,
QMainWindow* mainWindow, QWidget* parent):
QWidget(parent),
#ifdef HAVE_QTDESIGNER_INTEGRATION
m_dialogDesignerManager(new DialogDesignerManager(this)),
#endif
m_mainWindow(mainWindow),
m_verticalGridStep(10),
m_horizontalGridStep(10),
m_useGrid(false),
m_dialogChanged(false),
m_theme("Default"),
m_settings(settings),
m_defaultUnits(BaseDesignIntf::Millimeters)
{
#if QT_VERSION < 0x050000
m_tabWidget = new LimeReportTabWidget(this);
#else
m_tabWidget = new QTabWidget(this);
#endif
m_tabWidget->setTabPosition(QTabWidget::South);
m_tabWidget->setMovable(true);
connect(m_tabWidget->tabBar(), SIGNAL(tabMoved(int, int)), this, SLOT(slotTabMoved(int, int)));
QVBoxLayout* mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(m_tabWidget);
setLayout(mainLayout);
m_report = report;
m_settings->beginGroup("DesignerWidget");
QVariant v = m_settings->value("DefaultUnits");
if (v.isValid()) {
m_defaultUnits = static_cast<BaseDesignIntf::UnitType>(v.toInt());
}
m_settings->endGroup();
if (!m_report->pageCount()) {
createStartPage();
}
createTabs();
connect(dynamic_cast<QObject*>(m_report), SIGNAL(pagesLoadFinished()), this,
SLOT(slotPagesLoadFinished()));
connect(dynamic_cast<QObject*>(m_report), SIGNAL(cleared()), this, SIGNAL(cleared()));
connect(dynamic_cast<QObject*>(m_report), SIGNAL(loadFinished()), this,
SLOT(slotReportLoaded()));
connect(m_tabWidget, SIGNAL(currentChanged(int)), this, SLOT(slotCurrentTabChanged(int)));
#ifdef HAVE_UI_LOADER
connect(m_report->scriptContext(), SIGNAL(dialogDeleted(QString)), this,
SLOT(slotDialogDeleted(QString)));
#endif
// m_instance=this;
m_scriptEditor->setPlainText(m_report->scriptContext()->initScript());
m_zoomer = new GraphicsViewZoomer(activeView());
#ifdef Q_OS_WIN
m_defaultFont = QFont("Arial", 10);
#endif
#ifdef HAVE_QTDESIGNER_INTEGRATION
connect(m_dialogDesignerManager, SIGNAL(dialogChanged(QString)), this,
SLOT(slotDialogChanged(QString)));
connect(m_dialogDesignerManager, SIGNAL(dialogNameChanged(QString, QString)), this,
SLOT(slotDialogNameChanged(QString, QString)));
#endif
m_themes.insert("Default", "");
m_localToEng.insert(QObject::tr("Dark"), "Dark");
m_localToEng.insert(QObject::tr("Light"), "Light");
initThemeIfExist("Dark", ":/qdarkstyle/style.qss");
initThemeIfExist("Light", ":/qlightstyle/lightstyle.qss");
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
DialogDesignerManager* ReportDesignWidget::dialogDesignerManager() const
{
return m_dialogDesignerManager;
}
QString ReportDesignWidget::activeDialogName()
{
if (activeDialogPage())
return activeDialogPage()->dialogName();
return "";
}
QWidget* ReportDesignWidget::toolWindow(ReportDesignWidget::ToolWindowType windowType)
{
switch (windowType) {
case WidgetBox:
return dialogDesignerManager()->widgetBox();
case PropertyEditor:
return dialogDesignerManager()->propertyEditor();
case ObjectInspector:
return dialogDesignerManager()->objectInspector();
case ActionEditor:
return dialogDesignerManager()->actionEditor();
case ResourceEditor:
return dialogDesignerManager()->resourcesEditor();
case SignalSlotEditor:
return dialogDesignerManager()->signalSlotEditor();
}
return NULL;
}
#endif
ReportDesignWidget::EditorTabType ReportDesignWidget::activeTabType()
{
QString tabType = m_tabWidget->tabWhatsThis(m_tabWidget->currentIndex());
if (tabType.compare("dialog") == 0)
return Dialog;
if (tabType.compare("script") == 0)
return Script;
if (tabType.compare("translations") == 0)
return Translations;
return Page;
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
void ReportDesignWidget::initDialogDesignerToolBar(QToolBar* toolBar)
{
m_dialogDesignerManager->initToolBar(toolBar);
}
void ReportDesignWidget::updateDialogs()
{
for (int i = 0; i < m_tabWidget->count(); ++i) {
if (m_tabWidget->tabWhatsThis(i).compare("dialog") == 0) {
m_report->scriptContext()->changeDialog(
m_tabWidget->tabText(i),
m_dialogDesignerManager->getDialogDescription(m_tabWidget->widget(i)));
}
}
}
#endif
bool ReportDesignWidget::useMagnet() const { return m_useMagnet; }
void ReportDesignWidget::setUseMagnet(bool useMagnet)
{
m_useMagnet = useMagnet;
for (int i = 0; i < m_report->pageCount(); ++i) {
m_report->pageAt(i)->setMagneticMovement(useMagnet);
}
}
void ReportDesignWidget::saveState()
{
m_settings->beginGroup("DesignerWidget");
m_settings->setValue("hGridStep", m_horizontalGridStep);
m_settings->setValue("vGridStep", m_verticalGridStep);
m_settings->setValue("defaultFont", m_defaultFont);
m_settings->setValue("useGrid", m_useGrid);
m_settings->setValue("theme", m_theme);
m_settings->setValue("ScriptEditorState", m_scriptEditor->saveState());
m_settings->setValue("DefaultUnits", m_defaultUnits);
m_settings->endGroup();
}
void ReportDesignWidget::applySettings()
{
for (int i = 0; i < m_report->pageCount(); ++i) {
m_report->pageAt(i)->pageItem()->setFont(m_defaultFont);
}
applyUseGrid();
if (m_themes.contains(m_theme)) {
parentWidget()->setStyleSheet(m_themes.value(m_theme));
m_report->setStyleSheet(m_themes.value(m_theme));
} else {
m_theme = "Default";
parentWidget()->setStyleSheet("");
m_report->setStyleSheet("");
}
// if (m_theme.compare("Dark") == 0) {
// QFile theme(":/qdarkstyle/style.qss");
// theme.open(QIODevice::ReadOnly);
// QString styleSheet = theme.readAll();
// parentWidget()->setStyleSheet(styleSheet);
// m_report->setStyleSheet(styleSheet);
// } else {
// parentWidget()->setStyleSheet("");
// m_report->setStyleSheet("");
// }
if (m_settings) {
m_settings->beginGroup("ScriptEditor");
QVariant v = m_settings->value("DefaultFontName");
if (v.isValid()) {
QVariant fontSize = m_settings->value("DefaultFontSize");
m_scriptEditor->setEditorFont(QFont(v.toString(), fontSize.toInt()));
}
v = m_settings->value("TabIndention");
if (v.isValid()) {
m_scriptEditor->setTabIndention(v.toInt());
}
m_settings->endGroup();
}
}
void ReportDesignWidget::loadState()
{
m_settings->beginGroup("DesignerWidget");
QVariant v = m_settings->value("hGridStep");
if (v.isValid()) {
m_horizontalGridStep = v.toInt();
}
v = m_settings->value("vGridStep");
if (v.isValid()) {
m_verticalGridStep = v.toInt();
}
v = m_settings->value("defaultFont");
if (v.isValid()) {
m_defaultFont = v.value<QFont>();
}
v = m_settings->value("useGrid");
if (v.isValid()) {
m_useGrid = v.toBool();
}
v = m_settings->value("theme");
if (v.isValid()) {
m_theme = v.toString();
}
v = m_settings->value("ScriptEditorState");
if (v.isValid() && m_scriptEditor) {
m_scriptEditor->restoreState(v.toByteArray());
}
v = m_settings->value("DefaultUnits");
if (v.isValid()) {
m_defaultUnits = static_cast<BaseDesignIntf::UnitType>(v.toInt());
}
m_settings->endGroup();
applySettings();
}
PageView* ReportDesignWidget::createPageView(PageDesignIntf* page)
{
PageView* view = new PageView(this);
view->setBackgroundBrush(QBrush(Qt::gray));
view->setFrameShape(QFrame::NoFrame);
view->setScene(page);
view->setPageItem(page->pageItem());
view->scale(0.5, 0.5);
view->centerOn(0, 0);
return view;
}
void ReportDesignWidget::createTabs()
{
m_tabWidget->clear();
int pageIndex = -1;
for (int i = 0; i < m_report->pageCount(); ++i) {
PageDesignIntf* page = m_report->pageAt(i);
page->clearSelection();
connectPage(page);
PageView* view = createPageView(page);
int pageIndex = m_tabWidget->addTab(view, QIcon(), page->pageItem()->objectName());
m_tabWidget->setTabWhatsThis(pageIndex, "page");
}
m_scriptEditor = new ScriptEditor(this);
connect(m_scriptEditor, SIGNAL(textChanged()), this, SLOT(slotScriptTextChanged()));
m_scriptEditor->setReportEngine(m_report);
pageIndex = m_tabWidget->addTab(m_scriptEditor, QIcon(), tr("Script"));
m_tabWidget->setTabWhatsThis(pageIndex, "script");
m_tabWidget->setCurrentIndex(0);
#ifdef HAVE_QTDESIGNER_INTEGRATION
QWidget* dialogDesigner;
foreach (DialogDescriber::Ptr dialogDesc, m_report->scriptContext()->dialogDescribers()) {
dialogDesigner = m_dialogDesignerManager->createFormEditor(dialogDesc->description());
pageIndex = m_tabWidget->addTab(dialogDesigner, QIcon(), dialogDesc->name());
m_tabWidget->setTabWhatsThis(pageIndex, "dialog");
}
#endif
m_traslationEditor = new TranslationEditor(this);
pageIndex = m_tabWidget->addTab(m_traslationEditor, QIcon(), tr("Translations"));
m_tabWidget->setTabWhatsThis(pageIndex, "translations");
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
void ReportDesignWidget::createNewDialogTab(const QString& dialogName,
const QByteArray& description)
{
QWidget* dialogDesigner = m_dialogDesignerManager->createFormEditor(description);
int pageIndex = m_tabWidget->addTab(dialogDesigner, QIcon(), dialogName);
m_tabWidget->setTabWhatsThis(pageIndex, "dialog");
m_tabWidget->setCurrentIndex(pageIndex);
m_dialogDesignerManager->setActiveEditor(dialogDesigner);
}
DialogDesigner* ReportDesignWidget::activeDialogPage()
{
return dynamic_cast<DialogDesigner*>(m_tabWidget->currentWidget());
}
#endif
ReportDesignWidget::~ReportDesignWidget() { delete m_zoomer; }
QGraphicsView* ReportDesignWidget::activeView()
{
return dynamic_cast<QGraphicsView*>(m_tabWidget->currentWidget());
}
void ReportDesignWidget::connectPage(PageDesignIntf* page)
{
connect(page, SIGNAL(itemInserted(LimeReport::PageDesignIntf*, QPointF, QString)), this,
SIGNAL(itemInserted(LimeReport::PageDesignIntf*, QPointF, QString)));
connect(page, SIGNAL(itemInsertCanceled(QString)), this, SIGNAL(itemInsertCanceled(QString)));
connect(page, SIGNAL(itemPropertyChanged(QString, QString, QVariant, QVariant)), this,
SIGNAL(itemPropertyChanged(QString, QString, QVariant, QVariant)));
connect(page, SIGNAL(itemPropertyObjectNameChanged(QString, QString)), this,
SLOT(slotItemPropertyObjectNameChanged(QString, QString)));
connect(page, SIGNAL(selectionChanged()), this, SLOT(slotSelectionChanged()));
connect(page, SIGNAL(insertModeStarted()), this, SIGNAL(insertModeStarted()));
connect(page, SIGNAL(commandHistoryChanged()), this, SIGNAL(commandHistoryChanged()));
connect(page, SIGNAL(sceneRectChanged(QRectF)), this, SLOT(slotSceneRectChanged(QRectF)));
connect(page, SIGNAL(itemAdded(LimeReport::PageDesignIntf*, LimeReport::BaseDesignIntf*)), this,
SIGNAL(itemAdded(LimeReport::PageDesignIntf*, LimeReport::BaseDesignIntf*)));
connect(page, SIGNAL(itemRemoved(LimeReport::PageDesignIntf*, LimeReport::BaseDesignIntf*)),
this, SIGNAL(itemDeleted(LimeReport::PageDesignIntf*, LimeReport::BaseDesignIntf*)));
connect(page, SIGNAL(bandAdded(LimeReport::PageDesignIntf*, LimeReport::BandDesignIntf*)), this,
SIGNAL(bandAdded(LimeReport::PageDesignIntf*, LimeReport::BandDesignIntf*)));
connect(page, SIGNAL(bandRemoved(LimeReport::PageDesignIntf*, LimeReport::BandDesignIntf*)),
this, SIGNAL(bandDeleted(LimeReport::PageDesignIntf*, LimeReport::BandDesignIntf*)));
connect(page, SIGNAL(pageUpdateFinished(LimeReport::PageDesignIntf*)), this,
SIGNAL(activePageUpdated(LimeReport::PageDesignIntf*)));
connect(page->pageItem(), SIGNAL(propertyObjectNameChanged(QString, QString)), this,
SLOT(slotPagePropertyObjectNameChanged(QString, QString)));
emit activePageChanged();
}
PageDesignIntf* ReportDesignWidget::createStartPage()
{
PageDesignIntf* page = m_report->appendPage("page1");
page->pageItem()->setUnitType(m_defaultUnits);
// createTabs();
return page;
}
void ReportDesignWidget::removeDatasource(const QString& datasourceName)
{
if (m_report->dataManager())
m_report->dataManager()->removeDatasource(datasourceName);
}
void ReportDesignWidget::addBand(const QString& bandType)
{
if (activePage())
activePage()->addBand(bandType);
}
void ReportDesignWidget::addBand(BandDesignIntf::BandsType bandType)
{
if (activePage())
activePage()->addBand(bandType);
}
void ReportDesignWidget::startInsertMode(const QString& itemType)
{
if (activePage())
activePage()->startInsertMode(itemType);
}
void ReportDesignWidget::startEditMode()
{
if (activePage())
activePage()->startEditMode();
}
PageDesignIntf* ReportDesignWidget::activePage()
{
if (activeView())
return dynamic_cast<PageDesignIntf*>(activeView()->scene());
return 0;
}
QList<QGraphicsItem*> ReportDesignWidget::selectedItems() { return activePage()->selectedItems(); }
void ReportDesignWidget::deleteItem(QGraphicsItem* item)
{
activePage()->removeReportItem(dynamic_cast<BaseDesignIntf*>(item));
}
void ReportDesignWidget::deleteSelectedItems() { activePage()->deleteSelected(); }
QStringList ReportDesignWidget::datasourcesNames()
{
return m_report->dataManager()->dataSourceNames();
}
void ReportDesignWidget::slotItemSelected(BaseDesignIntf* item) { emit itemSelected(item); }
bool ReportDesignWidget::saveToFile(const QString& fileName)
{
bool result = false;
prepareReport();
#ifdef HAVE_QTDESIGNER_INTEGRATION
updateDialogs();
#endif
if (m_report->saveToFile(fileName)) {
m_report->emitSaveFinished();
result = true;
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
if (result) {
m_dialogChanged = false;
m_dialogDesignerManager->setDirty(false);
}
#endif
return result;
}
bool ReportDesignWidget::save()
{
prepareReport();
#ifdef HAVE_QTDESIGNER_INTEGRATION
updateDialogs();
#endif
bool result = false;
if (emitSaveReport()) {
result = true;
} else if (!m_report->reportFileName().isEmpty()) {
if (m_report->saveToFile()) {
m_report->emitSaveFinished();
result = true;
}
} else {
if (m_report->isSaved()) {
m_report->emitSaveFinished();
result = true;
} else if (m_report->saveToFile(QFileDialog::getSaveFileName(
this, tr("Report file name"), m_report->currentReportsDir(),
"Report files (*.lrxml);; All files (*)"))) {
m_report->emitSaveFinished();
result = true;
};
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
if (result) {
m_dialogChanged = false;
m_dialogDesignerManager->setDirty(false);
}
#endif
return result;
}
bool ReportDesignWidget::loadFromFile(const QString& fileName)
{
if (m_report->loadFromFile(fileName, false)) {
// QByteArray editorState = m_scriptEditor->saveState();
// createTabs();
// m_scriptEditor->setPlainText(m_report->scriptContext()->initScript());
// m_scriptEditor->restoreState(editorState);
// emit loaded();
// m_dialogChanged = false;
return true;
} else {
QMessageBox::critical(this, tr("Error"), tr("Wrong file format"));
return false;
}
}
void ReportDesignWidget::scale(qreal sx, qreal sy)
{
// m_view->scale(sx,sy);
if (activeView())
activeView()->scale(sx, sy);
}
QString ReportDesignWidget::reportFileName()
{
if (m_report)
return m_report->reportFileName();
return QString();
}
bool ReportDesignWidget::isNeedToSave()
{
if (m_report)
return (m_report->isNeedToSave() || m_dialogChanged);
return false;
}
bool ReportDesignWidget::emitSaveReport() { return m_report->emitSaveReport(); }
bool ReportDesignWidget::emitSaveReportAs() { return m_report->emitSaveReportAs(); }
bool ReportDesignWidget::emitLoadReport() { return m_report->emitLoadReport(); }
void ReportDesignWidget::updateSize()
{
if (activePage())
activePage()->slotUpdateItemSize();
}
void ReportDesignWidget::undo()
{
if (activePage())
activePage()->undo();
#ifdef HAVE_QTDESIGNER_INTEGRATION
if (activeDialogPage())
activeDialogPage()->undo();
#endif
}
void ReportDesignWidget::redo()
{
if (activePage())
activePage()->redo();
#ifdef HAVE_QTDESIGNER_INTEGRATION
if (activeDialogPage())
activeDialogPage()->redo();
#endif
}
void ReportDesignWidget::copy()
{
if (activePage())
activePage()->copy();
}
void ReportDesignWidget::paste()
{
if (activePage())
activePage()->paste();
}
void ReportDesignWidget::cut()
{
if (activePage())
activePage()->cut();
}
void ReportDesignWidget::bringToFront()
{
if (activePage())
activePage()->bringToFront();
}
void ReportDesignWidget::sendToBack()
{
if (activePage())
activePage()->sendToBack();
}
void ReportDesignWidget::alignToLeft()
{
if (activePage())
activePage()->alignToLeft();
}
void ReportDesignWidget::alignToRight()
{
if (activePage())
activePage()->alignToRigth();
}
void ReportDesignWidget::alignToVCenter()
{
if (activePage())
activePage()->alignToVCenter();
}
void ReportDesignWidget::alignToTop()
{
if (activePage())
activePage()->alignToTop();
}
void ReportDesignWidget::alignToBottom()
{
if (activePage())
activePage()->alignToBottom();
}
void ReportDesignWidget::alignToHCenter()
{
if (activePage())
activePage()->alignToHCenter();
}
void ReportDesignWidget::sameHeight()
{
if (activePage())
activePage()->sameHeight();
}
void ReportDesignWidget::sameWidth()
{
if (activePage())
activePage()->sameWidth();
}
void ReportDesignWidget::editLayoutMode(bool value)
{
if (value) {
activePage()->pageItem()->setItemMode(activePage()->pageItem()->itemMode()
| LayoutEditMode);
} else if (activePage()->pageItem()->itemMode() & LayoutEditMode) {
activePage()->pageItem()->setItemMode(activePage()->pageItem()->itemMode()
^ LayoutEditMode);
}
}
void ReportDesignWidget::addHLayout()
{
if (activePage())
activePage()->addHLayout();
}
void ReportDesignWidget::addVLayout()
{
if (activePage())
activePage()->addVLayout();
}
void ReportDesignWidget::setFont(const QFont& font)
{
if (activePage())
activePage()->setFont(font);
}
void ReportDesignWidget::setTextAlign(const bool& horizontalAlign,
const Qt::AlignmentFlag& alignment)
{
if (activePage())
activePage()->changeSelectedGrpoupTextAlignPropperty(horizontalAlign, alignment);
}
void ReportDesignWidget::setBorders(const BaseDesignIntf::BorderLines& borders)
{
if (activePage())
activePage()->setBorders(borders);
}
void ReportDesignWidget::setBordersExt(const BaseDesignIntf::BorderLines& border,
const double borderWidth,
const LimeReport::BaseDesignIntf::BorderStyle style,
const QString color)
{
if (activePage())
activePage()->setBordersExt(border, borderWidth, style, color);
}
void ReportDesignWidget::prepareReport()
{
m_report->scriptContext()->setInitScript(m_scriptEditor->toPlainText());
report()->clearSelection();
}
void ReportDesignWidget::initThemeIfExist(const QString& themeName, const QString& path)
{
QFile theme(path);
if (theme.exists()) {
theme.open(QIODevice::ReadOnly);
QString styleSheet = theme.readAll();
m_themes.insert(themeName, styleSheet);
}
}
void ReportDesignWidget::previewReport()
{
if (report()->isBusy())
return;
prepareReport();
#ifdef HAVE_QTDESIGNER_INTEGRATION
updateDialogs();
#endif
bool showProgressDialog = report()->isShowProgressDialog();
report()->setShowProgressDialog(false);
report()->previewReport();
report()->setShowProgressDialog(showProgressDialog);
}
void ReportDesignWidget::printReport()
{
if (report()->isBusy())
return;
prepareReport();
#ifdef HAVE_QTDESIGNER_INTEGRATION
updateDialogs();
#endif
setCursor(Qt::WaitCursor);
report()->printReport();
setCursor(Qt::ArrowCursor);
}
void ReportDesignWidget::addPage()
{
PageDesignIntf* page
= m_report->appendPage("page" + QString::number(m_report->pageCount() + 1));
connectPage(page);
PageView* view = createPageView(page);
int index = m_report->pageCount() - 1;
m_tabWidget->insertTab(index, view, QIcon(), page->pageItem()->objectName());
m_tabWidget->setTabWhatsThis(index, "page");
m_tabWidget->setCurrentIndex(index);
applyUseGrid();
emit pageAdded(page);
}
void ReportDesignWidget::deleteCurrentPage()
{
if (m_report->pageCount() > 1) {
QGraphicsView* view = dynamic_cast<QGraphicsView*>(m_tabWidget->currentWidget());
if (view) {
PageDesignIntf* page = dynamic_cast<PageDesignIntf*>(view->scene());
if (page) {
if (m_report->deletePage(page)) {
int index = m_tabWidget->currentIndex();
m_tabWidget->removeTab(m_tabWidget->currentIndex());
if (index > 0)
m_tabWidget->setCurrentIndex(index - 1);
emit pageDeleted();
}
}
}
}
}
void ReportDesignWidget::editSetting()
{
SettingDialog setting(this);
setting.setSettings(m_settings);
setting.setVerticalGridStep(m_verticalGridStep);
setting.setHorizontalGridStep(m_horizontalGridStep);
setting.setDefaultFont(m_defaultFont);
setting.setSuppressAbsentFieldsAndVarsWarnings(m_report->suppressFieldAndVarError());
setting.setBaseItemPadding(m_report->baseItemPadding());
QStringList themes;
themes.append(QObject::tr("Default"));
foreach (QString theme, m_themes.keys())
if (!themes.contains(QObject::tr(theme.toLatin1())))
themes.append(QObject::tr(theme.toLatin1()));
setting.setDesignerThemes(themes, QObject::tr(m_theme.toLatin1()));
setting.setDesignerLanguages(m_report->designerLanguages(),
m_report->currentDesignerLanguage());
QList<QString> unitTypes;
unitTypes << QObject::tr("Millimeters") << QObject::tr("Inches");
setting.setDesignerUnites(unitTypes,
m_defaultUnits == BaseDesignIntf::Millimeters
? QObject::tr("Millimeters")
: QObject::tr("Inches"));
if (setting.exec()) {
m_horizontalGridStep = setting.horizontalGridStep();
m_verticalGridStep = setting.verticalGridStep();
m_defaultFont = setting.defaultFont();
if (setting.reportUnits().compare(QObject::tr("Millimeters")) == 0)
m_defaultUnits = BaseDesignIntf::Millimeters;
else {
m_defaultUnits = BaseDesignIntf::Inches;
}
if (m_localToEng.contains(setting.theme())) {
m_theme = m_localToEng.value(setting.theme());
} else {
m_theme = "Default";
}
m_report->setSuppressFieldAndVarError(setting.suppressAbsentFieldsAndVarsWarnings());
m_report->setBaseItemPadding(setting.baseItemPadding());
if (m_report->currentDesignerLanguage() != setting.designerLanguage()) {
m_report->setCurrentDesignerLanguage(setting.designerLanguage());
}
applySettings();
}
}
void ReportDesignWidget::applyUseGrid()
{
int hGridStep = m_useGrid ? m_horizontalGridStep : Const::DEFAULT_GRID_STEP;
int vGridStep = m_useGrid ? m_verticalGridStep : Const::DEFAULT_GRID_STEP;
for (int i = 0; i < m_report->pageCount(); ++i) {
m_report->pageAt(i)->setVerticalGridStep(hGridStep);
m_report->pageAt(i)->setHorizontalGridStep(vGridStep);
}
}
void ReportDesignWidget::setUseGrid(bool value)
{
m_useGrid = value;
applyUseGrid();
}
bool ReportDesignWidget::isCanUndo()
{
if (activePage())
return activePage()->isCanUndo();
return false;
}
bool ReportDesignWidget::isCanRedo()
{
if (activePage())
return activePage()->isCanRedo();
return false;
}
void ReportDesignWidget::slotSelectionChanged()
{
QGraphicsScene* page = dynamic_cast<QGraphicsScene*>(sender());
if (page) {
if (page->selectedItems().count() == 1) {
BaseDesignIntf* item = dynamic_cast<BaseDesignIntf*>(page->selectedItems().at(0));
if (item)
emit(itemSelected(item));
} else if (page->selectedItems().count() > 1) {
emit(multiItemSelected());
}
}
}
DataSourceManager* ReportDesignWidget::dataManager() { return m_report->dataManager(); }
ScriptEngineManager* ReportDesignWidget::scriptManager() { return m_report->scriptManager(); }
ScriptEngineContext* ReportDesignWidget::scriptContext() { return m_report->scriptContext(); }
void ReportDesignWidget::slotPagesLoadFinished()
{
applySettings();
// setActivePage(m_report->pageAt(0));
emit loadFinished();
}
void ReportDesignWidget::slotDialogDeleted(QString dialogName)
{
for (int i = 0; i < m_tabWidget->count(); ++i) {
if (m_tabWidget->tabText(i).compare(dialogName) == 0) {
delete m_tabWidget->widget(i);
break;
}
}
}
void ReportDesignWidget::lockSelectedItems()
{
if (activePage())
activePage()->lockSelectedItems();
}
void ReportDesignWidget::unlockSelectedItems()
{
if (activePage())
activePage()->unlockSelectedItems();
}
void ReportDesignWidget::selectOneLevelItems()
{
if (activePage())
activePage()->selectOneLevelItems();
}
void ReportDesignWidget::slotDatasourceCollectionLoaded(const QString& /*collectionName*/) { }
void ReportDesignWidget::slotSceneRectChanged(QRectF)
{
if (activeView())
activeView()->centerOn(0, 0);
}
void ReportDesignWidget::slotCurrentTabChanged(int index)
{
QGraphicsView* view = dynamic_cast<QGraphicsView*>(m_tabWidget->widget(index));
if (view) {
if (view->scene()) {
// foreach (QGraphicsItem* item, view->scene()->selectedItems())
// item->setSelected(false);
view->scene()->clearSelection();
}
m_zoomer->setView(view);
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
if (activeTabType() == Dialog) {
m_dialogDesignerManager->setActiveEditor(m_tabWidget->widget(index));
}
updateDialogs();
#endif
if (activeTabType() == Translations) {
m_traslationEditor->setReportEngine(dynamic_cast<ITranslationContainer*>(report()));
}
if (activeTabType() == Script) {
m_scriptEditor->initCompleter();
m_scriptEditor->setFocus();
}
emit activePageChanged();
if (view)
view->centerOn(0, 0);
}
void ReportDesignWidget::slotReportLoaded()
{
QByteArray editorState = m_scriptEditor->saveState();
createTabs();
m_scriptEditor->setPlainText(m_report->scriptContext()->initScript());
m_scriptEditor->restoreState(editorState);
emit loadFinished();
m_dialogChanged = false;
}
void ReportDesignWidget::slotScriptTextChanged()
{
m_report->scriptContext()->setInitScript(m_scriptEditor->toPlainText());
}
void ReportDesignWidget::slotItemPropertyObjectNameChanged(const QString& oldName,
const QString& newName)
{
PageDesignIntf* page = qobject_cast<PageDesignIntf*>(sender());
if (page) {
ITranslationContainer* tc = dynamic_cast<ITranslationContainer*>(report());
for (int i = 0; i < tc->translations()->values().count(); ++i) {
PageTranslation* pt = tc->translations()->values().at(i)->findPageTranslation(
page->pageItem()->objectName());
if (pt)
pt->renameItem(oldName, newName);
}
}
}
#ifdef HAVE_QTDESIGNER_INTEGRATION
void ReportDesignWidget::addNewDialog()
{
QFile templateUi(":/templates/templates/Dialog.ui");
templateUi.open(QIODevice::ReadOnly | QIODevice::Text);
QString templateStr = templateUi.readAll();
QString dialogName = m_report->scriptContext()->getNewDialogName();
templateStr.replace("$ClassName$", dialogName);
m_report->scriptContext()->addDialog(dialogName, templateStr.toUtf8());
createNewDialogTab(dialogName, templateStr.toUtf8());
}
void ReportDesignWidget::slotDialogChanged(QString) { m_dialogChanged = true; }
void ReportDesignWidget::slotDialogNameChanged(QString oldName, QString newName)
{
for (int i = 0; i < m_tabWidget->count(); ++i) {
if (m_tabWidget->tabText(i).compare(oldName) == 0)
m_tabWidget->setTabText(i, newName);
}
m_report->scriptContext()->changeDialogName(oldName, newName);
}
#endif
void ReportDesignWidget::slotPagePropertyObjectNameChanged(const QString& oldValue,
const QString& newValue)
{
ITranslationContainer* tc = dynamic_cast<ITranslationContainer*>(report());
foreach (ReportTranslation* translation, tc->translations()->values()) {
translation->renamePage(oldValue, newValue);
}
for (int i = 0; i < m_tabWidget->count(); ++i) {
if (m_tabWidget->tabText(i).compare(oldValue) == 0) {
QGraphicsView* view = dynamic_cast<QGraphicsView*>(m_tabWidget->widget(i));
if (view) {
PageDesignIntf* page = dynamic_cast<PageDesignIntf*>(view->scene());
if (page->pageItem() == sender())
m_tabWidget->setTabText(i, newValue);
}
}
}
}
void ReportDesignWidget::slotTabMoved(int from, int to)
{
Q_UNUSED(from)
Q_UNUSED(to)
QList<PageDesignIntf*> pages;
for (int i = 0; i < m_tabWidget->tabBar()->count(); ++i) {
QGraphicsView* view = dynamic_cast<QGraphicsView*>(m_tabWidget->widget(i));
if (view) {
PageDesignIntf* page = dynamic_cast<PageDesignIntf*>(view->scene());
if (page) {
pages.append(page);
}
}
}
m_report->reorderPages(pages);
}
bool ReportDesignWidget::eventFilter(QObject* target, QEvent* event)
{
if (event->type() == QEvent::Wheel) {
QWheelEvent* we = dynamic_cast<QWheelEvent*>(event);
if (QApplication::keyboardModifiers() == Qt::ControlModifier) {
#if QT_VERSION < QT_VERSION_CHECK(5, 12, 3)
if (we->delta() < 0)
scale(1.2, 1.2);
else
scale(1 / 1.2, 1 / 1.2);
#else
if (we->pixelDelta().x() < 0)
scale(1.2, 1.2);
else
scale(1 / 1.2, 1 / 1.2);
#endif
}
}
return QWidget::eventFilter(target, event);
}
void ReportDesignWidget::clear()
{
m_report->clearReport();
m_tabWidget->clear();
m_report->setReportFileName("");
m_report->scriptContext()->setInitScript("");
m_scriptEditor->setPlainText("");
}
void PageView::setPageItem(PageItemDesignIntf* pageItem)
{
if (!pageItem)
return;
m_pageItem = pageItem;
if (!m_horizontalRuller) {
m_horizontalRuller = new Ruler(Ruler::Horizontal, this);
m_horizontalRuller->setPage(pageItem);
}
if (!m_verticalRuller) {
m_verticalRuller = new Ruler(Ruler::Vertical, this);
m_verticalRuller->setPage(pageItem);
}
}
bool PageView::viewportEvent(QEvent* event)
{
switch (event->type()) {
case QEvent::MouseMove:
if (m_horizontalRuller && m_verticalRuller) {
m_horizontalRuller->setMousePos(dynamic_cast<QMouseEvent*>(event)->pos());
m_verticalRuller->setMousePos(dynamic_cast<QMouseEvent*>(event)->pos());
m_horizontalRuller->update();
m_verticalRuller->update();
}
break;
// case QEvent::Resize:
case QEvent::Paint:
if (m_horizontalRuller && m_verticalRuller) {
int x
= mapFromScene(m_pageItem->boundingRect().x(), m_pageItem->boundingRect().y()).x();
int y
= mapFromScene(m_pageItem->boundingRect().x(), m_pageItem->boundingRect().y()).y();
int width = mapFromScene(m_pageItem->boundingRect().bottomRight().x(),
m_pageItem->boundingRect().bottomRight().y())
.x();
int height = mapFromScene(m_pageItem->boundingRect().bottomRight().x(),
m_pageItem->boundingRect().bottomRight().y())
.y();
x = x < 0 ? 0 : x;
y = y < 0 ? 0 : y;
m_horizontalRuller->setGeometry(x + 20, 0, (width - x), 20);
m_verticalRuller->setGeometry(0, y + 20, 20, (height - y));
m_verticalRuller->update();
m_horizontalRuller->update();
}
break;
default:
break;
}
return QGraphicsView::viewportEvent(event);
}
void Ruler::setPage(PageItemDesignIntf* page) { m_page = page; }
void Ruler::paintEvent(QPaintEvent* event)
{
QPainter painter(this);
painter.setBrush(palette().window());
painter.setPen(Qt::NoPen);
painter.drawRect(event->rect());
// painter.setPen(palette().windowText().color());
if (m_page) {
qreal rulerWidth = m_page->geometry().width() / m_page->unitFactor();
qreal rulerHeight = m_page->geometry().height() / m_page->unitFactor();
QGraphicsView* view = qobject_cast<QGraphicsView*>(parent());
int hStartPos = view->mapFromScene(0, 0).x();
int vStartPos = view->mapFromScene(0, 0).y();
QFont font = painter.font();
font.setPointSize(7);
painter.setFont(font);
switch (m_type) {
case Horizontal:
painter.setPen(Qt::NoPen);
if (isColorDark(palette().window().color()))
painter.setBrush(QColor("#64893d"));
else
painter.setBrush(QColor("#b5da91"));
drawItemWithChildren(&painter, m_page);
painter.setPen(palette().windowText().color());
for (int i = 0; i < rulerWidth / 10; ++i) {
int hs10 = view->mapFromScene(QPointF(m_page->geometry().topLeft().x()
+ i * 10 * m_page->unitFactor(),
0))
.x();
int hs5 = view->mapFromScene(QPointF(m_page->geometry().topLeft().x()
+ i * 10 * m_page->unitFactor()
+ 5 * m_page->unitFactor(),
0))
.x();
if (hs10 > 0) {
if (hStartPos > 0) {
hs10 -= hStartPos;
hs5 -= hStartPos;
}
painter.drawLine(hs10, 15, hs10, 20);
painter.drawLine(hs5, 10, hs5, 20);
if (i > 0)
painter.drawText(QPoint(hs10
- (painter.fontMetrics()
.boundingRect(QString::number(i))
.width()
/ 2),
12),
QString::number(i));
}
}
painter.setPen(palette().windowText().color());
painter.drawLine(m_mousePos.x() - (hStartPos > 0 ? hStartPos : 0), 0,
m_mousePos.x() - (hStartPos > 0 ? hStartPos : 0), 20);
break;
case Vertical:
painter.setPen(Qt::NoPen);
if (isColorDark(palette().window().color()))
painter.setBrush(QColor("#64893d"));
else
painter.setBrush(QColor("#b5da91"));
drawItemWithChildren(&painter, m_page);
painter.setPen(palette().windowText().color());
for (int i = 0; i < rulerHeight / 10; ++i) {
int vs10 = view->mapFromScene(QPointF(0,
m_page->geometry().topLeft().y()
+ i * 10 * m_page->unitFactor()))
.y();
int vs5 = view->mapFromScene(QPointF(0,
m_page->geometry().topLeft().y()
+ i * 10 * m_page->unitFactor()
+ 5 * m_page->unitFactor()))
.y();
if (vs10 > 0) {
if (vStartPos > 0) {
vs10 -= vStartPos;
vs5 -= vStartPos;
}
painter.drawLine(15, vs10, 20, vs10);
if (i > 0)
painter.drawText(
QPoint(
(15
- painter.fontMetrics().boundingRect(QString::number(i)).width())
/ 2,
vs10 + (painter.fontMetrics().height() / 2)),
QString::number(i));
painter.drawLine(10, vs5, 20, vs5);
}
}
painter.setPen(palette().windowText().color());
painter.drawLine(0, m_mousePos.y() - (vStartPos > 0 ? vStartPos : 0), 20,
m_mousePos.y() - (vStartPos > 0 ? vStartPos : 0));
break;
}
}
}
void Ruler::drawItemWithChildren(QPainter* painter, BaseDesignIntf* item)
{
foreach (BaseDesignIntf* child, item->childBaseItems()) {
if (!child->childBaseItems().isEmpty())
drawItemWithChildren(painter, child);
else
drawItem(painter, child);
}
drawItem(painter, item);
}
void Ruler::drawItem(QPainter* painter, BaseDesignIntf* item)
{
if (!item->isSelected())
return;
QGraphicsView* view = qobject_cast<QGraphicsView*>(parent());
int hStartPos = view->mapFromScene(0, 0).x();
int vStartPos = view->mapFromScene(0, 0).y();
int itemWidth
= view->mapFromScene(
item->mapToScene(item->geometry().width(), 0).x() - item->mapToScene(0, 0).x(), 0)
.x()
- hStartPos;
int itemHeight = view->mapFromScene(0,
item->mapToScene(0, item->geometry().height()).y()
- item->mapToScene(0, 0).y())
.y()
- vStartPos;
switch (m_type) {
case Horizontal:
if (item->isSelected())
painter->drawRect(view->mapFromScene(item->mapToScene(0, 0)).x()
- (hStartPos > 0 ? hStartPos : 0),
0, itemWidth, 20);
break;
case Vertical:
if (item->isSelected())
painter->drawRect(
0, view->mapFromScene(item->mapToScene(0, 0)).y() - (vStartPos > 0 ? vStartPos : 0),
20, itemHeight);
break;
}
}
} // namespace LimeReport