##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » USERS » JEANDET » qtcharts
RSS

Clone from http://code.qt.io/qt/qtcharts.git

Renames Grid to GridLine
Michal Klocek -
r535:774f7e43278b
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,78 +1,78
1 1 #include <QApplication>
2 2 #include <QMainWindow>
3 3 #include <qchartview.h>
4 4 #include <qlineseries.h>
5 5 #include <qchart.h>
6 6 #include <qchartaxis.h>
7 7 #include <qchartaxiscategories.h>
8 8 #include <cmath>
9 9
10 10 QTCOMMERCIALCHART_USE_NAMESPACE
11 11
12 12 #define PI 3.14159265358979
13 13
14 14 int main(int argc, char *argv[])
15 15 {
16 16 QApplication a(argc, argv);
17 17
18 18 QMainWindow window;
19 19
20 20 QLineSeries* series0 = new QLineSeries();
21 21 QPen blue(Qt::blue);
22 22 blue.setWidth(3);
23 23 series0->setPen(blue);
24 24 QLineSeries* series1 = new QLineSeries();
25 25 QPen red(Qt::red);
26 26 red.setWidth(3);
27 27 series1->setPen(red);
28 28
29 29 int numPoints = 100;
30 30
31 31 for (int x = 0; x <= numPoints; ++x) {
32 32 series0->add(x, fabs(sin(PI/50*x)*100));
33 33 series1->add(x, fabs(cos(PI/50*x)*100));
34 34 }
35 35
36 36 QChartView* chartView = new QChartView(&window);
37 37
38 38 chartView->setRenderHint(QPainter::Antialiasing);
39 39 chartView->setChartTitle("This is custom axis chart example");
40 40 chartView->addSeries(series0);
41 41 chartView->addSeries(series1);
42 42
43 43 QLinearGradient backgroundGradient;
44 44 backgroundGradient.setColorAt(0.0, Qt::white);
45 45 backgroundGradient.setColorAt(1.0, QRgb(0xffff80));
46 46 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
47 47 chartView->setChartBackgroundBrush(backgroundGradient);
48 48
49 49 QChartAxis* axisX = chartView->axisX();
50 50 axisX->setLabelsAngle(45);
51 axisX->setGridPen(Qt::DashLine);
51 axisX->setGridLinePen(Qt::DashLine);
52 52
53 53 QChartAxisCategories* categoriesX = axisX->categories();
54 54 categoriesX->insert(0,"low");
55 55 categoriesX->insert(50,"medium");
56 56 categoriesX->insert(100,"High");
57 57
58 58 axisX->setMin(-10);
59 59 axisX->setMax(2200);
60 60
61 61 QChartAxis* axisY = chartView->axisY();
62 62 axisY->setLabelsAngle(45);
63 63 axisY->setShadesBrush(Qt::yellow);
64 64
65 65 QChartAxisCategories* categoriesY = axisY->categories();
66 66 categoriesY->insert(0,"low");
67 67 categoriesY->insert(50,"medium");
68 68 categoriesY->insert(100,"High");
69 69
70 70 axisY->setMin(-10);
71 71 axisY->setMax(200);
72 72
73 73 window.setCentralWidget(chartView);
74 74 window.resize(400, 300);
75 75 window.show();
76 76
77 77 return a.exec();
78 78 }
Show file before | Show file after | Hide comments
@@ -1,81 +1,81
1 1 #include <QApplication>
2 2 #include <QMainWindow>
3 3 #include <qchartview.h>
4 4 #include <qbarseries.h>
5 5 #include <qbarset.h>
6 6 #include <qchartaxis.h>
7 7 #include <QStringList>
8 8
9 9 QTCOMMERCIALCHART_USE_NAMESPACE
10 10
11 11 int main(int argc, char *argv[])
12 12 {
13 13 QApplication a(argc, argv);
14 14 QMainWindow window;
15 15
16 16 //! [1]
17 17 // Define categories
18 18 QStringList categories;
19 19 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
20 20 //! [1]
21 21
22 22 //! [2]
23 23 // Create some test sets for chat
24 24
25 25 QBarSet *set0 = new QBarSet("Bub");
26 26 QBarSet *set1 = new QBarSet("Bob");
27 27 QBarSet *set2 = new QBarSet("Guybrush");
28 28 QBarSet *set3 = new QBarSet("Larry");
29 29 QBarSet *set4 = new QBarSet("Zak");
30 30
31 31 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
32 32 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
33 33 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
34 34 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
35 35 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
36 36 //! [2]
37 37
38 38 //! [3]
39 39 // Create series and add sets to it
40 40 QBarSeries* series= new QBarSeries(categories);
41 41
42 42 series->addBarSet(set0);
43 43 series->addBarSet(set1);
44 44 series->addBarSet(set2);
45 45 series->addBarSet(set3);
46 46 series->addBarSet(set4);
47 47 //! [3]
48 48
49 49 //! [4]
50 50 // Enable tooltip
51 51 series->setToolTipEnabled();
52 52 series->setSeparatorsVisible(true);
53 53
54 54 // Connect clicked signal of set to toggle floating values of set.
55 55 QObject::connect(set0,SIGNAL(clicked(QString)),set0,SIGNAL(toggleFloatingValues()));
56 56 QObject::connect(set1,SIGNAL(clicked(QString)),set1,SIGNAL(toggleFloatingValues()));
57 57 QObject::connect(set2,SIGNAL(clicked(QString)),set2,SIGNAL(toggleFloatingValues()));
58 58 QObject::connect(set3,SIGNAL(clicked(QString)),set3,SIGNAL(toggleFloatingValues()));
59 59 QObject::connect(set4,SIGNAL(clicked(QString)),set4,SIGNAL(toggleFloatingValues()));
60 60 //! [4]
61 61
62 62 //! [5]
63 63 // Create view for chart and add series to it. Apply theme.
64 64
65 65 QChartView* chartView = new QChartView(&window);
66 66 chartView->addSeries(series);
67 67 chartView->setChartTitle("simple barchart");
68 68 chartView->setChartTheme(QChart::ChartThemeIcy);
69 69 //! [5]
70 70
71 71 //! [6]
72 chartView->axisX()->setGridVisible(false);
72 chartView->axisX()->setGridLineVisible(false);
73 73 //! [6]
74 74
75 75 window.setCentralWidget(chartView);
76 76 window.resize(400, 300);
77 77 window.show();
78 78
79 79 return a.exec();
80 80 }
81 81
Show file before | Show file after | Hide comments
@@ -1,83 +1,83
1 1 #include <QApplication>
2 2 #include <QMainWindow>
3 3 #include <QStandardItemModel>
4 4 #include <qpercentbarseries.h>
5 5 #include <qchartview.h>
6 6 #include <qbarset.h>
7 7 #include <qchartaxis.h>
8 8 #include <QStringList>
9 9
10 10 QTCOMMERCIALCHART_USE_NAMESPACE
11 11
12 12 int main(int argc, char *argv[])
13 13 {
14 14 QApplication a(argc, argv);
15 15 QMainWindow window;
16 16
17 17 //! [1]
18 18 // Define categories
19 19 QStringList categories;
20 20 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
21 21 //! [1]
22 22
23 23 //! [2]
24 24 // Create some test sets for chat
25 25 QBarSet *set0 = new QBarSet("Bub");
26 26 QBarSet *set1 = new QBarSet("Bob");
27 27 QBarSet *set2 = new QBarSet("Guybrush");
28 28 QBarSet *set3 = new QBarSet("Larry");
29 29 QBarSet *set4 = new QBarSet("Zak");
30 30
31 31 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
32 32 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
33 33 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
34 34 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
35 35 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
36 36 //! [2]
37 37
38 38 //! [3]
39 39 // Create series and add sets to it
40 40 QPercentBarSeries* series = new QPercentBarSeries(categories);
41 41
42 42 series->addBarSet(set0);
43 43 series->addBarSet(set1);
44 44 series->addBarSet(set2);
45 45 series->addBarSet(set3);
46 46 series->addBarSet(set4);
47 47 //! [3]
48 48
49 49 //! [4]
50 50 // Enable tooltip
51 51 series->setToolTipEnabled();
52 52
53 53 // Connect clicked signal of set to toggle floating values of set.
54 54 // Note that we leave QBarset "Zak" unconnected here, so clicking on it doesn't toggle values.
55 55 QObject::connect(set0,SIGNAL(clicked(QString)),set0,SIGNAL(toggleFloatingValues()));
56 56 QObject::connect(set1,SIGNAL(clicked(QString)),set1,SIGNAL(toggleFloatingValues()));
57 57 QObject::connect(set2,SIGNAL(clicked(QString)),set2,SIGNAL(toggleFloatingValues()));
58 58 QObject::connect(set3,SIGNAL(clicked(QString)),set3,SIGNAL(toggleFloatingValues()));
59 59 QObject::connect(set4,SIGNAL(clicked(QString)),set4,SIGNAL(toggleFloatingValues()));
60 60 //! [4]
61 61
62 62 //! [5]
63 63 // Create view for chart and add series to it. Apply theme.
64 64
65 65 QChartView* chartView = new QChartView(&window);
66 66 chartView->addSeries(series);
67 67 chartView->setChartTitle("simple percent barchart");
68 68 chartView->setChartTheme(QChart::ChartThemeIcy);
69 69 //! [5]
70 70
71 71 //! [6]
72 72 chartView->axisX()->setAxisVisible(false);
73 chartView->axisX()->setGridVisible(false);
73 chartView->axisX()->setGridLineVisible(false);
74 74 chartView->axisX()->setLabelsVisible(false);
75 75 //! [6]
76 76
77 77 window.setCentralWidget(chartView);
78 78 window.resize(400, 300);
79 79 window.show();
80 80
81 81 return a.exec();
82 82 }
83 83
Show file before | Show file after | Hide comments
@@ -1,79 +1,79
1 1 #include <QApplication>
2 2 #include <QMainWindow>
3 3 #include <qchartview.h>
4 4 #include <qstackedbarseries.h>
5 5 #include <qbarset.h>
6 6 #include <qchartaxis.h>
7 7 #include <QStringList>
8 8
9 9 QTCOMMERCIALCHART_USE_NAMESPACE
10 10
11 11 int main(int argc, char *argv[])
12 12 {
13 13 QApplication a(argc, argv);
14 14 QMainWindow window;
15 15
16 16 //! [1]
17 17 // Define categories
18 18 QStringList categories;
19 19 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
20 20 //! [1]
21 21
22 22 //! [2]
23 23 // Create some test sets for chat
24 24 QBarSet *set0 = new QBarSet("Bub");
25 25 QBarSet *set1 = new QBarSet("Bob");
26 26 QBarSet *set2 = new QBarSet("Guybrush");
27 27 QBarSet *set3 = new QBarSet("Larry");
28 28 QBarSet *set4 = new QBarSet("Zak");
29 29
30 30 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
31 31 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
32 32 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
33 33 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
34 34 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
35 35 //! [2]
36 36
37 37 //! [3]
38 38 // Create series and add sets to it
39 39 QStackedBarSeries* series = new QStackedBarSeries(categories);
40 40
41 41 series->addBarSet(set0);
42 42 series->addBarSet(set1);
43 43 series->addBarSet(set2);
44 44 series->addBarSet(set3);
45 45 series->addBarSet(set4);
46 46 //! [3]
47 47
48 48 //! [4]
49 49 // Enable tooltip
50 50 series->setToolTipEnabled();
51 51
52 52 // Connect clicked signal of set to toggle floating values of set.
53 53 QObject::connect(set0,SIGNAL(clicked(QString)),set0,SIGNAL(toggleFloatingValues()));
54 54 QObject::connect(set1,SIGNAL(clicked(QString)),set1,SIGNAL(toggleFloatingValues()));
55 55 QObject::connect(set2,SIGNAL(clicked(QString)),set2,SIGNAL(toggleFloatingValues()));
56 56 QObject::connect(set3,SIGNAL(clicked(QString)),set3,SIGNAL(toggleFloatingValues()));
57 57 QObject::connect(set4,SIGNAL(clicked(QString)),set4,SIGNAL(toggleFloatingValues()));
58 58 //! [4]
59 59
60 60 //! [5]
61 61 // Create view for chart and add series to it. Apply theme.
62 62
63 63 QChartView* chartView = new QChartView(&window);
64 64 chartView->addSeries(series);
65 65 chartView->setChartTitle("simple stacked barchart");
66 66 chartView->setChartTheme(QChart::ChartThemeIcy);
67 67 //! [5]
68 68
69 69 //! [6]
70 chartView->axisX()->setGridVisible(false);
70 chartView->axisX()->setGridLineVisible(false);
71 71 //! [6]
72 72
73 73 window.setCentralWidget(chartView);
74 74 window.resize(400, 300);
75 75 window.show();
76 76
77 77 return a.exec();
78 78 }
79 79
Show file before | Show file after | Hide comments
@@ -1,156 +1,156
1 1 #include <QtGui/QApplication>
2 2 #include <QMainWindow>
3 3 #include <qchartglobal.h>
4 4 #include <qchartview.h>
5 5 #include <qstackedbarseries.h>
6 6 #include <qbarset.h>
7 7 #include <qchartaxis.h>
8 8 #include <qlegend.h>
9 9 #include <QStringList>
10 10 #include <QDebug>
11 11
12 12 QTCOMMERCIALCHART_USE_NAMESPACE
13 13
14 14 //! [1]
15 15 class DrilldownBarSeries : public QStackedBarSeries
16 16 {
17 17 Q_OBJECT
18 18 public:
19 19 DrilldownBarSeries(QStringList categories, QObject *parent = 0) : QStackedBarSeries(categories,parent) {}
20 20
21 21 void mapDrilldownSeries(QString category, DrilldownBarSeries* drilldownSeries)
22 22 {
23 23 mDrilldownSeries[category] = drilldownSeries;
24 24 }
25 25
26 26 DrilldownBarSeries* drilldownSeries(QString category)
27 27 {
28 28 return mDrilldownSeries[category];
29 29 }
30 30
31 31 public Q_SLOTS:
32 32
33 33 private:
34 34
35 35 QMap<QString, DrilldownBarSeries*> mDrilldownSeries;
36 36 };
37 37 //! [1]
38 38
39 39 //! [2]
40 40 class DrilldownChart : public QChartView
41 41 {
42 42 Q_OBJECT
43 43 public:
44 44 explicit DrilldownChart(QWidget *parent = 0) : QChartView(parent), m_currentSeries(0) {}
45 45
46 46 void changeSeries(QSeries* series)
47 47 {
48 48 if (m_currentSeries)
49 49 removeSeries(m_currentSeries);
50 50 m_currentSeries = series;
51 51 addSeries(series);
52 52 setChartTitle(series->title());
53 53 }
54 54
55 55 public Q_SLOTS:
56 56 void handleRightClick(QBarSet *barset, QString category)
57 57 {
58 58 // qDebug() << "DrilldownChart::handleRightClick" << barset->name() << category;
59 59 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
60 60 changeSeries(series->drilldownSeries(category));
61 61 }
62 62
63 63 private:
64 64 QSeries* m_currentSeries;
65 65 };
66 66 //! [2]
67 67
68 68 int main(int argc, char *argv[])
69 69 {
70 70 QApplication a(argc, argv);
71 71 QMainWindow window;
72 72
73 73 DrilldownChart* drilldownChart = new DrilldownChart(&window);
74 74 drilldownChart->setChartTheme(QChart::ChartThemeIcy);
75 75
76 76 //! [3]
77 77 // Define categories
78 78 QStringList months;
79 79 months << "May" << "Jun" << "Jul" << "Aug" << "Sep";
80 80 QStringList weeks;
81 81 weeks << "week 1" << "week 2" << "week 3" << "week 4";
82 82 QStringList plants;
83 83 plants << "Habanero" << "Lemon Drop" << "Starfish" << "Aji Amarillo";
84 84 //! [3]
85 85
86 86 //! [4]
87 87 // Create drilldown structure
88 88 DrilldownBarSeries* seasonSeries = new DrilldownBarSeries(months, drilldownChart);
89 89 seasonSeries->setTitle("Crop by month - Season");
90 90
91 91 // Each month in season series has drilldown series for weekly data
92 92 foreach (QString month, months) {
93 93
94 94 // Create drilldown series for every week
95 95 DrilldownBarSeries* weeklySeries = new DrilldownBarSeries(weeks, drilldownChart);
96 96 seasonSeries->mapDrilldownSeries(month, weeklySeries);
97 97
98 98 // Drilling down from weekly data brings us back to season data.
99 99 foreach (QString week, weeks) {
100 100 weeklySeries->mapDrilldownSeries(week, seasonSeries);
101 101 weeklySeries->setTitle(QString("Crop by week - " + month));
102 102 }
103 103
104 104 // Use right click signal to implement drilldown
105 105 QObject::connect(weeklySeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
106 106 }
107 107
108 108 // Enable drilldown from season series using right click.
109 109 QObject::connect(seasonSeries,SIGNAL(rightClicked(QBarSet*,QString)),drilldownChart,SLOT(handleRightClick(QBarSet*,QString)));
110 110 //! [4]
111 111
112 112 //! [5]
113 113 // Fill monthly and weekly series with data
114 114 foreach (QString plant, plants) {
115 115 QBarSet* monthlyCrop = new QBarSet(plant);
116 116 foreach (QString month, months) {
117 117 QBarSet* weeklyCrop = new QBarSet(plant);
118 118 foreach (QString week, weeks ) {
119 119 *weeklyCrop << (qrand() % 20);
120 120 }
121 121 // Get the drilldown series from season series and add crop to it.
122 122 seasonSeries->drilldownSeries(month)->addBarSet(weeklyCrop);
123 123 seasonSeries->drilldownSeries(month)->setToolTipEnabled(true);
124 124 *monthlyCrop << weeklyCrop->total();
125 125
126 126 QObject::connect(weeklyCrop,SIGNAL(clicked(QString)),weeklyCrop,SIGNAL(toggleFloatingValues()));
127 127 }
128 128 seasonSeries->addBarSet(monthlyCrop);
129 129 QObject::connect(monthlyCrop,SIGNAL(clicked(QString)),monthlyCrop,SIGNAL(toggleFloatingValues()));
130 130 }
131 131 //! [5]
132 132
133 133 seasonSeries->setToolTipEnabled(true);
134 134
135 135 //! [6]
136 136 // Show season series in initial view
137 137 drilldownChart->changeSeries(seasonSeries);
138 138 drilldownChart->setChartTitle(seasonSeries->title());
139 139 //! [6]
140 140
141 141 // Disable axis, since they don't really apply to bar chart
142 142 // drilldownChart->axisX()->setAxisVisible(false);
143 drilldownChart->axisX()->setGridVisible(false);
143 drilldownChart->axisX()->setGridLineVisible(false);
144 144 // drilldownChart->axisX()->setLabelsVisible(false);
145 145
146 146 QLegend* l = drilldownChart->legend();
147 147 l->handleGeometryChanged(QRectF(20,20,100,100));
148 148
149 149 window.setCentralWidget(drilldownChart);
150 150 window.resize(400, 300);
151 151 window.show();
152 152
153 153 return a.exec();
154 154 }
155 155
156 156 #include "main.moc"
Show file before | Show file after | Hide comments
@@ -1,414 +1,414
1 1 #include "axisitem_p.h"
2 2 #include "qchartaxis.h"
3 3 #include "chartpresenter_p.h"
4 4 #include "chartanimator_p.h"
5 5 #include <QPainter>
6 6 #include <QDebug>
7 7
8 8 static int label_padding = 5;
9 9
10 10 QTCOMMERCIALCHART_BEGIN_NAMESPACE
11 11
12 12 AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) :
13 13 ChartItem(parent),
14 14 m_presenter(presenter),
15 15 m_chartAxis(axis),
16 16 m_type(type),
17 17 m_labelsAngle(0),
18 18 m_grid(parent),
19 19 m_shades(parent),
20 20 m_labels(parent),
21 21 m_axis(parent),
22 22 m_min(0),
23 23 m_max(0),
24 24 m_ticksCount(0)
25 25 {
26 26 //initial initialization
27 27 m_axis.setZValue(ChartPresenter::AxisZValue);
28 28 m_shades.setZValue(ChartPresenter::ShadesZValue);
29 29 m_grid.setZValue(ChartPresenter::GridZValue);
30 30 setFlags(QGraphicsItem::ItemHasNoContents);
31 31
32 32 QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
33 33 QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
34 34
35 35 handleAxisUpdated();
36 36 }
37 37
38 38 AxisItem::~AxisItem()
39 39 {
40 40 }
41 41
42 42 QRectF AxisItem::boundingRect() const
43 43 {
44 44 return QRectF();
45 45 }
46 46
47 47 void AxisItem::createItems(int count)
48 48 {
49 49
50 50 if(m_axis.children().size()==0)
51 51 m_axis.addToGroup(new QGraphicsLineItem());
52 52 for (int i = 0; i < count; ++i) {
53 53 m_grid.addToGroup(new QGraphicsLineItem());
54 54 m_labels.addToGroup(new QGraphicsSimpleTextItem());
55 55 m_axis.addToGroup(new QGraphicsLineItem());
56 56 if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
57 57 }
58 58 }
59 59
60 60 void AxisItem::deleteItems(int count)
61 61 {
62 62 QList<QGraphicsItem *> lines = m_grid.childItems();
63 63 QList<QGraphicsItem *> labels = m_labels.childItems();
64 64 QList<QGraphicsItem *> shades = m_shades.childItems();
65 65 QList<QGraphicsItem *> axis = m_axis.childItems();
66 66
67 67 for (int i = 0; i < count; ++i) {
68 68 if(lines.size()%2 && lines.size()>1) delete(shades.takeLast());
69 69 delete(lines.takeLast());
70 70 delete(labels.takeLast());
71 71 delete(axis.takeLast());
72 72 }
73 73 }
74 74
75 75 void AxisItem::updateLayout(QVector<qreal>& layout)
76 76 {
77 77 if(m_animator){
78 78 m_animator->applyLayout(this,layout);
79 79 }
80 80 else setLayout(layout);
81 81 }
82 82
83 83 QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
84 84 {
85 85 Q_ASSERT(max>=min);
86 86 Q_ASSERT(ticks>0);
87 87
88 88 QStringList labels;
89 89
90 90 QChartAxisCategories* categories = m_chartAxis->categories();
91 91
92 92 for(int i=0; i< ticks; i++) {
93 93 qreal value = min + (i * (max - min)/ (ticks-1));
94 94 if(categories->count()==0) {
95 95 labels << QString::number(value);
96 96 }
97 97 else {
98 98 QString label = categories->label(value);
99 99 labels << label;
100 100 }
101 101 }
102 102 return labels;
103 103 }
104 104
105 105 void AxisItem::setAxisOpacity(qreal opacity)
106 106 {
107 107 m_axis.setOpacity(opacity);
108 108 }
109 109
110 110 qreal AxisItem::axisOpacity() const
111 111 {
112 112 return m_axis.opacity();
113 113 }
114 114
115 115 void AxisItem::setGridOpacity(qreal opacity)
116 116 {
117 117 m_grid.setOpacity(opacity);
118 118 }
119 119
120 120 qreal AxisItem::gridOpacity() const
121 121 {
122 122 return m_grid.opacity();
123 123 }
124 124
125 125 void AxisItem::setLabelsOpacity(qreal opacity)
126 126 {
127 127 m_labels.setOpacity(opacity);
128 128 }
129 129
130 130 qreal AxisItem::labelsOpacity() const
131 131 {
132 132 return m_labels.opacity();
133 133 }
134 134
135 135 void AxisItem::setShadesOpacity(qreal opacity)
136 136 {
137 137 m_shades.setOpacity(opacity);
138 138 }
139 139
140 140 qreal AxisItem::shadesOpacity() const
141 141 {
142 142 return m_shades.opacity();
143 143 }
144 144
145 145 void AxisItem::setLabelsAngle(int angle)
146 146 {
147 147 foreach(QGraphicsItem* item , m_labels.childItems()) {
148 148 QPointF center = item->boundingRect().center();
149 149 item->setRotation(angle);
150 150 }
151 151
152 152 m_labelsAngle=angle;
153 153 }
154 154
155 155 void AxisItem::setLabelsPen(const QPen& pen)
156 156 {
157 157 foreach(QGraphicsItem* item , m_labels.childItems()) {
158 158 static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
159 159 }
160 160 }
161 161
162 162 void AxisItem::setLabelsBrush(const QBrush& brush)
163 163 {
164 164 foreach(QGraphicsItem* item , m_labels.childItems()) {
165 165 static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
166 166 }
167 167 }
168 168
169 169 void AxisItem::setLabelsFont(const QFont& font)
170 170 {
171 171 foreach(QGraphicsItem* item , m_labels.childItems()) {
172 172 static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
173 173 }
174 174 }
175 175
176 176 void AxisItem::setShadesBrush(const QBrush& brush)
177 177 {
178 178 foreach(QGraphicsItem* item , m_shades.childItems()) {
179 179 static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
180 180 }
181 181 }
182 182
183 183 void AxisItem::setShadesPen(const QPen& pen)
184 184 {
185 185 foreach(QGraphicsItem* item , m_shades.childItems()) {
186 186 static_cast<QGraphicsRectItem*>(item)->setPen(pen);
187 187 }
188 188 }
189 189
190 190 void AxisItem::setAxisPen(const QPen& pen)
191 191 {
192 192 foreach(QGraphicsItem* item , m_axis.childItems()) {
193 193 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
194 194 }
195 195 }
196 196
197 197 void AxisItem::setGridPen(const QPen& pen)
198 198 {
199 199 foreach(QGraphicsItem* item , m_grid.childItems()) {
200 200 static_cast<QGraphicsLineItem*>(item)->setPen(pen);
201 201 }
202 202 }
203 203
204 204 QVector<qreal> AxisItem::calculateLayout() const
205 205 {
206 206 Q_ASSERT(m_ticksCount>=2);
207 207
208 208 QVector<qreal> points;
209 209 points.resize(m_ticksCount);
210 210
211 211 switch (m_type)
212 212 {
213 213 case X_AXIS:
214 214 {
215 215 const qreal deltaX = m_rect.width()/(m_ticksCount-1);
216 216 for (int i = 0; i < m_ticksCount; ++i) {
217 217 int x = i * deltaX + m_rect.left();
218 218 points[i] = x;
219 219 }
220 220 }
221 221 break;
222 222 case Y_AXIS:
223 223 {
224 224 const qreal deltaY = m_rect.height()/(m_ticksCount-1);
225 225 for (int i = 0; i < m_ticksCount; ++i) {
226 226 int y = i * -deltaY + m_rect.bottom();
227 227 points[i] = y;
228 228 }
229 229 }
230 230 break;
231 231 }
232 232 return points;
233 233 }
234 234
235 235 void AxisItem::setLayout(QVector<qreal>& layout)
236 236 {
237 237 int diff = m_layoutVector.size() - layout.size();
238 238
239 239 if(diff>0) {
240 240 deleteItems(diff);
241 241 }
242 242 else if(diff<0) {
243 243 createItems(-diff);
244 244 }
245 245
246 246 if(diff!=0) handleAxisUpdated();
247 247
248 248 QStringList ticksList = createLabels(layout.size(),m_min,m_max);
249 249
250 250 QList<QGraphicsItem *> lines = m_grid.childItems();
251 251 QList<QGraphicsItem *> labels = m_labels.childItems();
252 252 QList<QGraphicsItem *> shades = m_shades.childItems();
253 253 QList<QGraphicsItem *> axis = m_axis.childItems();
254 254
255 255 Q_ASSERT(labels.size() == ticksList.size());
256 256 Q_ASSERT(layout.size() == ticksList.size());
257 257 Q_ASSERT(layout.size() == m_ticksCount);
258 258
259 259 switch (m_type)
260 260 {
261 261 case X_AXIS:
262 262 {
263 263 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
264 264 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
265 265
266 266 for (int i = 0; i < layout.size(); ++i) {
267 267 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
268 268 lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
269 269 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
270 270 labelItem->setText(ticksList.at(i));
271 271 QPointF center = labelItem->boundingRect().center();
272 272 labelItem->setTransformOriginPoint(center.x(), center.y());
273 273 labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
274 274 if(i%2 && i+1 < layout.size() && i>1) {
275 275 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
276 276 rectItem->setRect(layout[i],m_rect.top(),layout[i+1]-layout[i],m_rect.height());
277 277 }
278 278 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
279 279 lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
280 280 }
281 281 }
282 282 break;
283 283
284 284 case Y_AXIS:
285 285 {
286 286 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
287 287 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
288 288
289 289 for (int i = 0; i < layout.size(); ++i) {
290 290 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
291 291 lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
292 292 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
293 293 labelItem->setText(ticksList.at(i));
294 294 QPointF center = labelItem->boundingRect().center();
295 295 labelItem->setTransformOriginPoint(center.x(), center.y());
296 296 labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
297 297 if(i%2 && i+1 < layout.size() && i>1) {
298 298 QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2));
299 299 rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i]-layout[i+1]);
300 300 }
301 301 lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
302 302 lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
303 303 }
304 304 }
305 305 break;
306 306 default:
307 307 qDebug()<<"Unknown axis type";
308 308 break;
309 309 }
310 310
311 311 m_layoutVector=layout;
312 312 }
313 313
314 314 bool AxisItem::isEmpty()
315 315 {
316 316 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
317 317 }
318 318
319 319 //handlers
320 320
321 321 void AxisItem::handleAxisCategoriesUpdated()
322 322 {
323 323 if(isEmpty()) return;
324 324 updateLayout(m_layoutVector);
325 325 }
326 326
327 327 void AxisItem::handleAxisUpdated()
328 328 {
329 329
330 330 if(isEmpty()) return;
331 331
332 332 if(m_chartAxis->isAxisVisible()) {
333 333 setAxisOpacity(100);
334 334 }
335 335 else {
336 336 setAxisOpacity(0);
337 337 }
338 338
339 if(m_chartAxis->isGridVisible()) {
339 if(m_chartAxis->isGridLineVisible()) {
340 340 setGridOpacity(100);
341 341 }
342 342 else {
343 343 setGridOpacity(0);
344 344 }
345 345
346 346 if(m_chartAxis->labelsVisible())
347 347 {
348 348 setLabelsOpacity(100);
349 349 }
350 350 else {
351 351 setLabelsOpacity(0);
352 352 }
353 353
354 354 if(m_chartAxis->shadesVisible()) {
355 355 setShadesOpacity(m_chartAxis->shadesOpacity());
356 356 }
357 357 else {
358 358 setShadesOpacity(0);
359 359 }
360 360
361 361 setLabelsAngle(m_chartAxis->labelsAngle());
362 362 setAxisPen(m_chartAxis->axisPen());
363 363 setLabelsPen(m_chartAxis->labelsPen());
364 364 setLabelsBrush(m_chartAxis->labelsBrush());
365 365 setLabelsFont(m_chartAxis->labelsFont());
366 setGridPen(m_chartAxis->gridPen());
366 setGridPen(m_chartAxis->gridLinePen());
367 367 setShadesPen(m_chartAxis->shadesPen());
368 368 setShadesBrush(m_chartAxis->shadesBrush());
369 369
370 370 }
371 371
372 372 void AxisItem::handleRangeChanged(qreal min, qreal max,int tickCount)
373 373 {
374 374 m_min = min;
375 375 m_max = max;
376 376 m_ticksCount = tickCount;
377 377
378 378 /*= qrand()%10;
379 379
380 380 while(m_ticksCount<2){
381 381 m_ticksCount = qrand()%10;
382 382 }
383 383
384 384 qDebug()<<"Warning : This is testing . Simulating new random ticks "<< m_ticksCount;
385 385 //m_chartAxis->setTicksCount(m_ticksCount);
386 386 */
387 387
388 388 if(isEmpty()) return;
389 389 QVector<qreal> layout = calculateLayout();
390 390 updateLayout(layout);
391 391
392 392 }
393 393
394 394 void AxisItem::handleGeometryChanged(const QRectF& rect)
395 395 {
396 396 m_rect = rect;
397 397 if(isEmpty()) return;
398 398 QVector<qreal> layout = calculateLayout();
399 399 updateLayout(layout);
400 400 }
401 401
402 402 //painter
403 403
404 404 void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
405 405 {
406 406 Q_UNUSED(painter);
407 407 Q_UNUSED(option);
408 408 Q_UNUSED(widget);
409 409 }
410 410
411 411 //TODO "nice numbers algorithm"
412 412 #include "moc_axisitem_p.cpp"
413 413
414 414 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,391 +1,391
1 1 #include "qchartaxis.h"
2 2
3 3 QTCOMMERCIALCHART_BEGIN_NAMESPACE
4 4
5 5 /*!
6 6 \class QChartAxis
7 7 \brief The QChartAxis class is used for manipulating chart's axis
8 8 and for adding optional axes to the chart.
9 9 \mainclass
10 10
11 11 There is only one x Axis, however there can be multiple y axes.
12 12 Each chart series can be bound to exactly one Y axis and the share common X axis.
13 13 Axis can be setup to show axis line with ticks, gird lines and shades.
14 14
15 15 */
16 16
17 17 /*!
18 18 \fn bool QChartAxis::isAxisVisible() const
19 19 \brief Returns if axis is visible
20 20 \sa setAxisVisible()
21 21 */
22 22
23 23 /*!
24 24 \fn QPen QChartAxis::axisPen() const
25 25 \brief Returns pen used to draw axis and ticks.
26 26 \sa setAxisPen()
27 27 */
28 28
29 29
30 30 /*!
31 \fn bool QChartAxis::isGridVisible() const
31 \fn bool QChartAxis::isGridLineVisible() const
32 32 \brief Returns if grid is visible
33 \sa setGridVisible()
33 \sa setGridLineVisible()
34 34 */
35 35
36 36 /*!
37 37 \fn QPen QChartAxis::gridPen() const
38 38 \brief Returns pen used to draw grid.
39 39 \sa setGridPen()
40 40 */
41 41
42 42 /*!
43 43 \fn bool QChartAxis::labelsVisible() const
44 44 \brief Returns if grid is visible
45 45 \sa setLabelsVisible()
46 46 */
47 47
48 48 /*!
49 49 \fn QPen QChartAxis::labelsPen() const
50 50 \brief Returns the pen used to labels.
51 51 \sa setLabelsPen()
52 52 */
53 53
54 54 /*!
55 55 \fn QBrush QChartAxis::labelsBrush() const
56 56 \brief Returns brush used to draw labels.
57 57 \sa setLabelsBrush()
58 58 */
59 59
60 60 /*!
61 61 \fn QFont QChartAxis::labelsFont() const
62 62 \brief Returns font used to draw labels.
63 63 \sa setLabelsFont()
64 64 */
65 65
66 66 /*!
67 67 \fn QFont QChartAxis::labelsAngle() const
68 68 \brief Returns angle used to draw labels.
69 69 \sa setLabelsAngle()
70 70 */
71 71
72 72 /*!
73 73 \fn bool QChartAxis::shadesVisible() const
74 74 \brief Returns if shades are visible.
75 75 \sa setShadesVisible()
76 76 */
77 77
78 78 /*!
79 79 \fn qreal QChartAxis::shadesOpacity() const
80 80 \brief Returns opacity of shades.
81 81 */
82 82
83 83 /*!
84 84 \fn QPen QChartAxis::shadesPen() const
85 85 \brief Returns pen used to draw shades.
86 86 \sa setShadesPen()
87 87 */
88 88
89 89 /*!
90 90 \fn QBrush QChartAxis::shadesBrush() const
91 91 \brief Returns brush used to draw shades.
92 92 \sa setShadesBrush()
93 93 */
94 94
95 95 /*!
96 96 \fn qreal QChartAxis::min() const
97 97 \brief Returns minimum value on the axis.
98 98 \sa setMin()
99 99 */
100 100
101 101 /*!
102 102 \fn qreal QChartAxis::max() const
103 103 \brief Returns maximim value on the axis.
104 104 \sa setMax()
105 105 */
106 106
107 107 /*!
108 108 \fn void QChartAxis::minChanged(qreal min)
109 109 \brief Axis emits signal when \a min of axis has changed.
110 110 */
111 111
112 112 /*!
113 113 \fn void QChartAxis::maxChanged(qreal max)
114 114 \brief Axis emits signal when \a max of axis has changed.
115 115 */
116 116
117 117 /*!
118 118 \fn void QChartAxis::rangeChanged(qreal min, qreal max)
119 119 \brief Axis emits signal when \a min or \a max of axis has changed.
120 120 */
121 121
122 122 /*!
123 123 \fn int QChartAxis::ticksCount() const
124 124 \brief Return number of ticks on the axis
125 125 \sa setTicksCount()
126 126 */
127 127
128 128 /*!
129 129 \fn void QChartAxis::updated()
130 130 \brief \internal
131 131 */
132 132
133 133 /*!
134 134 \fn void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
135 135 \brief \internal \a min \a max
136 136 */
137 137
138 138 /*!
139 139 Constructs new axis object which is a child of \a parent. Ownership is taken by
140 140 QChatView or QChart when axis added.
141 141 */
142 142
143 143 QChartAxis::QChartAxis(QObject* parent):QObject(parent),
144 144 m_axisVisible(true),
145 m_gridVisible(true),
145 m_gridLineVisible(true),
146 146 m_labelsVisible(true),
147 147 m_labelsAngle(0),
148 148 m_shadesVisible(true),
149 149 m_shadesOpacity(1.0),
150 150 m_min(0),
151 151 m_max(0),
152 152 m_ticksCount(5)
153 153 {
154 154
155 155 }
156 156
157 157 /*!
158 158 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
159 159 */
160 160
161 161 QChartAxis::~QChartAxis()
162 162 {
163 163 }
164 164
165 165 /*!
166 166 Sets \a pen used to draw axis line and ticks.
167 167 */
168 168 void QChartAxis::setAxisPen(const QPen& pen)
169 169 {
170 170 if (pen != m_axisPen) {
171 171 m_axisPen=pen;
172 172 emit updated();
173 173 }
174 174 }
175 175
176 176 /*!
177 177 Sets if axis and ticks are \a visible.
178 178 */
179 179 void QChartAxis::setAxisVisible(bool visible)
180 180 {
181 181 if (m_axisVisible!=visible) {
182 182 m_axisVisible=visible;
183 183 emit updated();
184 184 }
185 185 }
186 186
187 187 /*!
188 Sets if grid is \a visible.
188 Sets if grid line is \a visible.
189 189 */
190 void QChartAxis::setGridVisible(bool visible)
190 void QChartAxis::setGridLineVisible(bool visible)
191 191 {
192 if (m_gridVisible!=visible) {
193 m_gridVisible=visible;
192 if (m_gridLineVisible!=visible) {
193 m_gridLineVisible=visible;
194 194 emit updated();
195 195 }
196 196 }
197 197
198 198 /*!
199 Sets \a pen used to draw grid.
199 Sets \a pen used to draw grid line.
200 200 */
201 void QChartAxis::setGridPen(const QPen& pen)
201 void QChartAxis::setGridLinePen(const QPen& pen)
202 202 {
203 if (m_gridPen!=pen) {
204 m_gridPen=pen;
203 if (m_gridLinePen!=pen) {
204 m_gridLinePen=pen;
205 205 emit updated();
206 206 }
207 207 }
208 208
209 209 /*!
210 210 Sets if axis' labels are \a visible.
211 211 */
212 212 void QChartAxis::setLabelsVisible(bool visible)
213 213 {
214 214 if(m_labelsVisible!=visible) {
215 215 m_labelsVisible=visible;
216 216 emit updated();
217 217 }
218 218 }
219 219
220 220 /*!
221 221 Sets \a pen used to draw labels.
222 222 */
223 223 void QChartAxis::setLabelsPen(const QPen& pen)
224 224 {
225 225 if(m_labelsPen!=pen) {
226 226 m_labelsPen=pen;
227 227 emit updated();
228 228 }
229 229 }
230 230
231 231 /*!
232 232 Sets \a brush used to draw labels.
233 233 */
234 234 void QChartAxis::setLabelsBrush(const QBrush& brush)
235 235 {
236 236 if(m_labelsBrush!=brush) {
237 237 m_labelsBrush=brush;
238 238 emit updated();
239 239 }
240 240 }
241 241
242 242 /*!
243 243 Sets \a font used to draw labels.
244 244 */
245 245 void QChartAxis::setLabelsFont(const QFont& font)
246 246 {
247 247 if(m_labelsFont!=font) {
248 248 m_labelsFont=font;
249 249 emit updated();
250 250 }
251 251 }
252 252
253 253 /*!
254 254 Sets \a angle for all the labels on given axis.
255 255 */
256 256 void QChartAxis::setLabelsAngle(int angle)
257 257 {
258 258 if(m_labelsAngle!=angle) {
259 259 m_labelsAngle=angle;
260 260 emit updated();
261 261 }
262 262 }
263 263
264 264 /*!
265 265 Sets if shades are \a visible.
266 266 */
267 267 void QChartAxis::setShadesVisible(bool visible)
268 268 {
269 269 if(m_shadesVisible!=visible) {
270 270 m_shadesVisible=visible;
271 271 emit updated();
272 272 }
273 273 }
274 274
275 275 /*!
276 276 Sets \a pen used to draw shades.
277 277 */
278 278 void QChartAxis::setShadesPen(const QPen& pen)
279 279 {
280 280 if(m_shadesPen!=pen) {
281 281 m_shadesPen=pen;
282 282 emit updated();
283 283 }
284 284 }
285 285
286 286 /*!
287 287 Sets \a brush used to draw shades.
288 288 */
289 289 void QChartAxis::setShadesBrush(const QBrush& brush)
290 290 {
291 291 if(m_shadesBrush!=brush) {
292 292 m_shadesBrush=brush;
293 293 emit updated();
294 294 }
295 295 }
296 296
297 297 /*!
298 298 Sets \a opacity of the shades.
299 299 */
300 300 void QChartAxis::setShadesOpacity(qreal opacity)
301 301 {
302 302 if(m_shadesOpacity!=opacity) {
303 303 m_shadesOpacity=opacity;
304 304 emit updated();
305 305 }
306 306 }
307 307
308 308 /*!
309 309 Sets \a min value on the axis.
310 310 */
311 311 void QChartAxis::setMin(qreal min)
312 312 {
313 313 setRange(min,m_max);
314 314 }
315 315
316 316 /*!
317 317 Sets \a max value on the axis.
318 318 */
319 319 void QChartAxis::setMax(qreal max)
320 320 {
321 321 setRange(m_min,max);
322 322 }
323 323
324 324 /*!
325 325 Sets range from \a min to \a max on the axis.
326 326 */
327 327 void QChartAxis::setRange(qreal min, qreal max)
328 328 {
329 329
330 330
331 331 bool changed = false;
332 332 if(m_min!=min) {
333 333 m_min=min;
334 334 changed=true;
335 335 emit minChanged(min);
336 336 }
337 337
338 338 if(m_max!=max) {
339 339 m_max=max;
340 340 changed=true;
341 341 emit maxChanged(max);
342 342 }
343 343
344 344 if(changed) {
345 345 emit rangeChanged(m_min,m_max,m_ticksCount);
346 346 }
347 347 }
348 348
349 349 void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
350 350 {
351 351 setRange(min,max);
352 352 }
353 353
354 354 /*!
355 355 Sets \a count for ticks on the axis.
356 356 */
357 357 void QChartAxis::setTicksCount(int count)
358 358 {
359 359 if(m_ticksCount!=count) {
360 360 m_ticksCount=count;
361 361 emit rangeChanged(m_min,m_max,m_ticksCount);
362 362 }
363 363 }
364 364
365 365 /*!
366 366 Sets axis, shades, labels and grid lines to be visible.
367 367 */
368 368 void QChartAxis::show()
369 369 {
370 370 m_axisVisible=true;
371 m_gridVisible=true;
371 m_gridLineVisible=true;
372 372 m_labelsVisible=true;
373 373 m_shadesVisible=true;
374 374 emit updated();
375 375 }
376 376
377 377 /*!
378 378 Sets axis, shades, labels and grid lines to not be visible.
379 379 */
380 380 void QChartAxis::hide()
381 381 {
382 382 m_axisVisible=false;
383 m_gridVisible=false;
383 m_gridLineVisible=false;
384 384 m_labelsVisible=false;
385 385 m_shadesVisible=false;
386 386 emit updated();
387 387 }
388 388
389 389 #include "moc_qchartaxis.cpp"
390 390
391 391 QTCOMMERCIALCHART_END_NAMESPACE
Show file before | Show file after | Hide comments
@@ -1,106 +1,106
1 1 #ifndef QCHARTAXIS_H_
2 2 #define QCHARTAXIS_H_
3 3
4 4 #include <qchartaxiscategories.h>
5 5 #include <QPen>
6 6 #include <QFont>
7 7
8 8
9 9 QTCOMMERCIALCHART_BEGIN_NAMESPACE
10 10
11 11 class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
12 12 {
13 13 Q_OBJECT
14 14 public:
15 15 QChartAxis(QObject* parent =0);
16 16 ~QChartAxis();
17 17
18 18 //axis handling
19 19 bool isAxisVisible() const { return m_axisVisible;};
20 20 void setAxisVisible(bool visible);
21 21 void setAxisPen(const QPen& pen);
22 22 QPen axisPen() const { return m_axisPen;};
23 23
24 24 //grid handling
25 bool isGridVisible() const { return m_gridVisible;};
26 void setGridVisible(bool visible);
27 void setGridPen(const QPen& pen);
28 QPen gridPen() const {return m_gridPen;}
25 bool isGridLineVisible() const { return m_gridLineVisible;};
26 void setGridLineVisible(bool visible);
27 void setGridLinePen(const QPen& pen);
28 QPen gridLinePen() const {return m_gridLinePen;}
29 29
30 30 //labels handling
31 31 bool labelsVisible() const { return m_labelsVisible;};
32 32 void setLabelsVisible(bool visible);
33 33 void setLabelsPen(const QPen& pen);
34 34 QPen labelsPen() const { return m_labelsPen;}
35 35 void setLabelsBrush(const QBrush& brush);
36 36 QBrush labelsBrush() const { return m_labelsBrush;}
37 37 void setLabelsFont(const QFont& font);
38 38 QFont labelsFont() const { return m_labelsFont;}
39 39 void setLabelsAngle(int angle);
40 40 int labelsAngle() const { return m_labelsAngle;};
41 41
42 42 //shades handling
43 43 bool shadesVisible() const { return m_shadesVisible;};
44 44 void setShadesVisible(bool visible);
45 45 void setShadesPen(const QPen& pen);
46 46 QPen shadesPen() const { return m_shadesPen;}
47 47 void setShadesBrush(const QBrush& brush);
48 48 QBrush shadesBrush() const { return m_shadesBrush;}
49 49 void setShadesOpacity(qreal opacity);
50 50 qreal shadesOpacity() const { return m_shadesOpacity;}
51 51
52 52 //range handling
53 53 void setMin(qreal min);
54 54 qreal min() const { return m_min;};
55 55 void setMax(qreal max);
56 56 qreal max() const { return m_max;};
57 57 void setRange(qreal min, qreal max);
58 58
59 59 //ticks handling
60 60 void setTicksCount(int count);
61 61 int ticksCount() const { return m_ticksCount;}
62 62
63 63 QChartAxisCategories* categories() { return &m_category; }
64 64
65 65 void show();
66 66 void hide();
67 67
68 68 signals:
69 69 void minChanged(qreal min);
70 70 void maxChanged(qreal max);
71 71 void rangeChanged(qreal min, qreal max,int ticksCount);
72 72
73 73 //interal signal
74 74 void updated();
75 75 //internal slot
76 76 public slots:
77 77 void handleAxisRangeChanged(qreal min, qreal max);
78 78
79 79 private:
80 80 bool m_axisVisible;
81 81 QPen m_axisPen;
82 82 QBrush m_axisBrush;
83 83
84 bool m_gridVisible;
85 QPen m_gridPen;
84 bool m_gridLineVisible;
85 QPen m_gridLinePen;
86 86
87 87 bool m_labelsVisible;
88 88 QPen m_labelsPen;
89 89 QBrush m_labelsBrush;
90 90 QFont m_labelsFont;
91 91 int m_labelsAngle;
92 92
93 93 bool m_shadesVisible;
94 94 QPen m_shadesPen;
95 95 QBrush m_shadesBrush;
96 96 qreal m_shadesOpacity;
97 97
98 98 qreal m_min;
99 99 qreal m_max;
100 100
101 101 int m_ticksCount;
102 102 QChartAxisCategories m_category;
103 103 };
104 104
105 105 QTCOMMERCIALCHART_END_NAMESPACE
106 106 #endif /* QCHARTAXIS_H_ */
General Comments 0
You need to be logged in to leave comments. Login now