mirrors/LimeReport
0
0
Fork 0
mirror of https://github.com/fralx/LimeReport.git synced 2025-04-01 15:13:43 +03:00
Code

Merge pull request #1 from fralx/master

Browse Source 
sync
This commit is contained in:
Hatem Abu Setta 2020-02-27 02:09:48 +02:00 committed by GitHub
commit dafc7050c8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
44 changed files with 1159 additions and 696 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
.travis.yml
View File

@ -498,7 +498,7 @@ matrix:
- make
- make check
- env: Qt5.12.3_Ubuntu_18.04
- env: Qt5.12.6_Ubuntu_18.04
os: linux
dist: bionic
language: cpp
@ -507,7 +507,7 @@ matrix:
addons:
apt:
sources:
- sourceline: 'ppa:beineri/opt-qt-5.12.3-bionic'
- sourceline: 'ppa:beineri/opt-qt-5.12.6-bionic'
packages:
- qt512base
- qt512script
@ -521,7 +521,7 @@ matrix:
- make
- make check
- env: Qt5.12.3_Ubuntu_18.04
- env: Qt5.12.6_Ubuntu_18.04
os: linux
dist: bionic
language: cpp
@ -530,7 +530,7 @@ matrix:
addons:
apt:
sources:
- sourceline: 'ppa:beineri/opt-qt-5.12.3-bionic'
- sourceline: 'ppa:beineri/opt-qt-5.12.6-bionic'
packages:
- qt512base
- qt512script
@ -542,7 +542,99 @@ matrix:
- source /opt/qt512/bin/qt512-env.sh
- /opt/qt512/bin/qmake -r limereport.pro
- make
- make check
- make check
- env: Qt5.13.2_Ubuntu_18.04
os: linux
dist: bionic
language: cpp
compiler: gcc
cache: ccache
addons:
apt:
sources:
- sourceline: 'ppa:beineri/opt-qt-5.13.2-bionic'
packages:
- qt513base
- qt513script
- qt513tools
- mesa-common-dev
- libgl1-mesa-dev
script:
- source /opt/qt513/bin/qt513-env.sh
- /opt/qt513/bin/qmake -r limereport.pro
- make
- make check
- env: Qt5.13.2_Ubuntu_18.04
os: linux
dist: bionic
language: cpp
compiler: clang
cache: ccache
addons:
apt:
sources:
- sourceline: 'ppa:beineri/opt-qt-5.13.2-bionic'
packages:
- qt513base
- qt513script
- qt513tools
- mesa-common-dev
- libgl1-mesa-dev
script:
- source /opt/qt513/bin/qt513-env.sh
- /opt/qt513/bin/qmake -r limereport.pro
- make
- make check
- env: Qt5.14.0_Ubuntu_18.04
os: linux
dist: bionic
language: cpp
compiler: gcc
cache: ccache
addons:
apt:
sources:
- sourceline: 'ppa:beineri/opt-qt-5.14.0-bionic'
packages:
- qt514base
- qt514script
- qt514tools
- mesa-common-dev
- libgl1-mesa-dev
script:
- source /opt/qt514/bin/qt514-env.sh
- /opt/qt514/bin/qmake -r limereport.pro
- make
- make check
- env: Qt5.14.0_Ubuntu_18.04
os: linux
dist: bionic
language: cpp
compiler: clang
cache: ccache
addons:
apt:
sources:
- sourceline: 'ppa:beineri/opt-qt-5.14.0-bionic'
packages:
- qt514base
- qt514script
- qt514tools
- mesa-common-dev
- libgl1-mesa-dev
script:
- source /opt/qt514/bin/qt514-env.sh
- /opt/qt514/bin/qmake -r limereport.pro
- make
- make check
notifications:
email: false

2
README.md
View File

@ -1,5 +1,5 @@
# LimeReport v1.5.16 [![Build Status](https://api.travis-ci.org/fralx/LimeReport.svg?branch=master)](https://travis-ci.org/fralx/LimeReport) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/bc31412ea4814f30825b5ed3723e9a70)](https://app.codacy.com/app/fralx/LimeReport?utm_source=github.com&utm_medium=referral&utm_content=fralx/LimeReport&utm_campaign=Badge_Grade_Dashboard)
# LimeReport v1.5.35 [![Build Status](https://api.travis-ci.org/fralx/LimeReport.svg?branch=master)](https://travis-ci.org/fralx/LimeReport) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/bc31412ea4814f30825b5ed3723e9a70)](https://app.codacy.com/app/fralx/LimeReport?utm_source=github.com&utm_medium=referral&utm_content=fralx/LimeReport&utm_campaign=Badge_Grade_Dashboard)
## Official LimeReport web site [http://limereport.ru](http://limereport.ru)

2
common.pri
View File

@ -127,7 +127,7 @@ RCC_DIR = $${ARCH_DIR}/$${BUILD_TYPE}/rcc
LIMEREPORT_VERSION_MAJOR = 1
LIMEREPORT_VERSION_MINOR = 5
LIMEREPORT_VERSION_RELEASE = 22
LIMEREPORT_VERSION_RELEASE = 38
LIMEREPORT_VERSION = '$${LIMEREPORT_VERSION_MAJOR}.$${LIMEREPORT_VERSION_MINOR}.$${LIMEREPORT_VERSION_RELEASE}'
DEFINES *= LIMEREPORT_VERSION_STR=\\\"$${LIMEREPORT_VERSION}\\\"

1
designer/main.cpp
View File

@ -47,6 +47,7 @@ int main(int argc, char *argv[])
QObject::connect(&report, SIGNAL(currentDefaultDesignerLanguageChanged(QLocale::Language)),
&manager, SLOT(currentDefaultLanguageChanged(QLocale::Language)));
report.setShowDesignerModal(false);
report.designReport();
return a.exec();
}

4
include/lrreportengine.h
View File

@ -208,6 +208,9 @@ public:
bool showPreparedPages(PreviewHints hints = PreviewBarsUserSetting);
bool prepareReportPages();
bool printPreparedPages();
bool showDesignerModal() const;
void setShowDesignerModal(bool showDesignerModal);
signals:
void cleared();
void renderStarted();
@ -241,6 +244,7 @@ protected:
private:
Q_DECLARE_PRIVATE(ReportEngine)
static QSettings* m_settings;
bool m_showDesignerModal;
};
} // namespace LimeReport

6
limereport/base/lrattribsabstractfactory.h
View File

@ -54,11 +54,11 @@ private:
friend class Singleton< AttribsAbstractFactory< AbstractProduct,IdentifierType,ProductCreator,Attribs > >;
public:
bool registerCreator(const IdentifierType& id, Attribs attribs, ProductCreator creator){
return (m_factoryMap.insert(id,creator).value()==creator)&&
(m_attribsMap.insert(id,attribs).value()==attribs);
return (m_factoryMap.insert(id,creator).value() == creator) &&
(m_attribsMap.insert(id,attribs).value() == attribs);
}
bool unregisterCreator(const IdentifierType& id){
return (m_factoryMap.remove(id)==1)&&(m_attribsMap.remove(id)==1);
return (m_factoryMap.remove(id) == 1) && (m_attribsMap.remove(id) == 1);
}
ProductCreator objectCreator(const IdentifierType& id){
if (m_factoryMap.contains(id)){

3
limereport/databrowser/lrdatabrowser.cpp
View File

@ -723,7 +723,8 @@ void DataBrowser::addDatasource(SQLEditResult result)
void DataBrowser::activateItem(const QString& name, DataBrowserTree::NodeType type){
QTreeWidgetItem* item = findByNameAndType(name, type);
item->treeWidget()->setCurrentItem(item);
if (item)
item->treeWidget()->setCurrentItem(item);
}
void DataBrowser::addConnectionDesc(ConnectionDesc *connection)

2
limereport/designer.pri
View File

@ -28,6 +28,7 @@ SOURCES += \
$$REPORT_PATH/objectinspector/propertyItems/lrgroupfieldpropitem.cpp \
$$REPORT_PATH/objectinspector/propertyItems/lrcontentpropitem.cpp \
$$REPORT_PATH/objectinspector/propertyItems/lrmarginpropitem.cpp \
$$REPORT_PATH/objectinspector/propertyItems/lrseriespropitem.cpp \
$$REPORT_PATH/objectinspector/editors/lrtextitempropertyeditor.cpp \
$$REPORT_PATH/objectinspector/editors/lrcomboboxeditor.cpp \
$$REPORT_PATH/objectinspector/editors/lrcheckboxeditor.cpp \
@ -71,6 +72,7 @@ HEADERS += \
$$REPORT_PATH/objectinspector/propertyItems/lrqrealpropitem.h \
$$REPORT_PATH/objectinspector/propertyItems/lrcolorpropitem.h \
$$REPORT_PATH/objectinspector/propertyItems/lrmarginpropitem.h \
$$REPORT_PATH/objectinspector/propertyItems/lrseriespropitem.h \
$$REPORT_PATH/objectinspector/editors/lrtextitempropertyeditor.h \
$$REPORT_PATH/objectinspector/editors/lrcomboboxeditor.h \
$$REPORT_PATH/objectinspector/editors/lrcheckboxeditor.h \

64
limereport/items/charts/lrhorizontalbarchart.cpp Normal file
View File

@ -0,0 +1,64 @@
#include "lrhorizontalbarchart.h"
namespace LimeReport{
void HorizontalBarChart::paintChart(QPainter *painter, QRectF chartRect)
{
QRectF calcRect = verticalLabelsRect(painter, chartRect.adjusted(
hPadding(chartRect),
vPadding(chartRect) * 2,
-(chartRect.width() * 0.9),
-(vPadding(chartRect) * 2 + valuesVMargin(painter))
));
qreal barsShift = calcRect.width();
paintHorizontalGrid(painter, chartRect.adjusted(
hPadding(chartRect) + barsShift,
vPadding(chartRect),
-(hPadding(chartRect)),-vPadding(chartRect)));
paintHorizontalBars(painter, chartRect.adjusted(
hPadding(chartRect) + barsShift,
vPadding(chartRect) * 2,
-(hPadding(chartRect)),
-(vPadding(chartRect) * 2) ));
paintVerticalLabels(painter, calcRect);
}
void HorizontalBarChart::paintHorizontalBars(QPainter *painter, QRectF barsRect)
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing,false);
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
qreal vStep = (barsRect.height()-painter->fontMetrics().height()) / valuesCount() / seriesCount();
qreal hStep = (barsRect.width()-painter->fontMetrics().width(QString::number(maxValue()))) / delta;
if (!m_chartItem->series().isEmpty() && (m_chartItem->itemMode() != DesignMode)){
int curSeries = 0;
foreach (SeriesItem* series, m_chartItem->series()) {
qreal curVOffset = curSeries*vStep+barsRect.top();
painter->setBrush(series->color());
foreach (qreal value, series->data()->values()) {
painter->drawRect(QRectF((-minValue()*hStep)+barsRect.left(), curVOffset, value*hStep, vStep));
curVOffset+=vStep*seriesCount();
}
curSeries++;
}
} else {
qreal curVOffset = barsRect.top();
int curColor = 0;
for (int i=0; i<9; ++i){
if (curColor==3) curColor=0;
painter->setBrush(color_map[curColor]);
painter->drawRect(QRectF(barsRect.left(), curVOffset, designValues()[i]*hStep, vStep));
curVOffset+=vStep;
curColor++;
}
}
painter->restore();
}
}

17
limereport/items/charts/lrhorizontalbarchart.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef HORIZONTALBARCHART_H
#define HORIZONTALBARCHART_H
#include "lrchartitem.h"
namespace LimeReport{
class HorizontalBarChart: public AbstractBarChart{
public:
HorizontalBarChart(ChartItem* chartItem):AbstractBarChart(chartItem){}
void paintChart(QPainter *painter, QRectF chartRect);
void paintHorizontalBars(QPainter *painter, QRectF barsRect);
};
} // namespace LimeReport
#endif // HORIZONTALBARCHART_H

97
limereport/items/charts/lrlineschart.cpp Normal file
View File

@ -0,0 +1,97 @@
#include "lrlineschart.h"
namespace LimeReport {
void LinesChart::paintChart(QPainter *painter, QRectF chartRect)
{
QRectF calcRect = horizontalLabelsRect(
painter,
chartRect.adjusted(
hPadding(chartRect) * 2 + valuesHMargin(painter),
chartRect.height() - (painter->fontMetrics().height() + vPadding(chartRect)*2),
-(hPadding(chartRect) * 2),
-vPadding(chartRect)
)
);
qreal barsShift = calcRect.height();
paintVerticalGrid(
painter,
chartRect.adjusted(
hPadding(chartRect),
vPadding(chartRect) + valuesVMargin(painter),
-hPadding(chartRect),
-(vPadding(chartRect) + barsShift)
)
);
paintSerialLines(
painter,
chartRect.adjusted(
hPadding(chartRect) * 2 + valuesHMargin(painter),
vPadding(chartRect) + valuesVMargin(painter),
-(hPadding(chartRect) * 2),
-(vPadding(chartRect)+barsShift)
)
);
paintHorizontalLabels(painter, calcRect);
}
void LinesChart::drawDesignMode(QPainter* painter, qreal hStep, qreal vStep, qreal topShift, QRectF barsRect){
for (int i = 0; i < valuesCount()-1; ++i){
QPoint startPoint = QPoint((i+1) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - designValues()[i] * vStep
);
QPoint endPoint = QPoint((i+2) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - designValues()[i+1] * vStep
);
drawSegment(painter, startPoint, endPoint, color_map[0]);
startPoint = QPoint((i+1) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - designValues()[i+3] * vStep
);
endPoint = QPoint((i+2) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - designValues()[i+3+1] * vStep
);
drawSegment(painter, startPoint, endPoint, color_map[1]);
startPoint = QPoint((i+1) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - designValues()[i+6] * vStep
);
endPoint = QPoint((i+2) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - designValues()[i+6+1] * vStep
);
drawSegment(painter, startPoint, endPoint, color_map[2]);
}
}
void LinesChart::paintSerialLines(QPainter* painter, QRectF barsRect)
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing,true);
int delta = int(maxValue() - minValue());
delta = genNextValue(delta);
qreal vStep = barsRect.height() / delta;
qreal hStep = barsRect.width() / valuesCount();
qreal topShift = (delta - (maxValue() - minValue())) * vStep +barsRect.top();
if (m_chartItem->itemMode() != DesignMode){
foreach (SeriesItem* series, m_chartItem->series()) {
QPen pen(series->color());
pen.setWidth(4);
painter->setPen(pen);
for (int i = 0; i < series->data()->values().count()-1; ++i ){
QPoint startPoint = QPoint((i+1) * hStep + barsRect.left() - hStep/2,
(maxValue()*vStep+topShift) - series->data()->values().at(i) * vStep);
QPoint endPoint = QPoint((i+2) * hStep + barsRect.left() - hStep/2,
(maxValue() * vStep+topShift) - series->data()->values().at(i+1) * vStep);
drawSegment(painter, startPoint, endPoint, series->color());
}
}
} else {
drawDesignMode(painter, hStep, vStep, topShift, barsRect);
}
painter->restore();
}
} //namespace LimeReport

17
limereport/items/charts/lrlineschart.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef LINESCHART_H
#define LINESCHART_H
#include "lrchartitem.h"
namespace LimeReport {
class LinesChart: public AbstractBarChart{
public:
LinesChart(ChartItem* chartItem):AbstractBarChart(chartItem){}
void paintChart(QPainter *painter, QRectF chartRect);
private:
void paintSerialLines(QPainter *painter, QRectF barsRect);
void drawDesignMode(QPainter *painter, qreal hStep, qreal vStep, qreal topShift, QRectF barsRect);
};
}
#endif // LINESCHART_H

172
limereport/items/charts/lrpiechart.cpp Normal file
View File

@ -0,0 +1,172 @@
#include "lrpiechart.h"
namespace LimeReport{
void PieChart::drawPercent(QPainter *painter, QRectF chartRect, qreal startAngle, qreal angle)
{
painter->save();
QPointF center(chartRect.left()+chartRect.width()/2,chartRect.top()+chartRect.height()/2);
qreal percent = angle/3.6;
#ifdef HAVE_QT4
qreal radAngle = (angle/2+startAngle)*(M_PI/180);
#endif
#ifdef HAVE_QT5
qreal radAngle = qDegreesToRadians(angle/2+startAngle);
#endif
qreal radius = painter->fontMetrics().width("99,9%");
qreal border = chartRect.height()*0.02;
qreal length = (chartRect.height())/2-(radius/2+border);
qreal x,y;
x = length*qCos(radAngle);
y = length*qSin(radAngle);
QPointF endPoint(center.x()+x,center.y()-y);
painter->setPen(Qt::white);
QRectF textRect(endPoint.x()-(radius/2),endPoint.y()-(radius/2),radius,radius);
qreal arcLength = 3.14 * length * angle / 180;
if (arcLength >= radius)
painter->drawText(textRect,Qt::AlignCenter,QString::number(percent,'f',1)+"%");
painter->restore();
}
void PieChart::paintChart(QPainter *painter, QRectF chartRect)
{
painter->save();
QPen pen(Qt::white);
pen.setWidthF(2);
painter->setPen(pen);
QBrush brush(Qt::transparent);
painter->setBrush(brush);
painter->setBackground(QBrush(Qt::NoBrush));
QRectF tmpRect = chartRect;
if (chartRect.height()>chartRect.width()){
tmpRect.setHeight(chartRect.width());
tmpRect.adjust(0,(chartRect.bottom()-tmpRect.bottom())/2,
0,(chartRect.bottom()-tmpRect.bottom())/2);
} else {
tmpRect.setWidth(chartRect.height());
}
chartRect = tmpRect;
painter->drawRect(chartRect);
if (!m_chartItem->series().isEmpty()&&!m_chartItem->series().at(0)->data()->values().isEmpty()){
SeriesItem* si = m_chartItem->series().at(0);
qreal sum = 0;
foreach(qreal value, si->data()->values()){
sum+=value;
}
qreal onePercent = sum / 100;
qreal currentDegree = 0;
for(int i=0; i<si->data()->values().count(); ++i){
qreal value = si->data()->values().at(i);
qreal sectorDegree = (value/onePercent)*3.6;
painter->setBrush(si->data()->colors().at(i));
painter->drawPie(chartRect,currentDegree*16,sectorDegree*16);
drawPercent(painter, chartRect, currentDegree, sectorDegree);
currentDegree += sectorDegree;
}
} else {
painter->setBrush(color_map[0]);
painter->drawPie(chartRect,0,260*16);
drawPercent(painter, chartRect, 0, 260);
painter->setBrush(color_map[1]);
painter->drawPie(chartRect,260*16,40*16);
drawPercent(painter, chartRect, 260, 40);
painter->setBrush(color_map[2]);
painter->drawPie(chartRect,300*16,60*16);
drawPercent(painter, chartRect, 300, 60);
}
pen.setWidthF(1);
pen.setColor(Qt::gray);
painter->setPen(pen);
painter->setBrush(Qt::NoBrush);
painter->drawEllipse(chartRect);
painter->restore();
}
void PieChart::paintChartLegend(QPainter *painter, QRectF legendRect)
{
prepareLegendToPaint(legendRect, painter);
int indicatorSize = painter->fontMetrics().height()/2;
painter->setRenderHint(QPainter::Antialiasing,false);
if (m_chartItem->drawLegendBorder())
painter->drawRect(legendRect);
painter->setRenderHint(QPainter::Antialiasing,true);
QRectF indicatorsRect = legendRect.adjusted(painter->fontMetrics().height()/2,painter->fontMetrics().height()/2,0,0);
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
qreal cw = 0;
SeriesItem* si = m_chartItem->series().at(0);
for (int i=0;i<si->data()->labels().count();++i){
QString label = si->data()->labels().at(i);
painter->setPen(Qt::black);
painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
painter->setPen(si->data()->colors().at(i));
painter->setBrush(si->data()->colors().at(i));
painter->drawEllipse(
indicatorsRect.adjusted(
0,
cw+indicatorSize/2,
-(indicatorsRect.width()-indicatorSize),
-(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
)
);
cw += painter->fontMetrics().height();
}
} else {
qreal cw = 0;
for (int i=0;i<m_designLabels.size();++i){
QString label = m_designLabels.at(i);
painter->setPen(Qt::black);
painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
painter->setBrush(color_map[i]);
painter->setPen(color_map[i]);
painter->drawEllipse(
indicatorsRect.adjusted(
0,
cw+indicatorSize/2,
-(indicatorsRect.width()-indicatorSize),
-(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
)
);
cw += painter->fontMetrics().height();
}
}
}
QSizeF PieChart::calcChartLegendSize(const QFont &font)
{
QFontMetrics fm(font);
qreal cw = 0;
qreal maxWidth = 0;
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
SeriesItem* si = m_chartItem->series().at(0);
foreach(QString label, si->data()->labels()){
cw += fm.height();
if (maxWidth<fm.width(label))
maxWidth = fm.width(label)+10;
}
} else {
foreach(QString label, m_designLabels){
cw += fm.height();
if (maxWidth<fm.width(label))
maxWidth = fm.width(label)+10;
}
}
cw += fm.height();
return QSizeF(maxWidth+fm.height()*2,cw);
}
}

19
limereport/items/charts/lrpiechart.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef PIECHART_H
#define PIECHART_H
#include "lrchartitem.h"
namespace LimeReport{
class PieChart : public AbstractChart{
public:
PieChart(ChartItem* chartItem):AbstractChart(chartItem){}
QSizeF calcChartLegendSize(const QFont &font);
void paintChart(QPainter *painter, QRectF chartRect);
void paintChartLegend(QPainter *painter, QRectF legendRect);
protected:
void drawPercent(QPainter *painter, QRectF chartRect, qreal startAngle, qreal angle);
};
} // namespace LimeReport
#endif // PIECHART_H

123
limereport/items/charts/lrverticalbarchart.cpp Normal file
View File

@ -0,0 +1,123 @@
#include "lrverticalbarchart.h"
namespace LimeReport{
void VerticalBarChart::paintChart(QPainter *painter, QRectF chartRect)
{
QRectF calcRect = horizontalLabelsRect(
painter,
chartRect.adjusted(
hPadding(chartRect) * 2 + valuesHMargin(painter),
chartRect.height() - (painter->fontMetrics().height() + vPadding(chartRect) * 2),
-(hPadding(chartRect) * 2),
-vPadding(chartRect)
)
);
qreal barsShift = calcRect.height();
paintVerticalGrid(
painter,
chartRect.adjusted(
hPadding(chartRect),
vPadding(chartRect) + valuesVMargin(painter),
-hPadding(chartRect),
-(vPadding(chartRect) + barsShift)
)
);
paintVerticalBars(
painter,
chartRect.adjusted(
hPadding(chartRect) * 2 + valuesHMargin(painter),
vPadding(chartRect) + valuesVMargin(painter),
-hPadding(chartRect) * 2,
-(vPadding(chartRect) + barsShift)
)
);
paintSerialLines(
painter,
chartRect.adjusted(
hPadding(chartRect) * 2 + valuesHMargin(painter),
vPadding(chartRect) + valuesVMargin(painter),
-hPadding(chartRect) * 2,
-(vPadding(chartRect) + barsShift)
)
);
paintHorizontalLabels(painter, calcRect);
}
void VerticalBarChart::paintVerticalBars(QPainter *painter, QRectF barsRect)
{
int delta = int(maxValue() - minValue());
delta = genNextValue(delta);
int barSeriesCount = 0;
foreach(SeriesItem* series, m_chartItem->series()){
if (series->preferredType() == SeriesItem::Bar) barSeriesCount++;
}
barSeriesCount = (m_chartItem->itemMode() == DesignMode) ? seriesCount() : barSeriesCount;
if (barSeriesCount < 1) return;
painter->save();
painter->setRenderHint(QPainter::Antialiasing,false);
qreal vStep = barsRect.height() / delta;
qreal hStep = (barsRect.width() / valuesCount()) / (barSeriesCount == 0 ? 1 : barSeriesCount);
qreal topShift = (delta - (maxValue() - minValue())) * vStep + barsRect.top();
if (!m_chartItem->series().isEmpty() && (m_chartItem->itemMode() != DesignMode)){
int curSeries = 0;
foreach (SeriesItem* series, m_chartItem->series()) {
if (series->preferredType() == SeriesItem::Bar){
qreal curHOffset = curSeries * hStep + barsRect.left();
painter->setBrush(series->color());
foreach (qreal value, series->data()->values()) {
painter->drawRect(QRectF(curHOffset, maxValue() * vStep + topShift, hStep, -value * vStep));
curHOffset += hStep * barSeriesCount;
}
curSeries++;
}
}
} else {
qreal curHOffset = barsRect.left();
int curColor = 0;
for (int i = 0; i < 9; ++i){
if (curColor == 3) curColor = 0;
painter->setBrush(color_map[curColor]);
painter->drawRect(QRectF(curHOffset, maxValue() * vStep + barsRect.top(), hStep, -designValues()[i] * vStep));
curHOffset += hStep;
curColor++;
}
}
painter->restore();
}
void VerticalBarChart::paintSerialLines(QPainter* painter, QRectF barsRect)
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing,true);
int delta = int(maxValue() - minValue());
delta = genNextValue(delta);
qreal vStep = barsRect.height() / delta;
qreal hStep = (barsRect.width() / valuesCount());
qreal topShift = (delta - (maxValue()-minValue())) * vStep + barsRect.top();
if (!m_chartItem->series().isEmpty()){
foreach (SeriesItem* series, m_chartItem->series()) {
if (series->preferredType() == SeriesItem::Line){
for (int i = 0; i < series->data()->values().count()-1; ++i ){
QPoint startPoint = QPoint((i+1)*hStep + barsRect.left()-hStep/2,
(maxValue() * vStep+topShift) - series->data()->values().at(i) * vStep
);
QPoint endPoint = QPoint((i+2)*hStep + barsRect.left()-hStep/2,
(maxValue() * vStep+topShift) - series->data()->values().at(i+1) * vStep
);
drawSegment(painter, startPoint, endPoint, series->color());
}
}
}
}
painter->restore();
}
} // namespace LimeReport

19
limereport/items/charts/lrverticalbarchart.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef VERTICALBARCHART_H
#define VERTICALBARCHART_H
#include "lrchartitem.h"
namespace LimeReport{
class VerticalBarChart: public AbstractBarChart{
public:
VerticalBarChart(ChartItem* chartItem):AbstractBarChart(chartItem){}
void paintChart(QPainter *painter, QRectF chartRect);
// void paintVerticalGrid(QPainter *painter, QRectF gridRect);
void paintVerticalBars(QPainter *painter, QRectF barsRect);
void paintSerialLines(QPainter *painter, QRectF barsRect);
};
} //namespace LimeReport
#endif // VERTICALBARCHART_H

707
limereport/items/lrchartitem.cpp
View File

@ -9,6 +9,11 @@
#include "lrreportengine_p.h"
#include "lrdatadesignintf.h"
#include "charts/lrpiechart.h"
#include "charts/lrverticalbarchart.h"
#include "charts/lrhorizontalbarchart.h"
#include "charts/lrlineschart.h"
namespace{
const QString xmlTag = "ChartItem";
@ -32,15 +37,15 @@ QColor generateColor()
}
QColor color_map[39] = {
QColor(51,102,204), QColor(220,57,18), QColor(225, 153, 0), QColor(16, 150, 24), QColor(153,0,153),
QColor(0,153,198), QColor(221, 68, 119),
QColor(255,0,0), QColor(0,0,139), QColor(0,205,0), QColor(233,30,99), QColor(255,255,0), QColor(244,67,54),
QColor(156,39,176), QColor(103,58,183), QColor(63,81,181), QColor(33,153,243),
QColor(0,150,136), QColor(78,175,80), QColor(139,195,74), QColor(205,228,57),
QColor(0,139,0), QColor(0,0,255), QColor(255,235,59), QColor(255,193,7),
QColor(255,152,0), QColor(255,87,34), QColor(121,85,72), QColor(158,158,158),
QColor(96,125,139), QColor(241,153,185), QColor(64,64,64),
QColor(188,229,218), QColor(139,0,0), QColor(139,139,0), QColor(171, 130, 255),
QColor(51,102,204), QColor(220,57,18), QColor(225, 153, 0), QColor(16, 150, 24),
QColor(153,0,153), QColor(0,153,198), QColor(221, 68, 119), QColor(255,0,0),
QColor(0,0,139), QColor(0,205,0), QColor(233,30,99), QColor(255,255,0),
QColor(244,67,54), QColor(156,39,176), QColor(103,58,183), QColor(63,81,181),
QColor(33,153,243), QColor(0,150,136), QColor(78,175,80), QColor(139,195,74),
QColor(205,228,57), QColor(0,139,0), QColor(0,0,255), QColor(255,235,59),
QColor(255,193,7), QColor(255,152,0), QColor(255,87,34), QColor(121,85,72),
QColor(158,158,158), QColor(96,125,139), QColor(241,153,185), QColor(64,64,64),
QColor(188,229,218), QColor(139,0,0), QColor(139,139,0), QColor(171, 130, 255),
QColor(139, 123, 139), QColor(255, 0, 255), QColor(139, 69, 19)
};
@ -85,6 +90,8 @@ SeriesItem *SeriesItem::clone()
void SeriesItem::fillSeriesData(IDataSource *dataSource)
{
m_data.clear();
if (dataSource){
dataSource->first();
int currentColorIndex = 0;
@ -244,7 +251,7 @@ QWidget *ChartItem::defaultEditor()
QSettings* l_settings = (page()->settings() != 0) ?
page()->settings() :
(page()->reportEditor()!=0) ? page()->reportEditor()->settings() : 0;
QWidget* editor = new ChartItemEditor(this,page(),l_settings);
QWidget* editor = new ChartItemEditor(this, page(), l_settings);
editor->setAttribute(Qt::WA_DeleteOnClose);
return editor;
}
@ -295,6 +302,8 @@ void ChartItem::setChartType(const ChartType &chartType)
case HorizontalBar:
m_chart = new HorizontalBarChart(this);
break;
case Lines:
m_chart = new LinesChart(this);
}
notify("chartType",oldValue,m_chartType);
update();
@ -460,364 +469,14 @@ void AbstractChart::prepareLegendToPaint(QRectF &legendRect, QPainter *painter)
}
}
void PieChart::drawPercent(QPainter *painter, QRectF chartRect, qreal startAngle, qreal angle)
{
painter->save();
QPointF center(chartRect.left()+chartRect.width()/2,chartRect.top()+chartRect.height()/2);
qreal percent = angle/3.6;
#ifdef HAVE_QT4
qreal radAngle = (angle/2+startAngle)*(M_PI/180);
#endif
#ifdef HAVE_QT5
qreal radAngle = qDegreesToRadians(angle/2+startAngle);
#endif
qreal radius = painter->fontMetrics().width("99,9%");
qreal border = chartRect.height()*0.02;
qreal length = (chartRect.height())/2-(radius/2+border);
qreal x,y;
x = length*qCos(radAngle);
y = length*qSin(radAngle);
QPointF endPoint(center.x()+x,center.y()-y);
painter->setPen(Qt::white);
QRectF textRect(endPoint.x()-(radius/2),endPoint.y()-(radius/2),radius,radius);
qreal arcLength = 3.14 * length * angle / 180;
if (arcLength >= radius)
painter->drawText(textRect,Qt::AlignCenter,QString::number(percent,'f',1)+"%");
painter->restore();
}
void PieChart::paintChart(QPainter *painter, QRectF chartRect)
{
painter->save();
QPen pen(Qt::white);
pen.setWidthF(2);
painter->setPen(pen);
QBrush brush(Qt::transparent);
painter->setBrush(brush);
painter->setBackground(QBrush(Qt::NoBrush));
QRectF tmpRect = chartRect;
if (chartRect.height()>chartRect.width()){
tmpRect.setHeight(chartRect.width());
tmpRect.adjust(0,(chartRect.bottom()-tmpRect.bottom())/2,
0,(chartRect.bottom()-tmpRect.bottom())/2);
} else {
tmpRect.setWidth(chartRect.height());
}
chartRect = tmpRect;
painter->drawRect(chartRect);
if (!m_chartItem->series().isEmpty()&&!m_chartItem->series().at(0)->data()->values().isEmpty()){
SeriesItem* si = m_chartItem->series().at(0);
qreal sum = 0;
foreach(qreal value, si->data()->values()){
sum+=value;
}
qreal onePercent = sum / 100;
qreal currentDegree = 0;
for(int i=0; i<si->data()->values().count(); ++i){
qreal value = si->data()->values().at(i);
qreal sectorDegree = (value/onePercent)*3.6;
painter->setBrush(si->data()->colors().at(i));
painter->drawPie(chartRect,currentDegree*16,sectorDegree*16);
drawPercent(painter, chartRect, currentDegree, sectorDegree);
currentDegree += sectorDegree;
}
} else {
painter->setBrush(color_map[0]);
painter->drawPie(chartRect,0,260*16);
drawPercent(painter, chartRect, 0, 260);
painter->setBrush(color_map[1]);
painter->drawPie(chartRect,260*16,40*16);
drawPercent(painter, chartRect, 260, 40);
painter->setBrush(color_map[2]);
painter->drawPie(chartRect,300*16,60*16);
drawPercent(painter, chartRect, 300, 60);
}
pen.setWidthF(1);
pen.setColor(Qt::gray);
painter->setPen(pen);
painter->setBrush(Qt::NoBrush);
painter->drawEllipse(chartRect);
painter->restore();
}
void PieChart::paintChartLegend(QPainter *painter, QRectF legendRect)
{
prepareLegendToPaint(legendRect, painter);
int indicatorSize = painter->fontMetrics().height()/2;
painter->setRenderHint(QPainter::Antialiasing,false);
if (m_chartItem->drawLegendBorder())
painter->drawRect(legendRect);
painter->setRenderHint(QPainter::Antialiasing,true);
QRectF indicatorsRect = legendRect.adjusted(painter->fontMetrics().height()/2,painter->fontMetrics().height()/2,0,0);
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
qreal cw = 0;
SeriesItem* si = m_chartItem->series().at(0);
for (int i=0;i<si->data()->labels().count();++i){
QString label = si->data()->labels().at(i);
painter->setPen(Qt::black);
painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
painter->setPen(si->data()->colors().at(i));
painter->setBrush(si->data()->colors().at(i));
painter->drawEllipse(
indicatorsRect.adjusted(
0,
cw+indicatorSize/2,
-(indicatorsRect.width()-indicatorSize),
-(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
)
);
cw += painter->fontMetrics().height();
}
} else {
qreal cw = 0;
for (int i=0;i<m_designLabels.size();++i){
QString label = m_designLabels.at(i);
painter->setPen(Qt::black);
painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
painter->setBrush(color_map[i]);
painter->setPen(color_map[i]);
painter->drawEllipse(
indicatorsRect.adjusted(
0,
cw+indicatorSize/2,
-(indicatorsRect.width()-indicatorSize),
-(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
)
);
cw += painter->fontMetrics().height();
}
}
}
QSizeF PieChart::calcChartLegendSize(const QFont &font)
{
QFontMetrics fm(font);
qreal cw = 0;
qreal maxWidth = 0;
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
SeriesItem* si = m_chartItem->series().at(0);
foreach(QString label, si->data()->labels()){
cw += fm.height();
if (maxWidth<fm.width(label))
maxWidth = fm.width(label)+10;
}
} else {
foreach(QString label, m_designLabels){
cw += fm.height();
if (maxWidth<fm.width(label))
maxWidth = fm.width(label)+10;
}
}
cw += fm.height();
return QSizeF(maxWidth+fm.height()*2,cw);
}
int genNextValue(int value){
int curValue = value;
while (curValue%4!=0){
while (curValue % 4 != 0){
curValue++;
}
return curValue;
}
qreal VerticalBarChart::valuesHMargin(QPainter* painter)
{
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
return painter->fontMetrics().width(QString::number(delta))+4;
}
qreal VerticalBarChart::valuesVMargin(QPainter *painter)
{
return painter->fontMetrics().height();
}
QRectF VerticalBarChart::labelsRect(QPainter *painter, QRectF labelsRect)
{
qreal maxWidth = 0;
foreach (QString label, m_chartItem->labels()) {
if (painter->fontMetrics().width(label)>maxWidth)
maxWidth = painter->fontMetrics().width(label);
}
if (maxWidth+vPadding(m_chartItem->rect())> labelsRect.height())
return labelsRect;
else
return labelsRect.adjusted(0,(labelsRect.height()-(maxWidth+vPadding(m_chartItem->rect()))),0,0);
}
void VerticalBarChart::paintChart(QPainter *painter, QRectF chartRect)
{
QRectF calcRect = labelsRect(painter, chartRect.adjusted(
hPadding(chartRect)*2+valuesHMargin(painter),
chartRect.height()*0.5,
-(hPadding(chartRect)*2),
-vPadding(chartRect)
));
qreal barsShift = calcRect.height();
paintVerticalGrid(painter, chartRect.adjusted(
hPadding(chartRect),
vPadding(chartRect)+valuesVMargin(painter),
-hPadding(chartRect),-(vPadding(chartRect)+barsShift) ));
paintVerticalBars(painter, chartRect.adjusted(
hPadding(chartRect)*2+valuesHMargin(painter),
vPadding(chartRect)+valuesVMargin(painter),
-(hPadding(chartRect)*2),
-(vPadding(chartRect)+barsShift) ));
paintSerialLines(painter, chartRect.adjusted(
hPadding(chartRect)*2+valuesHMargin(painter),
vPadding(chartRect)+valuesVMargin(painter),
-(hPadding(chartRect)*2),
-(vPadding(chartRect)+barsShift) ));
paintLabels(painter,calcRect);
}
void VerticalBarChart::paintVerticalGrid(QPainter *painter, QRectF gridRect)
{
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
painter->setRenderHint(QPainter::Antialiasing,false);
qreal vStep = gridRect.height() / 4;
for (int i=0;i<5;i++){
painter->drawText(QRectF(gridRect.bottomLeft()-QPointF(0,vStep*i+painter->fontMetrics().height()),
QSizeF(valuesHMargin(painter),painter->fontMetrics().height())),
QString::number(minValue()+i*delta/4));
painter->drawLine(gridRect.bottomLeft()-QPointF(-valuesHMargin(painter),vStep*i),
gridRect.bottomRight()-QPointF(0,vStep*i));
}
painter->setRenderHint(QPainter::Antialiasing,true);
}
void VerticalBarChart::paintVerticalBars(QPainter *painter, QRectF barsRect)
{
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
int barSeriesCount = 0;
foreach(SeriesItem* series, m_chartItem->series()){
if (series->preferredType() == SeriesItem::Bar) barSeriesCount++;
}
barSeriesCount = (m_chartItem->itemMode()==DesignMode) ? seriesCount() : barSeriesCount;
painter->save();
painter->setRenderHint(QPainter::Antialiasing,false);
qreal vStep = barsRect.height() / delta;
qreal hStep = (barsRect.width() / valuesCount()) / (barSeriesCount == 0 ? 1 : barSeriesCount);
qreal topShift = (delta - (maxValue()-minValue())) * vStep +barsRect.top();
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
int curSeries = 0;
foreach (SeriesItem* series, m_chartItem->series()) {
if (series->preferredType() == SeriesItem::Bar){
qreal curHOffset = curSeries*hStep+barsRect.left();
painter->setBrush(series->color());
foreach (qreal value, series->data()->values()) {
painter->drawRect(QRectF(curHOffset, maxValue()*vStep+topShift, hStep, -value*vStep));
curHOffset+=hStep*barSeriesCount;
}
curSeries++;
}
}
} else {
qreal curHOffset = barsRect.left();
int curColor = 0;
for (int i=0; i<9; ++i){
if (curColor==3) curColor=0;
painter->setBrush(color_map[curColor]);
painter->drawRect(QRectF(curHOffset, maxValue()*vStep+barsRect.top(), hStep, -designValues()[i]*vStep));
curHOffset+=hStep;
curColor++;
}
}
painter->restore();
}
void VerticalBarChart::paintSerialLines(QPainter* painter, QRectF barsRect)
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing,true);
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
qreal vStep = barsRect.height() / delta;
qreal hStep = (barsRect.width() / valuesCount());
qreal topShift = (delta - (maxValue()-minValue())) * vStep +barsRect.top();
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
foreach (SeriesItem* series, m_chartItem->series()) {
if (series->preferredType() == SeriesItem::Line){
QPen pen(series->color());
pen.setWidth(4);
painter->setPen(pen);
for (int i = 0; i < series->data()->values().count()-1; ++i ){
QPoint startPoint = QPoint((i+1)*hStep + barsRect.left()-hStep/2,
(maxValue()*vStep+topShift) - series->data()->values().at(i)*vStep
);
QPoint endPoint = QPoint((i+2)*hStep + barsRect.left()-hStep/2,
(maxValue()*vStep+topShift) - series->data()->values().at(i+1)*vStep
);
painter->drawLine(startPoint, endPoint);
QRect startPointRect(startPoint,startPoint);
QRect endPointRect(endPoint,endPoint);
int radius = 4;
painter->setBrush(series->color());
painter->drawEllipse(startPointRect.adjusted(radius,radius,-radius,-radius));
painter->drawEllipse(endPointRect.adjusted(radius,radius,-radius,-radius));
}
}
}
}
painter->restore();
}
void VerticalBarChart::paintLabels(QPainter *painter, QRectF labelsRect)
{
painter->save();
qreal hStep = (labelsRect.width() / valuesCount());
if (!m_chartItem->labels().isEmpty()){
painter->rotate(270);
painter->translate(-(labelsRect.top()+labelsRect.height()),labelsRect.left());
foreach (QString label, m_chartItem->labels()) {
painter->drawText(QRectF(QPoint(0,0),
QSize(labelsRect.height()-4,hStep)),Qt::AlignVCenter|Qt::AlignRight,label);
painter->translate(0,hStep);
}
painter->rotate(-270);
}
painter->restore();
}
AbstractSeriesChart::AbstractSeriesChart(ChartItem *chartItem)
:AbstractChart(chartItem)
{
@ -834,7 +493,7 @@ AbstractSeriesChart::AbstractSeriesChart(ChartItem *chartItem)
qreal AbstractSeriesChart::maxValue()
{
if (m_chartItem->itemMode()==DesignMode) return 40;
if (m_chartItem->itemMode() == DesignMode) return 40;
qreal maxValue = 0;
foreach(SeriesItem* series, m_chartItem->series()){
foreach(qreal value, series->data()->values()){
@ -846,7 +505,7 @@ qreal AbstractSeriesChart::maxValue()
qreal AbstractSeriesChart::minValue()
{
if (m_chartItem->itemMode()==DesignMode) return 0;
if (m_chartItem->itemMode() == DesignMode) return 0;
qreal minValue = 0;
foreach(SeriesItem* series, m_chartItem->series()){
foreach(qreal value, series->data()->values()){
@ -856,15 +515,25 @@ qreal AbstractSeriesChart::minValue()
return minValue;
}
qreal AbstractSeriesChart::hPadding(QRectF chartRect)
{
return (chartRect.width() * 0.02);
}
qreal AbstractSeriesChart::vPadding(QRectF chartRect)
{
return (chartRect.height() * 0.02);
}
int AbstractSeriesChart::valuesCount()
{
if (m_chartItem->itemMode()==DesignMode) return 3;
return (m_chartItem->series().isEmpty())?(0):(m_chartItem->series().at(0)->data()->labels().count());
if (m_chartItem->itemMode() == DesignMode) return 3;
return (m_chartItem->series().isEmpty()) ? 0 : m_chartItem->series().at(0)->data()->values().count();
}
int AbstractSeriesChart::seriesCount()
{
if (m_chartItem->itemMode()==DesignMode) return 3;
if (m_chartItem->itemMode() == DesignMode) return 3;
return m_chartItem->series().count();
}
@ -892,154 +561,48 @@ QSizeF AbstractSeriesChart::calcChartLegendSize(const QFont &font)
return QSizeF(maxWidth+fm.height()*2,cw);
}
qreal HorizontalBarChart::valuesHMargin(QPainter *painter)
{
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
return painter->fontMetrics().width(QString::number(delta))+4;
}
qreal HorizontalBarChart::valuesVMargin(QPainter *painter)
{
return painter->fontMetrics().height();
}
void HorizontalBarChart::paintChart(QPainter *painter, QRectF chartRect)
{
QRectF calcRect = labelsRect(painter, chartRect.adjusted(
hPadding(chartRect),
vPadding(chartRect)*2,
-(chartRect.width()*0.5),
-(vPadding(chartRect)*2+valuesVMargin(painter))
));
qreal barsShift = calcRect.width();
paintHorizontalGrid(painter, chartRect.adjusted(
hPadding(chartRect)+barsShift,
vPadding(chartRect),
-(hPadding(chartRect)),-vPadding(chartRect)));
paintHorizontalBars(painter, chartRect.adjusted(
hPadding(chartRect)+barsShift,
vPadding(chartRect)*2,
-(hPadding(chartRect)),
-(vPadding(chartRect)*2) ));
paintLabels(painter,calcRect);
}
void HorizontalBarChart::paintHorizontalGrid(QPainter *painter, QRectF gridRect)
{
painter->save();
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
painter->setRenderHint(QPainter::Antialiasing,false);
qreal hStep = (gridRect.width()-painter->fontMetrics().width(QString::number(maxValue()))) / 4;
painter->setFont(adaptValuesFont(hStep-4,painter->font()));
for (int i=0;i<5;i++){
painter->drawText(QRectF(gridRect.left()+4+hStep*i,gridRect.bottom()-painter->fontMetrics().height(),
hStep,painter->fontMetrics().height()),
QString::number(minValue()+i*delta/4));
painter->drawLine( gridRect.left()+hStep*i, gridRect.bottom(),
gridRect.left()+hStep*i, gridRect.top());
}
painter->restore();
}
void HorizontalBarChart::paintHorizontalBars(QPainter *painter, QRectF barsRect)
{
painter->save();
painter->setRenderHint(QPainter::Antialiasing,false);
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
qreal vStep = (barsRect.height()-painter->fontMetrics().height()) / valuesCount() / seriesCount();
qreal hStep = (barsRect.width()-painter->fontMetrics().width(QString::number(maxValue()))) / delta;
if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
int curSeries = 0;
foreach (SeriesItem* series, m_chartItem->series()) {
qreal curVOffset = curSeries*vStep+barsRect.top();
painter->setBrush(series->color());
foreach (qreal value, series->data()->values()) {
painter->drawRect(QRectF((-minValue()*hStep)+barsRect.left(), curVOffset, value*hStep, vStep));
curVOffset+=vStep*seriesCount();
}
curSeries++;
}
} else {
qreal curVOffset = barsRect.top();
int curColor = 0;
for (int i=0; i<9; ++i){
if (curColor==3) curColor=0;
painter->setBrush(color_map[curColor]);
painter->drawRect(QRectF(barsRect.left(), curVOffset, designValues()[i]*hStep, vStep));
curVOffset+=vStep;
curColor++;
}
}
painter->restore();
}
QRectF HorizontalBarChart::labelsRect(QPainter *painter, QRectF labelsRect)
{
qreal maxWidth = 0;
foreach (QString label, m_chartItem->labels()) {
if (painter->fontMetrics().width(label)>maxWidth)
maxWidth = painter->fontMetrics().width(label);
}
if (maxWidth+hPadding(m_chartItem->rect())*2> labelsRect.width())
return labelsRect;
else
return labelsRect.adjusted(0,0,-(labelsRect.width()-(maxWidth+hPadding(m_chartItem->rect())*2)),0);
}
QFont HorizontalBarChart::adaptLabelsFont(QRectF rect, QFont font)
{
QString maxWord;
QFontMetrics fm(font);
bool AbstractSeriesChart::verticalLabels(QPainter* painter, QRectF labelsRect){
qreal hStep = (labelsRect.width() / valuesCount());
QFontMetrics fm = painter->fontMetrics();
foreach(QString label, m_chartItem->labels()){
foreach (QString currentWord, label.split(QRegExp("\\W+"))){
if (fm.width(maxWord)<fm.width(currentWord)) maxWord = currentWord;
if (fm.width(label) > hStep){
return true;
}
}
qreal curWidth = fm.width(maxWord);
QFont tmpFont = font;
while (curWidth>rect.width() && tmpFont.pixelSize()>1){
tmpFont.setPixelSize(tmpFont.pixelSize()-1);
QFontMetricsF tmpFM(tmpFont);
curWidth = tmpFM.width(maxWord);
}
return tmpFont;
return false;
}
QFont HorizontalBarChart::adaptValuesFont(qreal width, QFont font)
{
QString strValue = QString::number(maxValue());
QFont tmpFont = font;
QScopedPointer<QFontMetricsF> fm(new QFontMetricsF(tmpFont));
qreal curWidth = fm->width(strValue);
while (curWidth>width && tmpFont.pixelSize()>1){
tmpFont.setPixelSize(tmpFont.pixelSize()-1);
fm.reset(new QFontMetricsF(tmpFont));
curWidth = fm->width(strValue);
}
return tmpFont;
}
void HorizontalBarChart::paintLabels(QPainter *painter, QRectF labelsRect)
void AbstractSeriesChart::paintHorizontalLabels(QPainter *painter, QRectF labelsRect)
{
painter->save();
painter->setFont(adaptLabelsFont(labelsRect.adjusted(0,0,-hPadding(m_chartItem->rect()),0),
painter->font()));
qreal hStep = (labelsRect.width() / valuesCount());
if (!m_chartItem->labels().isEmpty()){
if (verticalLabels(painter, labelsRect)){
painter->rotate(270);
painter->translate( -(labelsRect.top()+labelsRect.height()), labelsRect.left() );
foreach (QString label, m_chartItem->labels()) {
painter->drawText(QRectF(QPoint(0,0),
QSize(labelsRect.height()-4, hStep)), Qt::AlignVCenter | Qt::AlignRight, label);
painter->translate(0,hStep);
}
painter->rotate(-270);
} else {
painter->translate( labelsRect.left(), labelsRect.top() );
foreach (QString label, m_chartItem->labels()) {
painter->drawText(QRectF(QPoint(0, 4),
QSize(hStep, labelsRect.height()-4)), Qt::AlignHCenter | Qt::AlignTop, label);
painter->translate(hStep, 0);
}
}
}
painter->restore();
}
void AbstractSeriesChart::paintVerticalLabels(QPainter *painter, QRectF labelsRect)
{
painter->save();
painter->setFont(adaptLabelsFont(labelsRect.adjusted(0, 0, -hPadding(m_chartItem->rect()), 0),
painter->font()));
qreal vStep = (labelsRect.height() / valuesCount());
int curLabel = 0;
@ -1056,14 +619,106 @@ void HorizontalBarChart::paintLabels(QPainter *painter, QRectF labelsRect)
painter->restore();
}
qreal AbstractBarChart::hPadding(QRectF chartRect)
void AbstractSeriesChart::paintHorizontalGrid(QPainter *painter, QRectF gridRect)
{
return (chartRect.width()*0.02);
painter->save();
int delta = int(maxValue() - minValue());
delta = genNextValue(delta);
painter->setRenderHint(QPainter::Antialiasing,false);
qreal hStep = (gridRect.width() - painter->fontMetrics().width(QString::number(maxValue()))) / 4;
painter->setFont(adaptValuesFont(hStep-4, painter->font()));
for (int i=0;i<5;i++){
painter->drawText(QRectF(gridRect.left() + 4 + hStep * i, gridRect.bottom() - painter->fontMetrics().height(),
hStep, painter->fontMetrics().height()),
QString::number(minValue() + i * delta / 4));
painter->drawLine( gridRect.left()+hStep*i, gridRect.bottom(),
gridRect.left()+hStep*i, gridRect.top());
}
painter->restore();
}
qreal AbstractBarChart::vPadding(QRectF chartRect)
void AbstractSeriesChart::paintVerticalGrid(QPainter *painter, QRectF gridRect)
{
return (chartRect.height()*0.02);
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
painter->setRenderHint(QPainter::Antialiasing,false);
qreal vStep = gridRect.height() / 4;
for (int i=0;i<5;i++){
painter->drawText(QRectF(gridRect.bottomLeft()-QPointF(0,vStep*i+painter->fontMetrics().height()),
QSizeF(valuesHMargin(painter),painter->fontMetrics().height())),
QString::number(minValue()+i*delta/4));
painter->drawLine(gridRect.bottomLeft()-QPointF(-valuesHMargin(painter),vStep*i),
gridRect.bottomRight()-QPointF(0,vStep*i));
}
painter->setRenderHint(QPainter::Antialiasing,true);
}
void AbstractSeriesChart::drawSegment(QPainter *painter, QPoint startPoint, QPoint endPoint, QColor color)
{
int radius = 4;
QPen pen(color);
pen.setWidth(radius);
painter->setPen(pen);
painter->drawLine(startPoint, endPoint);
QRect startPointRect(startPoint,startPoint);
QRect endPointRect(endPoint,endPoint);
painter->setBrush(color);
painter->drawEllipse(startPointRect.adjusted(radius,radius,-radius,-radius));
painter->drawEllipse(endPointRect.adjusted(radius,radius,-radius,-radius));
}
qreal AbstractSeriesChart::valuesHMargin(QPainter *painter)
{
int delta = int(maxValue()-minValue());
delta = genNextValue(delta);
return painter->fontMetrics().width(QString::number(delta))+4;
}
qreal AbstractSeriesChart::valuesVMargin(QPainter *painter)
{
return painter->fontMetrics().height();
}
QFont AbstractSeriesChart::adaptLabelsFont(QRectF rect, QFont font)
{
QString maxWord;
QFontMetrics fm(font);
foreach(QString label, m_chartItem->labels()){
foreach (QString currentWord, label.split(QRegExp("\\W+"))){
if (fm.width(maxWord) < fm.width(currentWord)) maxWord = currentWord;
}
}
qreal curWidth = fm.width(maxWord);
QFont tmpFont = font;
while (curWidth>rect.width() && tmpFont.pixelSize() > 1){
tmpFont.setPixelSize(tmpFont.pixelSize() - 1);
QFontMetricsF tmpFM(tmpFont);
curWidth = tmpFM.width(maxWord);
}
return tmpFont;
}
QFont AbstractSeriesChart::adaptValuesFont(qreal width, QFont font)
{
QString strValue = QString::number(maxValue());
QFont tmpFont = font;
QScopedPointer<QFontMetricsF> fm(new QFontMetricsF(tmpFont));
qreal curWidth = fm->width(strValue);
while (curWidth > width && tmpFont.pixelSize() > 1){
tmpFont.setPixelSize(tmpFont.pixelSize() - 1);
fm.reset(new QFontMetricsF(tmpFont));
curWidth = fm->width(strValue);
}
return tmpFont;
}
void AbstractBarChart::paintChartLegend(QPainter *painter, QRectF legendRect)
@ -1113,4 +768,34 @@ void AbstractBarChart::paintChartLegend(QPainter *painter, QRectF legendRect)
}
}
QRectF AbstractBarChart::verticalLabelsRect(QPainter *painter, QRectF labelsRect)
{
qreal maxWidth = 0;
foreach (QString label, m_chartItem->labels()) {
if (painter->fontMetrics().width(label)>maxWidth)
maxWidth = painter->fontMetrics().width(label);
}
if (maxWidth + hPadding(m_chartItem->rect()) * 2 < labelsRect.width())
return labelsRect;
else
return labelsRect.adjusted(0, 0, -(labelsRect.width() - (maxWidth + hPadding(m_chartItem->rect()) * 2)), 0);
}
QRectF AbstractBarChart::horizontalLabelsRect(QPainter *painter, QRectF labelsRect)
{
qreal maxWidth = 0;
foreach (QString label, m_chartItem->labels()) {
if (painter->fontMetrics().width(label)>maxWidth)
maxWidth = painter->fontMetrics().width(label);
}
if ((maxWidth + vPadding(m_chartItem->rect()) < labelsRect.height()) || !verticalLabels(painter, labelsRect))
return labelsRect;
else
return labelsRect.adjusted(0, (labelsRect.height() - maxWidth), 0, 0);
}
} // namespace LimeReport

67
limereport/items/lrchartitem.h
View File

@ -16,6 +16,7 @@ public:
QList<qreal>& values(){ return m_values;}
QList<QString>& labels(){ return m_labels;}
QList<QColor>& colors() { return m_colors;}
void clear(){ m_values.clear(); m_labels.clear(); m_colors.clear(); }
private:
QList<qreal> m_values;
QList<QString> m_labels;
@ -80,56 +81,34 @@ protected:
qreal minValue();
int valuesCount();
int seriesCount();
bool verticalLabels(QPainter* painter, QRectF labelsRect);
QSizeF calcChartLegendSize(const QFont &font);
qreal* designValues(){ return m_designValues;}
virtual qreal hPadding(QRectF chartRect);
virtual qreal vPadding(QRectF chartRect);
virtual void paintHorizontalLabels(QPainter *painter, QRectF labelsRect);
virtual void paintVerticalLabels(QPainter *painter, QRectF labelsRect);
virtual void paintHorizontalGrid(QPainter *painter, QRectF gridRect);
virtual void paintVerticalGrid(QPainter *painter, QRectF gridRect);
virtual void drawSegment(QPainter *painter, QPoint startPoint, QPoint endPoint, QColor color);
virtual qreal valuesHMargin(QPainter *painter);
virtual qreal valuesVMargin(QPainter *painter);
virtual QFont adaptLabelsFont(QRectF rect, QFont font);
virtual QFont adaptValuesFont(qreal width, QFont font);
private:
qreal m_designValues [9];
};
class PieChart : public AbstractChart{
public:
PieChart(ChartItem* chartItem):AbstractChart(chartItem){}
QSizeF calcChartLegendSize(const QFont &font);
void paintChart(QPainter *painter, QRectF chartRect);
void paintChartLegend(QPainter *painter, QRectF legendRect);
protected:
void drawPercent(QPainter *painter, QRectF chartRect, qreal startAngle, qreal angle);
};
int genNextValue(int value);
class AbstractBarChart: public AbstractSeriesChart{
public:
AbstractBarChart(ChartItem* chartItem):AbstractSeriesChart(chartItem){}
qreal hPadding(QRectF chartRect);
qreal vPadding(QRectF chartRect);
void paintChartLegend(QPainter *painter, QRectF legendRect);
};
class HorizontalBarChart: public AbstractBarChart{
public:
HorizontalBarChart(ChartItem* chartItem):AbstractBarChart(chartItem){}
qreal valuesHMargin(QPainter *painter);
qreal valuesVMargin(QPainter *painter);
void paintChart(QPainter *painter, QRectF chartRect);
void paintHorizontalGrid(QPainter *painter, QRectF gridRect);
void paintHorizontalBars(QPainter *painter, QRectF barsRect);
QRectF labelsRect(QPainter* painter, QRectF labelsRect);
void paintLabels(QPainter *painter, QRectF labelsRect);
protected:
QFont adaptLabelsFont(QRectF rect, QFont font);
QFont adaptValuesFont(qreal width, QFont font);
};
class VerticalBarChart: public AbstractBarChart{
public:
VerticalBarChart(ChartItem* chartItem):AbstractBarChart(chartItem){}
qreal valuesHMargin(QPainter *painter);
qreal valuesVMargin(QPainter *painter);
QRectF labelsRect(QPainter* painter, QRectF labelsRect);
void paintChart(QPainter *painter, QRectF chartRect);
void paintVerticalGrid(QPainter *painter, QRectF gridRect);
void paintVerticalBars(QPainter *painter, QRectF barsRect);
void paintSerialLines(QPainter *painter, QRectF barsRect);
void paintLabels(QPainter *painter, QRectF labelsRect);
QRectF verticalLabelsRect(QPainter* painter, QRectF horizontalLabelsRect);
virtual QRectF horizontalLabelsRect(QPainter* painter, QRectF horizontalLabelsRect);
};
class ChartItem : public LimeReport::ItemDesignIntf
@ -138,7 +117,7 @@ class ChartItem : public LimeReport::ItemDesignIntf
Q_ENUMS(LegendAlign)
Q_ENUMS(TitleAlign)
Q_ENUMS(ChartType)
Q_PROPERTY(ACollectionProperty series READ fakeCollectionReader)
Q_PROPERTY(ACollectionProperty series READ fakeCollectionReader WRITE setSeries)
Q_PROPERTY(QString datasource READ datasource WRITE setDatasource)
Q_PROPERTY(QString chartTitle READ chartTitle WRITE setChartTitle)
Q_PROPERTY(bool drawLegendBorder READ drawLegendBorder WRITE setDrawLegendBorder)
@ -151,7 +130,7 @@ public:
enum LegendAlign{LegendAlignTop,LegendAlignCenter,LegendAlignBottom};
enum TitleAlign{TitleAlignLeft, TitleAlignCenter, TitleAlignRight};
enum ChartType{Pie, VerticalBar, HorizontalBar};
enum ChartType{Pie, VerticalBar, HorizontalBar, Lines};
ChartItem(QObject* owner, QGraphicsItem* parent);
~ChartItem();
@ -184,22 +163,22 @@ public:
QList<QString> labels() const;
void setLabels(const QList<QString> &labels);
QWidget* defaultEditor();
protected:
void paintChartTitle(QPainter* painter, QRectF titleRect);
virtual BaseDesignIntf* createSameTypeItem(QObject *owner, QGraphicsItem *parent);
//ICollectionContainer
QObject* createElement(const QString& collectionName,const QString& elementType);
QObject* createElement(const QString& collectionName, const QString& elementType);
int elementsCount(const QString& collectionName);
QObject* elementAt(const QString& collectionName,int index);
void collectionLoadFinished(const QString& collectionName){Q_UNUSED(collectionName)}
void updateItemSize(DataSourceManager *dataManager, RenderPass, int);
void fillLabels(IDataSource* dataSource);
QWidget* defaultEditor();
void fillLabels(IDataSource* dataSource);
bool isNeedUpdateSize(RenderPass pass) const;
void setSeries(ACollectionProperty series){Q_UNUSED(series)}
private:
QList<SeriesItem*> m_series;
// QList< QPointer<SeriesItem> > m_series;
QString m_datasource;
QPixmap m_chartImage;
QString m_title;

2
limereport/items/lrchartitemeditor.cpp
View File

@ -189,9 +189,9 @@ void ChartItemEditor::on_splitter_splitterMoved(int , int )
#endif
}
void ChartItemEditor::on_pbOk_clicked()
{
emit editingFinished();
close();
}

4
limereport/items/lrchartitemeditor.h
View File

@ -25,6 +25,10 @@ public:
protected:
void resizeEvent(QResizeEvent *);
void moveEvent(QMoveEvent *);
signals:
void editingFinished();
private slots:
void on_splitter_splitterMoved(int, int);
void on_pbOk_clicked();

21
limereport/limereport.pri
View File

@ -43,6 +43,12 @@ SOURCES += \
$$REPORT_PATH/items/lrverticallayout.cpp \
$$REPORT_PATH/items/lrlayoutmarker.cpp \
$$REPORT_PATH/items/lrabstractlayout.cpp \
$$REPORT_PATH/items/lrchartitem.cpp \
$$REPORT_PATH/items/lrchartitemeditor.cpp \
$$REPORT_PATH/items/charts/lrhorizontalbarchart.cpp \
$$REPORT_PATH/items/charts/lrlineschart.cpp \
$$REPORT_PATH/items/charts/lrpiechart.cpp \
$$REPORT_PATH/items/charts/lrverticalbarchart.cpp \
$$REPORT_PATH/lrbanddesignintf.cpp \
$$REPORT_PATH/lrpageitemdesignintf.cpp \
$$REPORT_PATH/lrpagedesignintf.cpp \
@ -65,8 +71,6 @@ SOURCES += \
$$REPORT_PATH/lrsettingdialog.cpp \
$$REPORT_PATH/lritemscontainerdesignitf.cpp \
$$REPORT_PATH/lrcolorindicator.cpp \
$$REPORT_PATH/items/lrchartitem.cpp \
$$REPORT_PATH/items/lrchartitemeditor.cpp \
$$REPORT_PATH/lrreporttranslation.cpp \
$$REPORT_PATH/exporters/lrpdfexporter.cpp \
$$REPORT_PATH/lrpreparedpages.cpp
@ -104,6 +108,8 @@ HEADERS += \
$$REPORT_PATH/scripteditor/lrscripthighlighter.h \
$$REPORT_PATH/items/editors/lritemeditorwidget.h \
$$REPORT_PATH/items/editors/lrfonteditorwidget.h \
$$REPORT_PATH/items/editors/lrtextalignmenteditorwidget.h \
$$REPORT_PATH/items/editors/lritemsborderseditorwidget.h \
$$REPORT_PATH/items/lrtextitem.h \
$$REPORT_PATH/items/lrhorizontallayout.h \
$$REPORT_PATH/items/lrtextitemeditor.h \
@ -114,6 +120,12 @@ HEADERS += \
$$REPORT_PATH/items/lrverticallayout.h \
$$REPORT_PATH/items/lrlayoutmarker.h \
$$REPORT_PATH/items/lrabstractlayout.h \
$$REPORT_PATH/items/lrchartitem.h \
$$REPORT_PATH/items/lrchartitemeditor.h \
$$REPORT_PATH/items/charts/lrhorizontalbarchart.h \
$$REPORT_PATH/items/charts/lrlineschart.h \
$$REPORT_PATH/items/charts/lrpiechart.h \
$$REPORT_PATH/items/charts/lrverticalbarchart.h \
$$REPORT_PATH/lrbanddesignintf.h \
$$REPORT_PATH/lrpageitemdesignintf.h \
$$REPORT_PATH/lrbandsmanager.h \
@ -145,10 +157,6 @@ HEADERS += \
$$REPORT_PATH/lrpreviewreportwidget_p.h \
$$REPORT_PATH/lritemscontainerdesignitf.h \
$$REPORT_PATH/lrcolorindicator.h \
$$REPORT_PATH/items/lrchartitem.h \
$$REPORT_PATH/items/lrchartitemeditor.h \
$$REPORT_PATH/items/editors/lrtextalignmenteditorwidget.h \
$$REPORT_PATH/items/editors/lritemsborderseditorwidget.h \
$$REPORT_PATH/lrreporttranslation.h \
$$REPORT_PATH/lrreportdesignwindowintrerface.h \
$$REPORT_PATH/lrexporterintf.h \
@ -157,7 +165,6 @@ HEADERS += \
$$REPORT_PATH/lrpreparedpages.h \
$$REPORT_PATH/lrpreparedpagesintf.h
contains(CONFIG, staticlib){
HEADERS += $$REPORT_PATH/lrfactoryinitializer.h
}

11
limereport/lrbanddesignintf.cpp
View File

@ -241,6 +241,13 @@ void BandDesignIntf::setBackgroundOpacity(int value)
}
}
bool BandDesignIntf::isNeedUpdateSize(RenderPass pass) const{
foreach(BaseDesignIntf* item, childBaseItems()){
if (item->isNeedUpdateSize(pass)) return true;
}
return false;
}
void BandDesignIntf::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
prepareRect(painter, option, widget);
@ -1123,14 +1130,14 @@ void BandDesignIntf::updateItemSize(DataSourceManager* dataManager, RenderPass p
if (keepBottomSpace()) spaceBorder = bottomSpace();
spaceBorder = spaceBorder > 0 ? spaceBorder : 0;
if (borderLines() != 0){
spaceBorder += borderLineSize();
spaceBorder += borderLineSize() + 2;
}
spaceBorder += m_bottomSpace;
restoreLinks();
snapshotItemsLayout();
BandDesignIntf* patternBand = dynamic_cast<BandDesignIntf*>(patternItem());
if (patternBand && pass == FirstPass) emit(patternBand->preparedForRender());
arrangeSubItems(pass, dataManager);
if (autoHeight()){
if (!keepTopSpace()) {

4
limereport/lrbanddesignintf.h
View File

@ -117,6 +117,7 @@ class BandDesignIntf : public ItemsContainerDesignInft
Q_ENUMS(BandColumnsLayoutType)
friend class BandMarker;
friend class BandNameLabel;
friend class ReportRender;
public:
enum BandsType {
@ -263,7 +264,8 @@ public:
void setBootomSpace(int bootomSpace);
void updateBandMarkerGeometry();
int shiftItems() const;
void setShiftItems(int shiftItems);
void setShiftItems(int shiftItems);
bool isNeedUpdateSize(RenderPass) const;
signals:
void bandRendered(BandDesignIntf* band);

2
limereport/lrbasedesignintf.cpp
View File

@ -1569,7 +1569,7 @@ void BaseDesignIntf::objectLoadFinished()
void BaseDesignIntf::parentObjectLoadFinished()
{}
QList<BaseDesignIntf *> BaseDesignIntf::childBaseItems()
QList<BaseDesignIntf *> BaseDesignIntf::childBaseItems() const
{
QList<BaseDesignIntf *> resList;
foreach(QGraphicsItem * item, childItems()) {

4
limereport/lrbasedesignintf.h
View File

@ -244,7 +244,7 @@ public:
virtual void parentObjectLoadFinished();
virtual void beforeDelete();
QList<BaseDesignIntf*> childBaseItems();
QList<BaseDesignIntf*> childBaseItems() const;
QList<BaseDesignIntf*> allChildBaseItems();
BaseDesignIntf* childByName(const QString& name);
@ -468,7 +468,7 @@ public:
QVariant getBookMark(const QString& key);
void copyBookmarks(BookmarkContainerDesignIntf* source);
private:
QMap<QString,QVariant> m_bookmarks;
QHash<QString,QVariant> m_bookmarks;
};
} //namespace LimeReport

35
limereport/lrdatadesignintf.cpp
View File

@ -719,24 +719,35 @@ QVariant CallbackDatasource::dataByKeyField(const QString& columnName, const QSt
{
int backupCurrentRow = m_currentRow;
QVariant result = QVariant();
first();
if (!checkIfEmpty()){
int currentRow = 0;
do {
QVariant key = callbackData(keyColumnName, currentRow);
m_currentRow = m_lastKeyRow;
if (next()){
for (int i = 0; i < 10; ++i){
QVariant key = callbackData(keyColumnName, m_currentRow);
if (key == keyData){
result = callbackData(columnName, currentRow);
break;
result = callbackData(columnName, m_currentRow);
m_lastKeyRow = m_currentRow;
m_currentRow = backupCurrentRow;
return result;
}
currentRow++;
} while (next());
if (!next()) break;
}
}
first();
if (backupCurrentRow != -1){
for (int i = 0; i < backupCurrentRow; ++i)
next();
if (!checkIfEmpty()){
do {
QVariant key = callbackData(keyColumnName, m_currentRow);
if (key == keyData){
result = callbackData(columnName, m_currentRow);
m_lastKeyRow = m_currentRow;
m_currentRow = backupCurrentRow;
return result;
}
} while (next());
}
m_currentRow = backupCurrentRow;
return result;
}

7
limereport/lrdatadesignintf.h
View File

@ -410,8 +410,8 @@ private:
class CallbackDatasource :public ICallbackDatasource, public IDataSource {
Q_OBJECT
public:
CallbackDatasource(): m_currentRow(-1), m_eof(false), m_columnCount(-1),
m_rowCount(-1), m_getDataFromCache(false){}
CallbackDatasource(): m_currentRow(-1), m_eof(false), m_columnCount(-1),
m_rowCount(-1), m_getDataFromCache(false), m_lastKeyRow(0){}
bool next();
bool hasNext(){ if (!m_eof) return checkNextRecord(m_currentRow); else return false;}
bool prior();
@ -431,6 +431,7 @@ public:
private:
bool checkNextRecord(int recordNum);
bool checkIfEmpty();
QVariant callbackData(const QString& columnName, int row);
private:
QVector<QString> m_headers;
int m_currentRow;
@ -439,7 +440,7 @@ private:
int m_rowCount;
QHash<QString, QVariant> m_valuesCache;
bool m_getDataFromCache;
QVariant callbackData(const QString& columnName, int row);
int m_lastKeyRow;
};
class CallbackDatasourceHolder :public QObject, public IDataSourceHolder{

4
limereport/lrpreviewreportwidget.cpp
View File

@ -124,9 +124,9 @@ bool PreviewReportWidget::exportReport(QString exporterName, const QMap<QString,
if (ExportersFactory::instance().map().contains(exporterName)){
ReportExporterInterface* e = ExportersFactory::instance().objectCreator(exporterName)(d_ptr->m_report);
QString defaultFileName = d_ptr->m_report->reportName().split(".")[0];
QString filter = QString("%1 (*.%2)").arg(e->exporterName()).arg(e->exporterFileExt());
QString fileName = QFileDialog::getSaveFileName(this,tr("%1 file name").arg(e->exporterName()),"",filter);
QString fileName = QFileDialog::getSaveFileName(this,tr("%1 file name").arg(e->exporterName()), defaultFileName, filter);
if (!fileName.isEmpty()){
QFileInfo fi(fileName);
if (fi.suffix().isEmpty())

2
limereport/lrreportdesignwidget.cpp
View File

@ -722,6 +722,7 @@ void ReportDesignWidget::initThemeIfExist(const QString &themeName, const QStrin
void ReportDesignWidget::previewReport()
{
if (report()->isBusy()) return;
prepareReport();
#ifdef HAVE_QTDESIGNER_INTEGRATION
updateDialogs();
@ -734,6 +735,7 @@ void ReportDesignWidget::previewReport()
void ReportDesignWidget::printReport()
{
if (report()->isBusy()) return;
prepareReport();
#ifdef HAVE_QTDESIGNER_INTEGRATION
updateDialogs();

2
limereport/lrreportdesignwindow.cpp
View File

@ -1264,7 +1264,9 @@ void ReportDesignWindow::slotPrintReport()
void ReportDesignWindow::slotPreviewReport()
{
m_previewReportAction->setDisabled(true);
m_reportDesignWidget->previewReport();
m_previewReportAction->setDisabled(false);
}
void ReportDesignWindow::slotItemActionCliked()

45
limereport/lrreportengine.cpp
View File

@ -316,18 +316,17 @@ void ReportEnginePrivate::internalPrintPages(ReportPages pages, QPrinter &printe
if ( !m_cancelPrinting &&
((printer.printRange() == QPrinter::AllPages) ||
( (printer.printRange()==QPrinter::PageRange) &&
(currenPage>=printer.fromPage()) &&
(currenPage<=printer.toPage())
(currenPage >= printer.fromPage()) &&
(currenPage <= printer.toPage())
))
)
{
printProcessors["default"]->printPage(page);
currenPage++;
emit pagePrintingFinished(currenPage);
QApplication::processEvents();
}
currenPage++;
}
emit printingFinished();
}
@ -470,8 +469,9 @@ bool ReportEnginePrivate::exportReport(QString exporterName, const QString &file
if (ExportersFactory::instance().map().contains(exporterName)){
ReportExporterInterface* e = ExportersFactory::instance().objectCreator(exporterName)(this);
if (fn.isEmpty()){
QString defaultFileName = reportName().split(".")[0];
QString filter = QString("%1 (*.%2)").arg(e->exporterName()).arg(e->exporterFileExt());
QString fn = QFileDialog::getSaveFileName(0,tr("%1 file name").arg(e->exporterName()),"",filter);
QString fn = QFileDialog::getSaveFileName(0, tr("%1 file name").arg(e->exporterName()), defaultFileName, filter);
}
if (!fn.isEmpty()){
QFileInfo fi(fn);
@ -737,7 +737,7 @@ QGraphicsScene* ReportEngine::createPreviewScene(QObject* parent){
return d->createPreviewScene(parent);
}
void ReportEnginePrivate::designReport()
void ReportEnginePrivate::designReport(bool showModal)
{
ReportDesignWindowInterface* designerWindow = getDesignerWindow();
if (designerWindow){
@ -746,7 +746,7 @@ void ReportEnginePrivate::designReport()
#ifdef Q_OS_WIN
designerWindow->setWindowModality(Qt::ApplicationModal);
#endif
if (QApplication::activeWindow()==0){
if (!showModal){
designerWindow->show();;
} else {
designerWindow->showModal();
@ -1254,6 +1254,11 @@ BaseDesignIntf* ReportEnginePrivate::createWatermark(PageDesignIntf* page, Water
}
void ReportEnginePrivate::clearRenderingPages(){
qDeleteAll(m_renderingPages.begin(), m_renderingPages.end());
m_renderingPages.clear();
}
ReportPages ReportEnginePrivate::renderToPages()
{
int startTOCPage = -1;
@ -1275,7 +1280,7 @@ ReportPages ReportEnginePrivate::renderToPages()
m_reportRendering = true;
m_reportRender->setDatasources(dataManager());
m_reportRender->setScriptContext(scriptContext());
m_renderingPages.clear();
clearRenderingPages();
foreach (PageDesignIntf* page, m_pages) {
QVector<BaseDesignIntf*> watermarks;
@ -1349,14 +1354,10 @@ ReportPages ReportEnginePrivate::renderToPages()
emit renderFinished();
m_reportRender.clear();
//foreach(PageItemDesignIntf* page, m_renderingPages){
// delete page;
//}
m_renderingPages.clear();
clearRenderingPages();
}
m_reportRendering = false;
//activateLanguage(QLocale::AnyLanguage);
#ifdef USE_QTSCRIPTENGINE
ScriptEngineManager::instance().scriptEngine()->popContext();
#endif
@ -1372,7 +1373,7 @@ QString ReportEnginePrivate::lastError()
}
ReportEngine::ReportEngine(QObject *parent)
: QObject(parent), d_ptr(new ReportEnginePrivate())
: QObject(parent), d_ptr(new ReportEnginePrivate()), m_showDesignerModal(true)
{
Q_D(ReportEngine);
d->q_ptr=this;
@ -1468,7 +1469,7 @@ void ReportEngine::designReport()
Q_D(ReportEngine);
if (m_settings)
d->setSettings(m_settings);
d->designReport();
d->designReport(showDesignerModal());
}
ReportDesignWindowInterface* ReportEngine::getDesignerWindow()
@ -1759,7 +1760,7 @@ void ReportEngine::cancelPrinting()
}
ReportEngine::ReportEngine(ReportEnginePrivate &dd, QObject *parent)
:QObject(parent),d_ptr(&dd)
:QObject(parent), d_ptr(&dd), m_showDesignerModal(true)
{
Q_D(ReportEngine);
d->q_ptr=this;
@ -1769,6 +1770,16 @@ ReportEngine::ReportEngine(ReportEnginePrivate &dd, QObject *parent)
connect(d, SIGNAL(renderFinished()), this, SIGNAL(renderFinished()));
}
bool ReportEngine::showDesignerModal() const
{
return m_showDesignerModal;
}
void ReportEngine::setShowDesignerModal(bool showDesignerModal)
{
m_showDesignerModal = showDesignerModal;
}
ScriptEngineManager*LimeReport::ReportEnginePrivate::scriptManager(){
ScriptEngineManager::instance().setContext(scriptContext());
ScriptEngineManager::instance().setDataManager(dataManager());

4
limereport/lrreportengine.h
View File

@ -208,6 +208,9 @@ public:
bool showPreparedPages(PreviewHints hints = PreviewBarsUserSetting);
bool prepareReportPages();
bool printPreparedPages();
bool showDesignerModal() const;
void setShowDesignerModal(bool showDesignerModal);
signals:
void cleared();
void renderStarted();
@ -241,6 +244,7 @@ protected:
private:
Q_DECLARE_PRIVATE(ReportEngine)
static QSettings* m_settings;
bool m_showDesignerModal;
};
} // namespace LimeReport

4
limereport/lrreportengine_p.h
View File

@ -113,6 +113,7 @@ public:
virtual void cancelRender() = 0;
virtual void setShowProgressDialog(bool value) = 0;
virtual bool isShowProgressDialog() const = 0;
virtual bool isBusy() = 0;
};
class PrintProcessor{
@ -179,7 +180,7 @@ public:
void previewReport(QPrinter* printer, PreviewHints hints = PreviewBarsUserSetting);
ReportDesignWindowInterface* getDesignerWindow();
void designReport();
void designReport(bool showModal);
void setSettings(QSettings* value);
void setShowProgressDialog(bool value){m_showProgressDialog = value;}
bool isShowProgressDialog() const {return m_showProgressDialog;}
@ -310,6 +311,7 @@ private:
void initReport();
void paintByExternalPainter(const QString& objectName, QPainter* painter, const QStyleOptionGraphicsItem* options);
void dropChanges(){ m_datasources->dropChanges(); m_scriptEngineContext->dropChanges();}
void clearRenderingPages();
private:
QList<PageDesignIntf*> m_pages;
QList<PageItemDesignIntf*> m_renderingPages;

41
limereport/lrreportrender.cpp
View File

@ -1,4 +1,4 @@
/***************************************************************************
/***************************************************************************
* This file is part of the Lime Report project *
* Copyright (C) 2015 by Alexander Arin *
* arin_a@bk.ru *
@ -261,11 +261,11 @@ void ReportRender::renderPage(PageItemDesignIntf* patternPage, bool isTOC, bool
renderReportHeader(m_patternPageItem, AfterPageHeader);
BandDesignIntf* lastRenderedBand = 0;
for (int i=0;i<m_patternPageItem->dataBandCount() && !m_renderCanceled;i++){
for (int i=0;i<m_patternPageItem->dataBandCount() && !m_renderCanceled; i++){
lastRenderedBand = m_patternPageItem->dataBandAt(i);
initDatasource(lastRenderedBand->datasourceName());
renderDataBand(lastRenderedBand);
if (i<m_patternPageItem->dataBandCount()-1) closeFooterGroup(lastRenderedBand);
if (i < m_patternPageItem->dataBandCount()-1) closeFooterGroup(lastRenderedBand);
}
if (reportFooter)
@ -475,7 +475,7 @@ BandDesignIntf* ReportRender::renderBand(BandDesignIntf *patternBand, BandDesign
if (bandData){
bandClone = bandData;
} else {
bandClone=renderData(patternBand);
bandClone = renderData(patternBand);
}
if (isLast) bandClone->setBootomSpace(1);
@ -543,8 +543,10 @@ BandDesignIntf* ReportRender::renderBand(BandDesignIntf *patternBand, BandDesign
savePage();
startNewPage();
if (!bandIsSliced){
BandDesignIntf* t = renderData(patternBand);
t->copyBookmarks(bandClone);
delete bandClone;
bandClone = renderData(patternBand);
bandClone = t;
}
}
if (!registerBand(bandClone)) {
@ -636,10 +638,23 @@ void ReportRender::renderDataBand(BandDesignIntf *dataBand)
bandDatasource->next();
datasources()->setReportVariable(varName,datasources()->variable(varName).toInt()+1);
foreach (BandDesignIntf* band, dataBand->childrenByType(BandDesignIntf::GroupHeader)){
QString groupLineVar = QLatin1String("line_")+band->objectName().toLower();
if (datasources()->containsVariable(groupLineVar))
datasources()->setReportVariable(groupLineVar,datasources()->variable(groupLineVar).toInt()+1);
QList<BandDesignIntf *> bandList;
QList<BandDesignIntf *> childList;
bandList = dataBand->childrenByType(BandDesignIntf::GroupHeader);
while (bandList.size() > 0)
{
childList.clear();
foreach (BandDesignIntf* band, bandList)
{
childList.append(band->childrenByType(BandDesignIntf::GroupHeader));
QString groupLineVar = QLatin1String("line_")+band->objectName().toLower();
if (datasources()->containsVariable(groupLineVar))
datasources()->setReportVariable(groupLineVar,datasources()->variable(groupLineVar).toInt()+1);
}
bandList = childList;
}
renderGroupHeader(dataBand, bandDatasource, false);
@ -1170,7 +1185,7 @@ void ReportRender::updateTOC(BaseDesignIntf* item, int pageNumber){
void ReportRender::secondRenderPass(ReportPages renderedPages)
{
if (!m_scriptEngineContext->tableOfContents()->isEmpty()){
for(int i=0; i<renderedPages.count(); ++i){
for(int i = 0; i < renderedPages.count(); ++i){
PageItemDesignIntf::Ptr page = renderedPages.at(i);
updateTOC(page.data(), m_pagesRanges.findPageNumber(i));
foreach(BaseDesignIntf* item, page->childBaseItems()){
@ -1179,12 +1194,13 @@ void ReportRender::secondRenderPass(ReportPages renderedPages)
}
}
for(int i=0; i<renderedPages.count(); ++i){
for(int i = 0; i < renderedPages.count(); ++i){
PageItemDesignIntf::Ptr page = renderedPages.at(i);
m_datasources->setReportVariable("#PAGE",m_pagesRanges.findPageNumber(i));
m_datasources->setReportVariable("#PAGE_COUNT",m_pagesRanges.findLastPageNumber(i));
foreach(BaseDesignIntf* item, page->childBaseItems()){
item->updateItemSize(m_datasources, SecondPass);
if (item->isNeedUpdateSize(SecondPass))
item->updateItemSize(m_datasources, SecondPass);
}
}
}
@ -1248,6 +1264,7 @@ BandDesignIntf *ReportRender::renderData(BandDesignIntf *patternBand)
replaceGroupsFunction(bandClone);
}
emit(patternBand->preparedForRender());
bandClone->updateItemSize(m_datasources);
//m_scriptEngineContext->baseDesignIntfToScript(bandClone);

90
limereport/lrscriptenginemanager.cpp
View File

@ -60,14 +60,18 @@ QScriptValue constructColor(QScriptContext *context, QScriptEngine *engine)
namespace LimeReport{
ScriptEngineNode::ScriptEngineNode(const QString &name, const QString &description,
ScriptEngineNode::NodeType type, ScriptEngineNode *parent, const QIcon &icon)
:m_name(name), m_description(description), m_icon(icon), m_type(type), m_parent(parent)
{}
ScriptEngineNode::~ScriptEngineNode()
{
for (int i = 0; i<m_childs.count(); ++i){
delete m_childs[i];
}
qDeleteAll(m_childs.begin(), m_childs.end());
}
ScriptEngineNode*ScriptEngineNode::addChild(const QString& name, const QString& description, ScriptEngineNode::NodeType type, const QIcon& icon)
ScriptEngineNode*ScriptEngineNode::addChild(const QString& name, const QString& description,
ScriptEngineNode::NodeType type, const QIcon& icon)
{
ScriptEngineNode* res = new ScriptEngineNode(name, description, type,this,icon);
m_childs.push_back(res);
@ -213,26 +217,23 @@ ScriptEngineManager::~ScriptEngineManager()
bool ScriptEngineManager::isFunctionExists(const QString &functionName) const
{
foreach (ScriptFunctionDesc desc, m_functions) {
if (desc.name.compare(functionName,Qt::CaseInsensitive)==0){
return true;
}
}
return false;
return m_functions.contains(functionName);
// foreach (ScriptFunctionDesc desc, m_functions.values()) {
// if (desc.name.compare(functionName,Qt::CaseInsensitive)==0){
// return true;
// }
// }
// return false;
}
void ScriptEngineManager::deleteFunction(const QString &functionsName)
{
QMutableListIterator<ScriptFunctionDesc> it(m_functions);
while(it.hasNext()){
if (it.next().name.compare(functionsName, Qt::CaseInsensitive)==0){
it.remove();
}
}
m_functions.remove(functionsName);
}
bool ScriptEngineManager::addFunction(const JSFunctionDesc &functionDescriber)
{
if (m_functions.contains(functionDescriber.name())) return false;
ScriptValueType functionManager = scriptEngine()->globalObject().property(functionDescriber.managerName());
#ifdef USE_QJSENGINE
if (functionManager.isUndefined()){
@ -254,7 +255,7 @@ bool ScriptEngineManager::addFunction(const JSFunctionDesc &functionDescriber)
funct.description = functionDescriber.description();
funct.category = functionDescriber.category();
funct.type = ScriptFunctionDesc::Native;
m_functions.append(funct);
m_functions.insert(funct.name, funct);
if (m_model)
m_model->updateModel();
return true;
@ -269,15 +270,6 @@ bool ScriptEngineManager::addFunction(const JSFunctionDesc &functionDescriber)
}
bool ScriptEngineManager::containsFunction(const QString& functionName){
foreach (ScriptFunctionDesc funct, m_functions) {
if (funct.name.compare(functionName)== 0){
return true;
}
}
return false;
}
#ifdef USE_QTSCRIPTENGINE
#if QT_VERSION > 0x050600
Q_DECL_DEPRECATED
@ -287,19 +279,19 @@ bool ScriptEngineManager::addFunction(const QString& name,
const QString& category,
const QString& description)
{
if (!containsFunction(name)){
if (!isFunctionExists(name)){
ScriptFunctionDesc funct;
funct.name = name;
funct.description = description;
funct.category = category;
funct.scriptValue = scriptEngine()->newFunction(function);
funct.scriptValue.setProperty("functionName",name);
funct.scriptValue.setProperty("functionName", name);
funct.scriptValue.setData(m_scriptEngine->toScriptValue(this));
funct.type = ScriptFunctionDesc::Native;
m_functions.append(funct);
m_functions.insert(name, funct);
if (m_model)
m_model->updateModel();
m_scriptEngine->globalObject().setProperty(funct.name,funct.scriptValue);
m_scriptEngine->globalObject().setProperty(funct.name, funct.scriptValue);
return true;
} else {
return false;
@ -317,7 +309,7 @@ bool ScriptEngineManager::addFunction(const QString& name, const QString& script
funct.category = category;
funct.description = description;
funct.type = ScriptFunctionDesc::Script;
m_functions.append(funct);
m_functions.insert(name, funct);
m_model->updateModel();
return true;
} else {
@ -328,16 +320,17 @@ bool ScriptEngineManager::addFunction(const QString& name, const QString& script
QStringList ScriptEngineManager::functionsNames()
{
QStringList res;
foreach(ScriptFunctionDesc func, m_functions){
res<<func.name;
}
return res;
return m_functions.keys();
// QStringList res;
// foreach(ScriptFunctionDesc func, m_functions){
// res<<func.name;
// }
// return res;
}
void ScriptEngineManager::setDataManager(DataSourceManager *dataManager){
if (dataManager && m_dataManager != dataManager){
m_dataManager = dataManager;
m_dataManager = dataManager;
if (m_dataManager){
foreach(QString func, m_dataManager->groupFunctionNames()){
JSFunctionDesc describer(
@ -594,8 +587,7 @@ void ScriptEngineManager::clearTableOfContents(){
}
ScriptValueType ScriptEngineManager::moveQObjectToScript(QObject* object, const QString objectName)
{
{
ScriptValueType obj = scriptEngine()->globalObject().property(objectName);
if (!obj.isNull()) delete obj.toQObject();
ScriptValueType result = scriptEngine()->newQObject(object);
@ -1941,7 +1933,7 @@ bool DatasourceFunctions::invalidate(const QString& datasourceName)
return false;
}
QObject* DatasourceFunctions::createTableBuilder(BaseDesignIntf* horizontalLayout)
QObject* DatasourceFunctions::createTableBuilder(QObject* horizontalLayout)
{
return new TableBuilder(dynamic_cast<LimeReport::HorizontalLayout*>(horizontalLayout), dynamic_cast<DataSourceManager*>(m_dataManager));
}
@ -1994,14 +1986,16 @@ void TableBuilder::buildTable(const QString& datasourceName)
{
checkBaseLayout();
m_dataManager->dataSourceHolder(datasourceName)->invalidate(IDataSource::RENDER_MODE);
m_dataManager->dataSource(datasourceName)->first();
bool firstTime = true;
QObject* row = m_horizontalLayout;
while(!m_dataManager->dataSource(datasourceName)->eof()){
if (!firstTime) row = addRow();
else firstTime = false;
fillInRowData(row);
m_dataManager->dataSource(datasourceName)->next();
IDataSource* ds = m_dataManager->dataSource(datasourceName);
if (ds){
bool firstTime = true;
QObject* row = m_horizontalLayout;
while(!ds->eof()){
if (!firstTime) row = addRow();
else firstTime = false;
fillInRowData(row);
ds->next();
}
}
}

17
limereport/lrscriptenginemanager.h
View File

@ -98,14 +98,15 @@ struct ScriptFunctionDesc{
class ScriptEngineNode {
public:
enum NodeType{Root,Category,Function,Dialog,DialogElement};
ScriptEngineNode(const QString& name="", const QString& description ="", NodeType type=Root, ScriptEngineNode* parent=0, const QIcon& icon=QIcon())
:m_name(name), m_description(description), m_icon(icon), m_type(type), m_parent(parent){}
enum NodeType{Root, Category, Function, Dialog, DialogElement};
ScriptEngineNode(const QString& name = "", const QString& description = "", NodeType type = Root,
ScriptEngineNode* parent = 0, const QIcon& icon = QIcon());
virtual ~ScriptEngineNode();
int childCount(){return m_childs.count();}
ScriptEngineNode* child(int index){return m_childs[index];}
ScriptEngineNode* parent(){return m_parent;}
ScriptEngineNode* addChild(const QString& name="", const QString &description="", NodeType type=Root, const QIcon& icon=QIcon());
ScriptEngineNode* addChild(const QString& name = "", const QString &description = "",
NodeType type = Root, const QIcon& icon = QIcon());
int row();
QString name(){return m_name;}
QString description(){return m_description;}
@ -337,7 +338,7 @@ public:
Q_INVOKABLE bool prior(const QString& datasourceName);
Q_INVOKABLE bool isEOF(const QString& datasourceName);
Q_INVOKABLE bool invalidate(const QString& datasourceName);
Q_INVOKABLE QObject *createTableBuilder(BaseDesignIntf* horizontalLayout);
Q_INVOKABLE QObject *createTableBuilder(QObject *horizontalLayout);
private:
IDataSourceManager* m_dataManager;
};
@ -455,7 +456,7 @@ public:
const QString &category="", const QString &description="");
const QString& lastError() const {return m_lastError;}
QStringList functionsNames();
const QList<ScriptFunctionDesc>& functionsDescribers(){return m_functions;}
const QHash<QString,ScriptFunctionDesc>& functionsDescribers(){return m_functions;}
ScriptEngineModel* model(){return m_model;}
void setContext(ScriptEngineContext* context){m_context=context;}
DataSourceManager* dataManager() const {return m_dataManager;}
@ -473,10 +474,8 @@ public:
void addTableOfContentsItem(const QString& uniqKey, const QString& content, int indent);
void clearTableOfContents();
ScriptValueType moveQObjectToScript(QObject* object, const QString objectName);
protected:
void updateModel();
bool containsFunction(const QString &functionName);
private:
Q_DISABLE_COPY(ScriptEngineManager)
bool createLineFunction();
@ -503,7 +502,7 @@ private:
ScriptEngineManager();
ScriptEngineType* m_scriptEngine;
QString m_lastError;
QList<ScriptFunctionDesc> m_functions;
QHash<QString,ScriptFunctionDesc> m_functions;
ScriptEngineModel* m_model;
ScriptEngineContext* m_context;
DataSourceManager* m_dataManager;

8
limereport/objectinspector/lrobjectinspectorwidget.cpp
View File

@ -95,13 +95,17 @@ void ObjectInspectorTreeView::mousePressEvent(QMouseEvent *event)
if ((event->button()==Qt::LeftButton)){
QModelIndex index=indexAt(event->pos());
if (index.isValid()){
if (event->pos().x()<indentation()) {
if (event->pos().x() < indentation()) {
if (!nodeFromIndex(index)->isHaveValue())
setExpanded(index,!isExpanded(index));
} else {
if ((index.column()==1)&&(!nodeFromIndex(index)->isHaveChildren())) {
setCurrentIndex(index);
edit(index);
Qt::ItemFlags flags = index.model()->flags(index);
if ( !(((flags & Qt::ItemIsEditable) == 0) || ((flags & Qt::ItemIsEnabled) == 0)) )
edit(index);
return ;
}
}

10
limereport/objectinspector/lrobjectitemmodel.cpp
View File

@ -363,14 +363,14 @@ QModelIndex QObjectPropertyModel::parent(const QModelIndex &child) const
Qt::ItemFlags QObjectPropertyModel::flags(const QModelIndex &index) const
{
if ((index.column()==1)&&(!nodeFromIndex(index)->isValueReadonly())) return Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable;
if ((index.column() == 1) && (!nodeFromIndex(index)->isValueReadonly())) return Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable;
else return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}
CreatePropItem QObjectPropertyModel::propertyItemCreator(QMetaProperty prop)
{
CreatePropItem creator=0;
creator=ObjectPropFactory::instance().objectCreator(APropIdent(prop.name(),prop.enclosingMetaObject()->className()));
CreatePropItem creator = 0;
creator = ObjectPropFactory::instance().objectCreator(APropIdent(prop.name(),prop.enclosingMetaObject()->className()));
if (!creator){
if (prop.isFlagType()){
creator=ObjectPropFactory::instance().objectCreator(APropIdent("flags",""));
@ -390,7 +390,7 @@ CreatePropItem QObjectPropertyModel::propertyItemCreator(QMetaProperty prop)
return 0;
}
}
creator=ObjectPropFactory::instance().objectCreator(APropIdent(prop.typeName(),""));
creator = ObjectPropFactory::instance().objectCreator(APropIdent(prop.typeName(),""));
if (!creator) {qDebug()<<"Editor for propperty name = \""<<prop.name()<<"\" & property type =\""<<prop.typeName()<<"\" not found!";}
}
return creator;
@ -409,7 +409,7 @@ ObjectPropItem * QObjectPropertyModel::createPropertyItem(QMetaProperty prop, QO
QString(tr(prop.name())),
object->property(prop.name()),
parent,
!(prop.isWritable()&&prop.isDesignable())
!(prop.isWritable() && prop.isDesignable())
);
} else {
propertyItem=new ObjectPropItem(

4
limereport/objectinspector/propertyItems/lrimagepropitem.cpp
View File

@ -48,12 +48,12 @@ QWidget* ImagePropItem::createProperyEditor(QWidget *parent) const
QString ImagePropItem::displayValue() const
{
return (propertyValue().isNull())?"":"Picture";
return (propertyValue().isNull()) ? "" : QObject::tr("image");
}
void ImagePropItem::setPropertyEditorData(QWidget *propertyEditor, const QModelIndex &) const
{
ImageEditor *editor =qobject_cast<ImageEditor*>(propertyEditor);
ImageEditor *editor = qobject_cast<ImageEditor*>(propertyEditor);
editor->setImage(propertyValue().value<QImage>());
}

51
limereport/objectinspector/propertyItems/lrseriespropitem.cpp Normal file
View File

@ -0,0 +1,51 @@
#include "lrseriespropitem.h"
#include <QToolButton>
#include <lrchartitemeditor.h>
#include <lrpagedesignintf.h>
#include <lrreportengine_p.h>
namespace{
LimeReport::ObjectPropItem * createSeriesPropItem(
QObject *object, LimeReport::ObjectPropItem::ObjectsList* objects, const QString& name, const QString& displayName, const QVariant& data, LimeReport::ObjectPropItem* parent, bool readonly)
{
return new LimeReport::SeriesPropItem(object, objects, name, displayName, data, parent, readonly);
}
bool VARIABLE_IS_NOT_USED registredSeriesProp = LimeReport::ObjectPropFactory::instance().registerCreator(LimeReport::APropIdent("series", "LimeReport::ChartItem"), QObject::tr("series"), createSeriesPropItem);
}
namespace LimeReport {
QWidget *SeriesPropItem::createProperyEditor(QWidget *parent) const
{
return new SeriesPropEditor(qobject_cast<ChartItem*>(object()), parent);
}
QString SeriesPropItem::displayValue() const
{
return QObject::tr("Series");
}
SeriesPropEditor::SeriesPropEditor(ChartItem *chart, QWidget *parent)
: QWidget(parent), m_button(new QPushButton(this)), m_chart(chart)
{
m_button->setText("...");
QHBoxLayout* layout = new QHBoxLayout(this);
layout->addWidget(m_button);
layout->setSpacing(1);
layout->setContentsMargins(1,0,1,1);
setLayout(layout);
setFocusProxy(m_button);
setAutoFillBackground(true);
connect(m_button,SIGNAL(clicked()),this,SLOT(slotButtonClicked()));
}
void SeriesPropEditor::slotButtonClicked()
{
m_chart->showEditorDialog();
emit editingFinished();
}
}

41
limereport/objectinspector/propertyItems/lrseriespropitem.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef SERIESPROPITEM_H
#define SERIESPROPITEM_H
#include <QPushButton>
#include <QHBoxLayout>
#include <lrobjectpropitem.h>
#include <lrchartitem.h>
namespace LimeReport {
class SeriesPropEditor : public QWidget
{
Q_OBJECT
public:
SeriesPropEditor(ChartItem* chart, QWidget *parent = 0);
signals:
void editingFinished();
private slots:
void slotButtonClicked();
private:
QPushButton* m_button;
ChartItem* m_chart;
};
class SeriesPropItem : public LimeReport::ObjectPropItem{
Q_OBJECT
public:
SeriesPropItem():ObjectPropItem(){}
SeriesPropItem(QObject* object, ObjectsList* objects, const QString& name, const QString& displayName, const QVariant& value, ObjectPropItem* parent, bool readonly)
:ObjectPropItem(object, objects, name, displayName, value, parent, readonly){}
QWidget* createProperyEditor(QWidget *parent) const;
QString displayValue() const;
};
} // namespace LimeReport
#endif // SERIESPROPITEM_H

2
limereport/objectinspector/propertyItems/lrstringpropitem.cpp
View File

@ -54,7 +54,7 @@ QWidget * StringPropItem::createProperyEditor(QWidget *parent) const
void StringPropItem::setPropertyEditorData(QWidget *propertyEditor, const QModelIndex &) const
{
ButtonLineEditor *editor =qobject_cast<ButtonLineEditor *>(propertyEditor);
ButtonLineEditor *editor = qobject_cast<ButtonLineEditor *>(propertyEditor);
editor->setText(propertyValue().toString());
}

BIN
translations/limereport_ru.qm
View File

Binary file not shown.

16
translations/limereport_ru.ts
View File

@ -16,7 +16,7 @@
</message>
<message>
<source>Series</source>
<translation>Ряд</translation>
<translation>Ряды данных</translation>
</message>
<message>
<source>Add</source>
@ -1952,7 +1952,7 @@ p, li { white-space: pre-wrap; }
</message>
<message>
<source>series</source>
<translation>Ряд данных</translation>
<translation>Ряды данных</translation>
</message>
<message>
<source>titleAlign</source>
@ -3225,5 +3225,17 @@ This preview is no longer valid.</source>
<source>&apos;&apos;</source>
<translation>&apos;&apos;</translation>
</message>
<message>
<source>image</source>
<translation>Изображение</translation>
</message>
<message>
<source>series</source>
<translation>Ряды данных</translation>
</message>
<message>
<source>Series</source>
<translation>Ряды данных</translation>
</message>
</context>
</TS>