From d24f813f3f2a05c112e803e4256b53535895fc98 Mon Sep 17 00:00:00 2001 From: Jedidiah Barber Date: Wed, 14 Jul 2021 11:49:10 +1200 Subject: Initial mirror commit --- src/charts/Chart.cpp | 23 +++++++ src/charts/Chart.h | 32 +++++++++ src/charts/ChartAxes.cpp | 138 ++++++++++++++++++++++++++++++++++++++ src/charts/ChartAxes.h | 51 ++++++++++++++ src/charts/ChartDataLine.cpp | 80 ++++++++++++++++++++++ src/charts/ChartDataLine.h | 37 +++++++++++ src/charts/ChartMarker.cpp | 50 ++++++++++++++ src/charts/ChartMarker.h | 36 ++++++++++ src/charts/ChartScene.cpp | 111 +++++++++++++++++++++++++++++++ src/charts/ChartScene.h | 55 +++++++++++++++ src/charts/ChartToolTip.cpp | 43 ++++++++++++ src/charts/ChartToolTip.h | 26 ++++++++ src/charts/ChartView.cpp | 12 ++++ src/charts/ChartView.h | 16 +++++ src/charts/DataPoint.h | 15 +++++ src/charts/PieChart.cpp | 28 ++++++++ src/charts/PieChart.h | 27 ++++++++ src/charts/PieChartScene.cpp | 30 +++++++++ src/charts/PieChartScene.h | 30 +++++++++ src/charts/PieLegend.cpp | 48 ++++++++++++++ src/charts/PieLegend.h | 34 ++++++++++ src/charts/PieRound.cpp | 77 +++++++++++++++++++++ src/charts/PieRound.h | 37 +++++++++++ src/charts/TimeChart.cpp | 155 +++++++++++++++++++++++++++++++++++++++++++ src/charts/TimeChart.h | 54 +++++++++++++++ 25 files changed, 1245 insertions(+) create mode 100644 src/charts/Chart.cpp create mode 100644 src/charts/Chart.h create mode 100644 src/charts/ChartAxes.cpp create mode 100644 src/charts/ChartAxes.h create mode 100644 src/charts/ChartDataLine.cpp create mode 100644 src/charts/ChartDataLine.h create mode 100644 src/charts/ChartMarker.cpp create mode 100644 src/charts/ChartMarker.h create mode 100644 src/charts/ChartScene.cpp create mode 100644 src/charts/ChartScene.h create mode 100644 src/charts/ChartToolTip.cpp create mode 100644 src/charts/ChartToolTip.h create mode 100644 src/charts/ChartView.cpp create mode 100644 src/charts/ChartView.h create mode 100644 src/charts/DataPoint.h create mode 100644 src/charts/PieChart.cpp create mode 100644 src/charts/PieChart.h create mode 100644 src/charts/PieChartScene.cpp create mode 100644 src/charts/PieChartScene.h create mode 100644 src/charts/PieLegend.cpp create mode 100644 src/charts/PieLegend.h create mode 100644 src/charts/PieRound.cpp create mode 100644 src/charts/PieRound.h create mode 100644 src/charts/TimeChart.cpp create mode 100644 src/charts/TimeChart.h (limited to 'src/charts') diff --git a/src/charts/Chart.cpp b/src/charts/Chart.cpp new file mode 100644 index 0000000..f50911a --- /dev/null +++ b/src/charts/Chart.cpp @@ -0,0 +1,23 @@ +#include "Chart.h" +#include "ChartScene.h" +#include "ChartView.h" + +Chart::Chart(): + scene(new ChartScene(this)) +{ + createChartView(); +} + +void Chart::createChartView() +{ + view = new ChartView(scene); + QVBoxLayout* mainLt = new QVBoxLayout; + mainLt->addWidget(view); + mainLt->setContentsMargins(QMargins()); + setLayout(mainLt); +} + +void Chart::setDataSet(const QList& dataSet) +{ + scene->setDataSet(dataSet, 1); +} diff --git a/src/charts/Chart.h b/src/charts/Chart.h new file mode 100644 index 0000000..a613b06 --- /dev/null +++ b/src/charts/Chart.h @@ -0,0 +1,32 @@ +#ifndef CHART_H +#define CHART_H + +#include +#include + +#include "DataPoint.h" + +class ChartView; +class ChartScene; + +class Chart: public QWidget +{ +public: + Chart(); + void setLabels(const QString& xLabel, const QString& yLabel) + { this->xLabel = xLabel; this->yLabel = yLabel; } + QString getXLabel() const { return xLabel; } + QString getYLabel() const { return yLabel; } + void setDataSet(const QList& dataSet); + +private: + void createChartView(); + +protected: + ChartScene* scene; + ChartView* view; + QString xLabel; + QString yLabel; +}; + +#endif diff --git a/src/charts/ChartAxes.cpp b/src/charts/ChartAxes.cpp new file mode 100644 index 0000000..caf8828 --- /dev/null +++ b/src/charts/ChartAxes.cpp @@ -0,0 +1,138 @@ +#include "ChartAxes.h" +#include "ChartScene.h" + +#include + +const QPointF ChartAxes::XLabelOffset(0, 5); +const QPointF ChartAxes::YLabelOffset(-10, -7); +const QFont ChartAxes::TickLabelFont("Sans Serif", 11); + +ChartAxes::ChartAxes(ChartScene* scene, int xTickInterval): + scene(scene), xTickInterval(xTickInterval) +{ +} + +void ChartAxes::paint() +{ + addAxisLines(); + addTicks(); +} + +void ChartAxes::addAxisLines() +{ + QPointF chartOrigin = scene->getChartOrigin(); + QRectF chartRect = scene->getChartRect(); + scene->addLine(QLineF(chartOrigin, chartRect.topLeft())); + scene->addLine(QLineF(chartOrigin, chartRect.bottomRight())); +} + +void ChartAxes::addTicks() +{ + addXTicks(); + addYTicks(); +} + +void ChartAxes::addXTicks() +{ + qreal tickSpacing = scene->getDataDirection() * scene->getXTickSpacing(); + QPointF pos = getTickOrigin(XTick); + for(int i = 0; i < scene->getDataSet().size(); i++) + { + addLabelledXTick(i, pos); + pos.rx() += tickSpacing; + } +} + +void ChartAxes::addLabelledXTick(int index, QPointF& pos) +{ + if(index % xTickInterval == 0) + { + addTick(pos, XTick); + DataPoint point = scene->getDataSet().at(index); + addLabel(point.label, pos, XTick); + } +} + +QPointF ChartAxes::getTickOrigin(TickOrientation orientation) const +{ + QPointF res = scene->getChartOrigin(); + if(orientation == XTick) + { + if(scene->getDataDirection() == 1) + res.rx() += ChartScene::DataSetPadding.width(); + else + res.rx() += scene->getChartRect().width(); + } + else + res.ry() -= ChartScene::DataSetPadding.height(); + return res; +} + +void ChartAxes::addTick(const QPointF& pos, TickOrientation orientation) +{ + QPointF end = pos + getTickVector(orientation); + scene->addLine(QLineF(pos, end)); +} + +QPointF ChartAxes::getTickVector(TickOrientation orientation) +{ + if(orientation == XTick) + return QPointF(0, TickLength); + else + return QPointF(-TickLength, 0); +} + +void ChartAxes::addLabel(const QString& labelText, const QPointF& pos, + TickOrientation orientation) +{ + QPointF labelOffset = getLabelOffset(orientation); + QGraphicsItem* textItem = scene->addSimpleText(labelText, TickLabelFont); + qreal xAlignOffset = getLabelXAlignOffset( + textItem->boundingRect().width(), orientation); + textItem->setPos(pos + labelOffset + QPointF(xAlignOffset, 0)); +} + +QPointF ChartAxes::getLabelOffset(TickOrientation orientation) +{ + if(orientation == XTick) + return XLabelOffset; + else + return YLabelOffset; +} + +qreal ChartAxes::getLabelXAlignOffset(qreal labelWidth, TickOrientation orientation) +{ + if(orientation == XTick) + return -labelWidth / 2; + else + return -labelWidth; +} + +void ChartAxes::addYTicks() +{ + int valueSpacing = scene->getYTickSpacing(); + qreal posSpacing = scene->getYPosFromValue(valueSpacing); + QPointF pos = getTickOrigin(YTick); + for(int value = scene->getMinY(); value <= scene->getMaxY(); + value += valueSpacing) + { + addLabelledYTick(value, pos, posSpacing); + if(valueSpacing == 0) + break; + } +} + +void ChartAxes::addLabelledYTick(int value, QPointF& pos, qreal posSpacing) +{ + addTick(pos, YTick); + addLabel(QString::number(value), pos, YTick); + addHRuler(pos); + pos.ry() -= posSpacing; +} + +void ChartAxes::addHRuler(const QPointF& pos) + { + QPointF end = pos; + end.rx() += scene->getChartRect().width(); + scene->addLine(QLineF(pos, end), QPen(Qt::lightGray)); + } diff --git a/src/charts/ChartAxes.h b/src/charts/ChartAxes.h new file mode 100644 index 0000000..ebfe4ac --- /dev/null +++ b/src/charts/ChartAxes.h @@ -0,0 +1,51 @@ +#ifndef CHART_AXES_H +#define CHART_AXES_H + +#include +#include + +class ChartScene; + +class ChartAxes +{ +public: + ChartAxes(ChartScene* scene, int xTickInterval); + void paint(); + +private: + enum TickOrientation + { + XTick, + YTick + }; + +private: + static QPointF getTickVector(TickOrientation orientation); + static QPointF getLabelOffset(TickOrientation orientation); + static qreal getLabelXAlignOffset(qreal labelWidth, TickOrientation orientation); + +private: + void addAxisLines(); + void addTicks(); + void addXTicks(); + void addYTicks(); + void addLabel(const QString& labelText, const QPointF& pos, + TickOrientation orientation); + QPointF getTickOrigin(TickOrientation orientation) const; + void addHRuler(const QPointF& pos); + void addTick(const QPointF& pos, TickOrientation orientation); + void addLabelledXTick(int index, QPointF& pos); + void addLabelledYTick(int value, QPointF& pos, qreal posSpacing); + +private: + static const int TickLength = 5; + static const QPointF XLabelOffset; + static const QPointF YLabelOffset; + static const QFont TickLabelFont; + +private: + ChartScene* scene; + int xTickInterval; +}; + +#endif diff --git a/src/charts/ChartDataLine.cpp b/src/charts/ChartDataLine.cpp new file mode 100644 index 0000000..17919cd --- /dev/null +++ b/src/charts/ChartDataLine.cpp @@ -0,0 +1,80 @@ +#include "ChartDataLine.h" +#include "ChartScene.h" +#include "ChartMarker.h" + +const QColor ChartDataLine::MarkerColor(Qt::blue); +const QColor ChartDataLine::FillColor(0, 0, 255, 128); + +ChartDataLine::ChartDataLine(ChartScene* scene): + scene(scene), + origin(getDataSetOrigin()), + xSpacing(scene->getXTickSpacing()) +{ +} + +QPointF ChartDataLine::getDataSetOrigin() const +{ + QSizeF padding = scene->DataSetPadding; + QPointF res = scene->getChartOrigin(); + res.ry() -= padding.height(); + if(scene->getDataDirection() == 1) + res.rx() += padding.width(); + else + res.rx() += scene->getChartRect().width(); + return res; +} + +void ChartDataLine::paint() +{ + QPainterPath linePath = createLinePath(); + addLinePath(linePath); + addAreaPath(linePath); +} + +QPainterPath ChartDataLine::createLinePath() +{ + QList dataSet = scene->getDataSet(); + QPointF firstPoint = getDataPos(0, dataSet.first().value); + QPainterPath linePath(firstPoint); + for (int i = 0; i < dataSet.size(); i++) + addLineSegment(linePath, i); + return linePath; +} + +void ChartDataLine::addLineSegment(QPainterPath& path, int i) +{ + DataPoint dataPoint = scene->getDataSet().at(i); + QPointF pos = getDataPos(i, dataPoint.value); + QString toolTipText = createToolTipText(dataPoint); + scene->addItem(new ChartMarker(pos, toolTipText)); + path.lineTo(pos); +} + +QPointF ChartDataLine::getDataPos(int index, int yValue) +{ + qreal xPos = scene->getDataDirection() * index * xSpacing; + qreal yPos = scene->getYPosFromValue(yValue - scene->getMinY()); + return origin + QPointF(xPos, -yPos); +} + +QString ChartDataLine::createToolTipText(const DataPoint& dataPoint) const +{ + return scene->getXLabel() + ": " + dataPoint.toolTipLabel + "
" + + scene->getYLabel() + ": " + QString::number(dataPoint.value) + ""; +} + +void ChartDataLine::addLinePath(const QPainterPath& path) +{ + QPen pen(MarkerColor); + pen.setWidth(2); + scene->addPath(path, pen); +} + +void ChartDataLine::addAreaPath(const QPainterPath& linePath) +{ + QPainterPath areaPath(origin); + areaPath.lineTo(QPointF(linePath.elementAt(0))); + areaPath.connectPath(linePath); + areaPath.lineTo(QPointF(linePath.currentPosition().x(), origin.y())); + scene->addPath(areaPath, QPen(FillColor), QBrush(FillColor)); +} diff --git a/src/charts/ChartDataLine.h b/src/charts/ChartDataLine.h new file mode 100644 index 0000000..c90ccb4 --- /dev/null +++ b/src/charts/ChartDataLine.h @@ -0,0 +1,37 @@ +#ifndef CHART_DATA_SET_H +#define CHART_DATA_SET_H + +#include +#include + +#include "DataPoint.h" + +class ChartScene; + +class ChartDataLine +{ +public: + ChartDataLine(ChartScene* scene); + void paint(); + +private: + QPointF getDataSetOrigin() const; + QPainterPath createLinePath(); + QPointF getDataPos(int index, int yValue); + void addLinePath(const QPainterPath& path); + void addLineSegment(QPainterPath& path, int i); + void addAreaPath(const QPainterPath& linePath); + QString createToolTipText(const DataPoint& dataPoint) const; + +private: + static const int MarkerRadius = 2; + static const QColor MarkerColor; + static const QColor FillColor; + +private: + ChartScene* scene; + QPointF origin; + qreal xSpacing; +}; + +#endif diff --git a/src/charts/ChartMarker.cpp b/src/charts/ChartMarker.cpp new file mode 100644 index 0000000..7fdd8cd --- /dev/null +++ b/src/charts/ChartMarker.cpp @@ -0,0 +1,50 @@ +#include "ChartMarker.h" +#include "ChartToolTip.h" + +const QPointF ChartMarker::ToolTipOffset(45, -35); +const QColor ChartMarker::Color(Qt::blue); + +ChartMarker::ChartMarker(const QPointF& center, const QString& toolTipText): + radius(Radius), toolTip(NULL), toolTipText(toolTipText) +{ + setPos(center); + setRect(QRectF(-HoverRadius, -HoverRadius, + 2 * HoverRadius, 2 * HoverRadius)); + setAcceptHoverEvents(true); +} + +ChartMarker::~ChartMarker() +{ + delete toolTip; +} + +void ChartMarker::hoverEnterEvent(QGraphicsSceneHoverEvent*) +{ + radius = HighlightedRadius; + update(); + if(!toolTip) + createToolTip(); + toolTip->show(); +} + +void ChartMarker::createToolTip() +{ + toolTip = new ChartToolTip(mapToScene(ToolTipOffset), toolTipText); + scene()->addItem(toolTip); + toolTip->adjustPos(); +} + +void ChartMarker::hoverLeaveEvent(QGraphicsSceneHoverEvent*) +{ + radius = Radius; + update(); + toolTip->hide(); +} + +void ChartMarker::paint(QPainter* painter, const QStyleOptionGraphicsItem*, + QWidget*) +{ + painter->setPen(Color); + painter->setBrush(Color); + painter->drawEllipse(QPointF(), radius, radius); +} diff --git a/src/charts/ChartMarker.h b/src/charts/ChartMarker.h new file mode 100644 index 0000000..1f3d81e --- /dev/null +++ b/src/charts/ChartMarker.h @@ -0,0 +1,36 @@ +#ifndef CHART_MARKER_H +#define CHART_MARKER_H + +#include + +class ChartToolTip; + +class ChartMarker: public QGraphicsEllipseItem +{ +public: + ChartMarker(const QPointF& center, const QString& toolTipText); + ~ChartMarker(); + void paint(QPainter* painter, + const QStyleOptionGraphicsItem* option, QWidget* widget = 0); + +protected: + void hoverEnterEvent(QGraphicsSceneHoverEvent* event); + void hoverLeaveEvent(QGraphicsSceneHoverEvent* event); + +private: + void createToolTip(); + +private: + static const QColor Color; + static const int HoverRadius = 15; + static const int Radius = 2; + static const int HighlightedRadius = 4; + static const QPointF ToolTipOffset; + +private: + int radius; + ChartToolTip* toolTip; + QString toolTipText; +}; + +#endif diff --git a/src/charts/ChartScene.cpp b/src/charts/ChartScene.cpp new file mode 100644 index 0000000..559ecc5 --- /dev/null +++ b/src/charts/ChartScene.cpp @@ -0,0 +1,111 @@ +#include "ChartScene.h" +#include "ChartAxes.h" +#include +#include +#include "ChartDataLine.h" + +const QSizeF ChartScene::Margin(30, 20); +const QSizeF ChartScene::Padding(20, 20); +const QSizeF ChartScene::DataSetPadding(10, 10); + +ChartScene::ChartScene(Chart* chart): + QGraphicsScene(chart), chart(chart), dataDirection(1) +{ + setSceneRect(0, 0, 600, 300); +} + +void ChartScene::setDataSet(const QList& dataSet, int xTickInterval) +{ + clear(); + this->dataSet = dataSet; + initYScale(); + ChartAxes(this, xTickInterval).paint(); + ChartDataLine(this).paint(); +} + +void ChartScene::initYScale() +{ + yMin = computeMinY(); + yMax = computeMaxY(); + yTickSpacing = computeYTickSpacing(); + extendYMinMax(); + yScale = getDataSetSize().height() / getYDiff(); +} + +int ChartScene::computeMinY() const +{ + int min = 1000000; + foreach(DataPoint point, dataSet) + if(point.value < min) + min = point.value; + return min; +} + +int ChartScene::computeMaxY() const +{ + int max = -1000000; + foreach(DataPoint point, dataSet) + if(point.value > max) + max = point.value; + return max; +} + +int ChartScene::computeYTickSpacing() const +{ + const int higherZonesLimit = 4; + const int lowerZonesLimit = 3; + + double order = floor(log10(getYDiff())); + double base = pow(10, order); + double zonesNum = ceil(getYDiff() / base); + if(zonesNum > higherZonesLimit) + base *= 2; + else if(zonesNum < lowerZonesLimit) + base /= 2; + int res = (int)base; + if(res == 0) + res = 10; + return res; +} + +void ChartScene::extendYMinMax() +{ + yMin = int(floor(yMin / double(yTickSpacing))) * yTickSpacing; + yMax = int(ceil(yMax / double(yTickSpacing))) * yTickSpacing; + if (yMax == yMin) + yMax = yMin + yTickSpacing; +} + +QSizeF ChartScene::getBorder() +{ + return Margin + Padding; +} + +QRectF ChartScene::getChartRect() const +{ + QSizeF border = getBorder(); + return sceneRect().adjusted(border.width(), border.height(), + -border.width(), -border.height()); +} + +QPointF ChartScene::getChartOrigin() const +{ + QRectF chartRect = getChartRect(); + return QPointF(chartRect.left(), chartRect.bottom()); +} + +QSizeF ChartScene::getDataSetSize() const +{ + QSizeF dataSetBorder(2 * getBorder() + DataSetPadding); + return sceneRect().size() - dataSetBorder; +} + +qreal ChartScene::getXTickSpacing() const +{ + return getDataSetSize().width() / (dataSet.size() - 1); +} + +qreal ChartScene::getYPosFromValue(int value) const +{ + return yScale * value; +} diff --git a/src/charts/ChartScene.h b/src/charts/ChartScene.h new file mode 100644 index 0000000..3a9af62 --- /dev/null +++ b/src/charts/ChartScene.h @@ -0,0 +1,55 @@ +#ifndef CHART_SCENE_H +#define CHART_SCENE_H + +#include +#include + +#include "Chart.h" +#include "DataPoint.h" + +class ChartScene: public QGraphicsScene +{ +public: + static const QSizeF Margin; + static const QSizeF Padding; + static const QSizeF DataSetPadding; + +public: + static QSizeF getBorder(); + +public: + ChartScene(Chart* chart); + void setDataSet(const QList& dataSet, int xTickInterval); + void setDataDirection(int direction) { dataDirection = direction; } + QString getXLabel() const { return chart->getXLabel(); } + QString getYLabel() const { return chart->getYLabel(); } + int getDataDirection() const { return dataDirection; } + QPointF getChartOrigin() const; + QRectF getChartRect() const; + QSizeF getDataSetSize() const; + QList getDataSet() const {return dataSet; } + qreal getXTickSpacing() const; + qreal getYPosFromValue(int value) const; + int getMinY() const { return yMin; } + int getMaxY() const { return yMax; } + int getYDiff() const { return yMax - yMin; } + int getYTickSpacing() const { return yTickSpacing; } + +private: + void initYScale(); + int computeMinY() const; + int computeMaxY() const; + int computeYTickSpacing() const; + void extendYMinMax(); + +private: + Chart* chart; + QList dataSet; + int yMin; + int yMax; + qreal yScale; + int yTickSpacing; + int dataDirection; +}; + +#endif diff --git a/src/charts/ChartToolTip.cpp b/src/charts/ChartToolTip.cpp new file mode 100644 index 0000000..15783ea --- /dev/null +++ b/src/charts/ChartToolTip.cpp @@ -0,0 +1,43 @@ +#include "ChartToolTip.h" + +const QFont ChartToolTip::Font("Sans Serif", 11); + +ChartToolTip::ChartToolTip(const QPointF& pos, const QString& text): + text(text) +{ + setPos(pos); + document.setDefaultFont(Font); + document.setHtml(text); + QSizeF docSize = document.size(); + setRect(QRectF(QPointF(-docSize.width() / 2, -docSize.height() / 2), docSize)); +} + +void ChartToolTip::paint(QPainter* painter, const QStyleOptionGraphicsItem*, + QWidget*) +{ + drawFrame(painter); + drawText(painter); +} + +void ChartToolTip::drawFrame(QPainter* painter) +{ + painter->setPen(QPen(Qt::black)); + painter->setBrush(QBrush(Qt::white)); + painter->drawRect(rect()); +} + +void ChartToolTip::drawText(QPainter* painter) +{ + painter->translate(rect().topLeft()); + document.drawContents(painter); +} + +void ChartToolTip::adjustPos() +{ + QRectF toolTipRect = mapRectToScene(boundingRect()); + QRectF sceneRect = scene()->sceneRect(); + if(toolTipRect.right() >= sceneRect.right()) + moveBy(-(toolTipRect.right() - sceneRect.right()) - 1, 0); + if(toolTipRect.top() <= sceneRect.top()) + moveBy(0, sceneRect.top() - toolTipRect.top() + 1); +} diff --git a/src/charts/ChartToolTip.h b/src/charts/ChartToolTip.h new file mode 100644 index 0000000..88453a8 --- /dev/null +++ b/src/charts/ChartToolTip.h @@ -0,0 +1,26 @@ +#ifndef CHART_TOOL_TIP_H +#define CHART_TOOL_TIP_H + +#include + +class ChartToolTip: public QGraphicsRectItem +{ +public: + ChartToolTip(const QPointF& pos, const QString& text); + void paint(QPainter* painter, + const QStyleOptionGraphicsItem* option, QWidget* widget = 0); + void adjustPos(); + +private: + void drawFrame(QPainter* painter); + void drawText(QPainter* painter); + +private: + static const QFont Font; + +private: + QString text; + QTextDocument document; +}; + +#endif diff --git a/src/charts/ChartView.cpp b/src/charts/ChartView.cpp new file mode 100644 index 0000000..24a08c5 --- /dev/null +++ b/src/charts/ChartView.cpp @@ -0,0 +1,12 @@ +#include "ChartView.h" + +ChartView::ChartView(QGraphicsScene* scene): + QGraphicsView(scene) +{ + setRenderHints(QPainter::Antialiasing); +} + +void ChartView::resizeEvent(QResizeEvent*) +{ + fitInView(scene()->sceneRect(), Qt::KeepAspectRatio); +} diff --git a/src/charts/ChartView.h b/src/charts/ChartView.h new file mode 100644 index 0000000..fcd071c --- /dev/null +++ b/src/charts/ChartView.h @@ -0,0 +1,16 @@ +#ifndef CHART_VIEW_H +#define CHART_VIEW_H + +#include +#include + +class ChartView: public QGraphicsView +{ +public: + ChartView(QGraphicsScene* scene); + +protected: + void resizeEvent(QResizeEvent* event); +}; + +#endif diff --git a/src/charts/DataPoint.h b/src/charts/DataPoint.h new file mode 100644 index 0000000..394d1be --- /dev/null +++ b/src/charts/DataPoint.h @@ -0,0 +1,15 @@ +#ifndef DATAPOINT_H +#define DATAPOINT_H + +struct DataPoint +{ +public: + DataPoint(const QString& label, int value, QString toolTipLabel = ""): + label(label), value(value), toolTipLabel(toolTipLabel) {} + + QString label; + int value; + QString toolTipLabel; +}; + +#endif diff --git a/src/charts/PieChart.cpp b/src/charts/PieChart.cpp new file mode 100644 index 0000000..0637823 --- /dev/null +++ b/src/charts/PieChart.cpp @@ -0,0 +1,28 @@ +#include "PieChart.h" +#include "PieChartScene.h" +#include "ChartView.h" + +PieChart::PieChart(): + scene(new PieChartScene(this)) +{ + createChartView(); +} + +void PieChart::createChartView() +{ + view = new ChartView(scene); + QVBoxLayout* mainLt = new QVBoxLayout; + mainLt->addWidget(view); + mainLt->setContentsMargins(QMargins()); + setLayout(mainLt); +} + +void PieChart::setDataSet(const QList& dataSet) +{ + scene->setDataSet(dataSet); +} + +void PieChart::setColors(const QStringList& colors) +{ + scene->setColors(colors); +} diff --git a/src/charts/PieChart.h b/src/charts/PieChart.h new file mode 100644 index 0000000..8e60833 --- /dev/null +++ b/src/charts/PieChart.h @@ -0,0 +1,27 @@ +#ifndef PIE_CHART_H +#define PIE_CHART_H + +#include +#include + +#include "DataPoint.h" + +class ChartView; +class PieChartScene; + +class PieChart: public QWidget +{ +public: + PieChart(); + void setDataSet(const QList& dataSet); + void setColors(const QStringList& colors); + +private: + void createChartView(); + +protected: + PieChartScene* scene; + ChartView* view; +}; + +#endif diff --git a/src/charts/PieChartScene.cpp b/src/charts/PieChartScene.cpp new file mode 100644 index 0000000..135a0e4 --- /dev/null +++ b/src/charts/PieChartScene.cpp @@ -0,0 +1,30 @@ +#include +#include +#include "PieChartScene.h" +#include "PieRound.h" +#include "PieLegend.h" + +const QSizeF PieChartScene::Margin(20, 20); +const QSizeF PieChartScene::Size(500, 230); + +PieChartScene::PieChartScene(PieChart* chart): + QGraphicsScene(chart), chart(chart) +{ + setSceneRect(0, 0, Size.width(), Size.height()); +} + +void PieChartScene::setDataSet(const QList& dataSet) +{ + clear(); + this->dataSet = dataSet; + int centerPos = PieRound::Margin + PieRound::Radius; + QPointF roundPos(QPointF(Margin.width(), Margin.height()) + + QPointF(centerPos, centerPos)); + addItem(new PieRound(roundPos, this)); + addItem(new PieLegend(roundPos + QPointF(LegendDistance, 0), this)); +} + +void PieChartScene::setColors(const QStringList& colors) +{ + this->colors = colors; +} diff --git a/src/charts/PieChartScene.h b/src/charts/PieChartScene.h new file mode 100644 index 0000000..4ab8129 --- /dev/null +++ b/src/charts/PieChartScene.h @@ -0,0 +1,30 @@ +#ifndef PIE_CHART_SCENE_H +#define PIE_CHART_SCENE_H + +#include +#include + +#include "DataPoint.h" +#include "PieChart.h" + +class PieChartScene: public QGraphicsScene +{ +public: + static const QSizeF Margin; + static const QSizeF Size; + static const int LegendDistance = 230; + +public: + PieChartScene(PieChart* chart); + void setDataSet(const QList& dataSet); + void setColors(const QStringList& colors); + QList getDataSet() const {return dataSet; } + QStringList getColors() const { return colors; } + +private: + PieChart* chart; + QList dataSet; + QStringList colors; +}; + +#endif diff --git a/src/charts/PieLegend.cpp b/src/charts/PieLegend.cpp new file mode 100644 index 0000000..5faabf4 --- /dev/null +++ b/src/charts/PieLegend.cpp @@ -0,0 +1,48 @@ +#include "PieLegend.h" +#include "PieChartScene.h" + +PieLegend::PieLegend(const QPointF& pos, const PieChartScene* scene): + scene(scene) +{ + setPos(pos); + addLabels(); +} + +QRectF PieLegend::boundingRect() const +{ + return QRectF(-Width / 2, -Width / 2, Width, Width); +} + +void PieLegend::addLabels() +{ + for(int i = 0; i < scene->getDataSet().size(); i++) + addLabel(i, getLabelPos(i)); +} + +QPointF PieLegend::getLabelPos(int index) const +{ + return boundingRect().topLeft() + + QPointF(SquareSide / 2, SquareSide / 2) + + index * QPointF(0, SquareSide + LabelSpacing); +} + +void PieLegend::addLabel(int index, const QPointF& pos) +{ + QRectF squareRect(-SquareSide / 2., -SquareSide / 2., + SquareSide, SquareSide); + QGraphicsRectItem* squareItem = new QGraphicsRectItem(squareRect, this); + squareItem->setBrush(QColor(scene->getColors()[index])); + squareItem->setPos(pos); + + QGraphicsSimpleTextItem* textItem = + new QGraphicsSimpleTextItem(scene->getDataSet()[index].label, this); + textItem->setPos(getTextPos(pos, textItem)); +} + +QPointF PieLegend::getTextPos(const QPointF& squarePos, + const QGraphicsSimpleTextItem* textItem) const +{ + return squarePos + + QPointF(SquareSide / 2. + LabelTextSpacing, + -textItem->boundingRect().height() / 2); +} diff --git a/src/charts/PieLegend.h b/src/charts/PieLegend.h new file mode 100644 index 0000000..d8e83e5 --- /dev/null +++ b/src/charts/PieLegend.h @@ -0,0 +1,34 @@ +#ifndef PIE_LEGEND_H +#define PIE_LEGEND_H + +#include + +#include "DataPoint.h" + +class PieChartScene; + +class PieLegend: public QGraphicsItem +{ +public: + static const int Width = 150; + static const int SquareSide = 20; + static const int LabelSpacing = 10; + static const int LabelTextSpacing = 10; + +public: + PieLegend(const QPointF& pos, const PieChartScene* scene); + QRectF boundingRect() const; + void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget* = 0) {} + +private: + void addLabels(); + QPointF getLabelPos(int index) const; + void addLabel(int index, const QPointF& pos); + QPointF getTextPos(const QPointF& squarePos, + const QGraphicsSimpleTextItem* textItem) const; + +private: + const PieChartScene* scene; +}; + +#endif diff --git a/src/charts/PieRound.cpp b/src/charts/PieRound.cpp new file mode 100644 index 0000000..f90d740 --- /dev/null +++ b/src/charts/PieRound.cpp @@ -0,0 +1,77 @@ +#include "PieRound.h" +#include "PieChartScene.h" + +PieRound::PieRound(const QPointF& center, const PieChartScene* scene): + scene(scene) +{ + setPos(center); + calculateSum(); + addSectors(); +} + +QRectF PieRound::boundingRect() const +{ + return QRectF(-Radius, -Radius, 2 * Radius, 2 * Radius); +} + +void PieRound::calculateSum() +{ + sum = 0; + foreach(DataPoint point, scene->getDataSet()) + sum += point.value; +} + +void PieRound::addSectors() +{ + qreal angle = -90; + for(int i = 0; i < scene->getDataSet().size(); i++) + { + qreal sweep = 360. * scene->getDataSet()[i].value / sum; + addSector(i, angle, sweep); + angle += sweep; + } +} + +void PieRound::addSector(int index, qreal startAngle, qreal sweep) +{ + addSectorItem(createSectorPath(startAngle, sweep), + QColor(scene->getColors()[index])); + addSectorLabel(index, startAngle, sweep); +} + +QPainterPath PieRound::createSectorPath(qreal startAngle, qreal sweep) +{ + QPainterPath sectorPath; + sectorPath.arcTo(boundingRect(), -startAngle, -sweep); + sectorPath.lineTo(QPointF()); + return sectorPath; +} + +void PieRound::addSectorItem(const QPainterPath& path, QColor color) +{ + QGraphicsPathItem* sectorItem = new QGraphicsPathItem(path, this); + sectorItem->setPen(QColor("white")); + sectorItem->setBrush(color); +} + +void PieRound::addSectorLabel(int index, qreal startAngle, qreal sweep) +{ + int value = scene->getDataSet()[index].value; + if(value == 0) + return; + QGraphicsSimpleTextItem* labelItem = + new QGraphicsSimpleTextItem(QString::number(value), this); + labelItem->setPos(getLabelPos(startAngle, sweep, labelItem)); +} + +QPointF PieRound::getLabelPos(qreal startAngle, qreal sweep, + QGraphicsSimpleTextItem* labelItem) +{ + int radius = sweep > 30 ? LabelRadius : 2 * LabelRadius; + QRectF labelArcRect(-radius, -radius, 2 * radius, 2 * radius); + QPainterPath path; + path.arcMoveTo(labelArcRect, -startAngle - sweep / 2); + QSizeF labelSize = labelItem->boundingRect().size(); + return path.currentPosition() - + QPointF(labelSize.width() / 2, labelSize.height() / 2); +} diff --git a/src/charts/PieRound.h b/src/charts/PieRound.h new file mode 100644 index 0000000..1963f26 --- /dev/null +++ b/src/charts/PieRound.h @@ -0,0 +1,37 @@ +#ifndef PIE_ROUND_H +#define PIE_ROUND_H + +#include + +#include "DataPoint.h" + +class PieChartScene; + +class PieRound: public QGraphicsItem +{ +public: + static const int Margin = 20; + static const int Radius = 80; + static const int LabelRadius = 50; + +public: + PieRound(const QPointF& center, const PieChartScene* scene); + QRectF boundingRect() const; + void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget* = 0) {} + +private: + void calculateSum(); + void addSectors(); + void addSector(int index, qreal startAngle, qreal sweep); + QPainterPath createSectorPath(qreal startAngle, qreal sweep); + void addSectorItem(const QPainterPath& path, QColor color); + void addSectorLabel(int index, qreal startAngle, qreal sweep); + QPointF getLabelPos(qreal startAngle, qreal sweep, + QGraphicsSimpleTextItem* labelItem); + +private: + int sum; + const PieChartScene* scene; +}; + +#endif diff --git a/src/charts/TimeChart.cpp b/src/charts/TimeChart.cpp new file mode 100644 index 0000000..c6a60b9 --- /dev/null +++ b/src/charts/TimeChart.cpp @@ -0,0 +1,155 @@ +#include "TimeChart.h" +#include "ChartScene.h" +#include "DataPoint.h" + +const QList TimeChart::TimeUnits = QList() << + 1 << 7 << 30 << 92 << 183; + +TimeChart::TimeChart() +{ +} + +void TimeChart::setDates(const QList& dates, int period, + int dataDirection) +{ + this->dates = dates; + scene->setDataDirection(dataDirection); + TimeUnit timeUnit = findTimeUnit(period); + QDate thisIntervalStart = getIntervalStart(QDate::currentDate(), timeUnit); + QList dataSet; + int pointsNum = getDataPointsNum(period, timeUnit); + for(int i = 0; i < pointsNum; i++) + dataSet.append(createDataPoint(thisIntervalStart, timeUnit, i)); + scene->setDataSet(dataSet, getTicksInterval(pointsNum)); +} + +int TimeChart::getDataPointsNum(int period, TimeUnit timeUnit) +{ + return period / TimeUnits.at(timeUnit); +} + +int TimeChart::getTicksInterval(int pointsNum) +{ + int ticksInterval = 1; + while(pointsNum / ticksInterval > MaxXTicks) + ticksInterval *= 2; + return ticksInterval; +} + +TimeChart::TimeUnit TimeChart::findTimeUnit(int period) +{ + for(int unit = Day; unit < (int)TimeUnitsNum; unit++) + if(getDataPointsNum(period, (TimeUnit)unit) <= MaxDataPoints) + return (TimeUnit)unit; + return HalfYear; +} + +QDate TimeChart::getIntervalStart(const QDate& date, TimeUnit timeUnit) +{ + switch(timeUnit) + { + case Day: + return date; + case Week: + return date.addDays(-date.dayOfWeek() + 1); + case Month: + return QDate(date.year(), date.month(), 1); + case Quarter: + return getQuarterStart(date); + case HalfYear: + return getHalfYearStart(date); + default: + return date; + } +} + +QDate TimeChart::getQuarterStart(const QDate& date) +{ + const int quarterLen = 3; + int quarter = (date.month() - 1) / quarterLen; + int startMonth = quarter * quarterLen + 1; + return QDate(date.year(), startMonth, 1); +} + +QDate TimeChart::getHalfYearStart(const QDate& date) +{ + const int secondHalfStart = 7; + int startMonth = date.month() < secondHalfStart ? 1 : secondHalfStart; + return QDate(date.year(), startMonth, 1); +} + +QDate TimeChart::getInterval(const QDate& start, TimeUnit timeUnit, + int num) +{ + switch(timeUnit) + { + case Day: + return start.addDays(num); + case Week: + return start.addDays(7 * num); + case Month: + return start.addMonths(num); + case Quarter: + return start.addMonths(3 * num); + case HalfYear: + return start.addMonths(6 * num); + default: + return start; + } +} + +QDate TimeChart::getIntervalEnd(const QDate& start, TimeUnit timeUnit) +{ + return getInterval(start, timeUnit, 1).addDays(-1); +} + +DataPoint TimeChart::createDataPoint(const QDate& thisIntervalStart, TimeUnit timeUnit, + int intervalIndex) +{ + QDate startDate = getInterval(thisIntervalStart, timeUnit, + scene->getDataDirection() * intervalIndex); + QDate endDate = getIntervalEnd(startDate, timeUnit); + QString xLabel = getDateLabel(startDate, timeUnit); + int value = getCardsNumForDate(startDate, endDate); + QString toolTipLabel = getIntervalLabel(startDate, endDate, timeUnit); + return DataPoint(xLabel, value, toolTipLabel); +} + +QString TimeChart::getDateLabel(const QDate& date, TimeUnit timeUnit) +{ + return date.toString(getIntervalFormat(timeUnit)); +} + +QString TimeChart::getIntervalFormat(TimeUnit timeUnit) +{ + switch(timeUnit) + { + case Day: + case Week: + return "dd.MM"; + case Month: + case Quarter: + case HalfYear: + return "MM/yy"; + default: + return "dd.MM"; + } +} + +QString TimeChart::getIntervalLabel(const QDate& startDate, + const QDate& endDate, TimeUnit timeUnit) +{ + QString startLabel = getDateLabel(startDate, timeUnit); + if(timeUnit == Day || timeUnit == Month) + return startLabel; + return startLabel + " - " + getDateLabel(endDate, timeUnit); +} + +int TimeChart::getCardsNumForDate(const QDate& startDate, const QDate& endDate) +{ + int cardsNum = 0; + foreach(QDateTime date, dates) + if(date.date() >= startDate && date.date() <= endDate) + cardsNum++; + return cardsNum; +} diff --git a/src/charts/TimeChart.h b/src/charts/TimeChart.h new file mode 100644 index 0000000..1d9f92d --- /dev/null +++ b/src/charts/TimeChart.h @@ -0,0 +1,54 @@ +#ifndef TIME_CHART_H +#define TIME_CHART_H + +#include + +#include "Chart.h" + +class TimeChart: public Chart +{ +enum TimeUnit +{ + Day = 0, + Week, + Month, + Quarter, + HalfYear, + TimeUnitsNum +}; + +public: + TimeChart(); + void setDates(const QList& dates, int period, + int dataDirection = 1); + +private: + static TimeUnit findTimeUnit(int period); + static QDate getIntervalStart(const QDate& date, TimeUnit timeUnit); + static QDate getInterval(const QDate& start, TimeUnit timeUnit, + int num); + static QDate getIntervalEnd(const QDate& start, TimeUnit timeUnit); + static QString getDateLabel(const QDate& date, TimeUnit timeUnit); + static QString getIntervalFormat(TimeUnit timeUnit); + static QString getIntervalLabel(const QDate& startDate, + const QDate& endDate, TimeUnit timeUnit); + static QDate getQuarterStart(const QDate& date); + static QDate getHalfYearStart(const QDate& date); + static int getDataPointsNum(int period, TimeUnit timeUnit); + static int getTicksInterval(int pointsNum); + +private: + DataPoint createDataPoint(const QDate& thisIntervalStart, TimeUnit timeUnit, + int intervalIndex); + int getCardsNumForDate(const QDate& startDate, const QDate& endDate); + +private: + static const QList TimeUnits; + static const int MaxDataPoints = 28; + static const int MaxXTicks = 12; + +private: + QList dates; +}; + +#endif -- cgit