HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2127:74495bad3a7b

Refactor charviewer...

Michal Klocek -

r2127:74495bad3a7b

parent child

Context file:

r2127:74495bad3a7b

Collapse all files

demos/chartviewer/grid.cpp created 644 +238 0

@@ -0,0 +1,238
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "grid.h"
	22	#include "charts.h"
	23	#include <qchart.h>
	24	#include <QGraphicsGridLayout>
	25	#include <QGraphicsSceneMouseEvent>
	26	#include <QDebug>
	27
	28	Grid::Grid(int size,QGraphicsItem *parent):QGraphicsWidget(parent),
	29	m_listCount(3),
	30	m_valueMax(10),
	31	m_valueCount(7),
	32	m_size(size),
	33	m_dataTable(Model::generateRandomData(m_listCount, m_valueMax, m_valueCount)),
	34	m_rubberBand(new QGraphicsRectItem()),
	35	m_gridLayout(new QGraphicsGridLayout())
	36	{
	37	setLayout(m_gridLayout);
	38	m_rubberBand->setParentItem(this);
	39	m_rubberBand->setVisible(false);
	40	m_rubberBand->setZValue(2);
	41	}
	42
	43	Grid::~Grid()
	44	{
	45
	46	}
	47
	48	void Grid::createCharts()
	49	{
	50	clear();
	51
	52	Charts::ChartList list = Charts::chartList();
	53
	54	for (int i = 0; i < m_size * m_size; ++i) {
	55	QChart *chart = 0;
	56	if (i < list.size()) {
	57	chart = list.at(i)->createChart(m_dataTable);
	58	}
	59	else {
	60	chart = new QChart();
	61	chart->setTitle(QObject::tr("Empty"));
	62	}
	63
	64	m_gridLayout->addItem(chart, i / m_size, i % m_size);
	65	m_chartHash[chart] = i;
	66	}
	67
	68	}
	69
	70	void Grid::createCharts(const QString& category)
	71	{
	72	clear();
	73
	74	QChart *qchart(0);
	75	Charts::ChartList list = Charts::chartList();
	76
	77	int j = 0;
	78	for (int i = 0; i < list.size(); ++i) {
	79	Chart *chart = list.at(i);
	80	if (chart->category() == category && j < m_size * m_size) {
	81	qchart = list.at(i)->createChart(m_dataTable);
	82	m_gridLayout->addItem(qchart, j / m_size, j % m_size);
	83	m_chartHash[qchart] = j;
	84	j++;
	85	}
	86	}
	87	for (; j < m_size * m_size; ++j) {
	88	qchart = new QChart();
	89	qchart->setTitle(QObject::tr("Empty"));
	90	m_gridLayout->addItem(qchart, j / m_size, j % m_size);
	91	m_chartHash[qchart] = j;
	92	}
	93
	94	m_gridLayout->activate();
	95	}
	96
	97	void Grid::clear()
	98	{
	99	for (int i = 0; i < m_gridLayout->count(); ++i) {
	100	m_gridLayout->removeAt(i);
	101	}
	102
	103	qDeleteAll(m_chartHash.keys());
	104	m_chartHash.clear();
	105	}
	106
	107	QList<QChart*> Grid::charts()
	108	{
	109	return m_chartHash.keys();
	110	}
	111
	112	void Grid::setState(State state)
	113	{
	114	m_state = state;
	115	}
	116
	117	void Grid::setRubberPen(const QPen& pen)
	118	{
	119	m_rubberBand->setPen(pen);
	120	}
	121
	122	void Grid::replaceChart(QChart* oldChart, Chart* newChart)
	123	{
	124	int index = m_chartHash[oldChart];
	125	//not in 4.7.2 m_baseLayout->removeItem(qchart);
	126	for (int i = 0; i < m_gridLayout->count(); ++i) {
	127	if (m_gridLayout->itemAt(i) == oldChart) {
	128	m_gridLayout->removeAt(i);
	129	break;
	130	}
	131	}
	132	m_chartHash.remove(oldChart);
	133	QChart *chart = newChart->createChart(m_dataTable);
	134	m_gridLayout->addItem(chart, index / m_size, index % m_size);
	135	m_chartHash[chart] = index;
	136	delete oldChart;
	137	}
	138
	139	void Grid::mousePressEvent(QGraphicsSceneMouseEvent *event)
	140	{
	141	if (event->button() == Qt::LeftButton) {
	142
	143	m_origin = event->pos();
	144	m_currentState = NoState;
	145
	146	foreach (QChart *chart, charts()) {
	147
	148	QRectF geometryRect = chart->geometry();
	149	QRectF plotArea = chart->plotArea();
	150	plotArea.translate(geometryRect.topLeft());
	151	if (plotArea.contains(m_origin)) {
	152	m_currentState = m_state;
	153	if (m_currentState == NoState) emit chartSelected(chart);
	154	break;
	155	}
	156	}
	157	if (m_currentState == ZoomState) {
	158	m_rubberBand->setRect(QRectF(m_origin, QSize()));
	159	m_rubberBand->setVisible(true);
	160	}
	161
	162	event->accept();
	163	}
	164
	165	if (event->button() == Qt::RightButton) {
	166	m_origin = event->pos();
	167	m_currentState = m_state;
	168	}
	169	}
	170
	171	void Grid::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
	172	{
	173	if (m_currentState != NoState) {
	174
	175	foreach (QChart *chart, charts()) {
	176
	177	QRectF geometryRect = chart->geometry();
	178	QRectF plotArea = chart->plotArea();
	179	plotArea.translate(geometryRect.topLeft());
	180
	181	if (plotArea.contains(m_origin)) {
	182	if (m_currentState == ScrollState) {
	183	QPointF delta = m_origin - event->pos();
	184	chart->scroll(delta.x(), -delta.y());
	185	}
	186	if (m_currentState == ZoomState && plotArea.contains(event->pos()))
	187	m_rubberBand->setRect(QRectF(m_origin, event->pos()).normalized());
	188	break;
	189	}
	190	}
	191	if (m_currentState == ScrollState)
	192	m_origin = event->pos();
	193	event->accept();
	194	}
	195	}
	196
	197	void Grid::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
	198	{
	199	if (event->button() == Qt::LeftButton) {
	200	if (m_currentState == ZoomState) {
	201	m_rubberBand->setVisible(false);
	202
	203	foreach (QChart *chart, charts()) {
	204
	205	QRectF geometryRect = chart->geometry();
	206	QRectF plotArea = chart->plotArea();
	207	plotArea.translate(geometryRect.topLeft());
	208
	209	if (plotArea.contains(m_origin)) {
	210	QRectF rect = m_rubberBand->rect();
	211	rect.translate(-geometryRect.topLeft());
	212	chart->zoomIn(rect);
	213	break;
	214	}
	215	}
	216	}
	217
	218	m_currentState = NoState;
	219	event->accept();
	220	}
	221
	222	if (event->button() == Qt::RightButton) {
	223
	224	if (m_currentState == ZoomState) {
	225	foreach (QChart *chart, charts()) {
	226
	227	QRectF geometryRect = chart->geometry();
	228	QRectF plotArea = chart->plotArea();
	229	plotArea.translate(geometryRect.topLeft());
	230
	231	if (plotArea.contains(m_origin)) {
	232	chart->zoomOut();
	233	break;
	234	}
	235	}
	236	}
	237	}
	238	}

demos/chartviewer/grid.h created 644 +75 0

@@ -0,0 +1,75
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef GRID_H_
	22	#define GRID_H_
	23
	24	#include "model.h"
	25	#include <QGraphicsWidget>
	26	#include <QChartGlobal>
	27
	28	class QGraphicsGridLayout;
	29	class GridControl;
	30	class Chart;
	31
	32	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	33	class QChart;
	34	QTCOMMERCIALCHART_END_NAMESPACE
	35
	36	QTCOMMERCIALCHART_USE_NAMESPACE
	37
	38	class Grid : public QGraphicsWidget
	39	{
	40	Q_OBJECT
	41	public:
	42	enum State { NoState = 0, ZoomState, ScrollState};
	43	Grid(int size , QGraphicsItem *parent = 0 );
	44	~Grid();
	45	QList<QChart*> charts();
	46	void createCharts();
	47	void createCharts(const QString& category);
	48	void replaceChart(QChart* oldChart, Chart* newChart);
	49	void setState(State state);
	50	State state(){ return m_state; };
	51	void setRubberPen(const QPen& pen);
	52	Q_SIGNAL
	53	void chartSelected(QChart* chart);
	54	protected:
	55	void mousePressEvent(QGraphicsSceneMouseEvent *event);
	56	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
	57	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
	58	private:
	59	void clear();
	60	private:
	61	int m_listCount;
	62	int m_valueMax;
	63	int m_valueCount;
	64	int m_size;
	65	DataTable m_dataTable;
	66	QHash<QChart *, int> m_chartHash;
	67	GridControl* m_control;
	68	State m_state;
	69	State m_currentState;
	70	QPointF m_origin;
	71	QGraphicsRectItem *m_rubberBand;
	72	QGraphicsGridLayout* m_gridLayout;
	73	};
	74
	75	#endif /* GRID_H_ */

demos/chartviewer/chartviewer.pro +2 -2

             !include( ../demos.pri ):error( "Couldn't find the demos.pri file!" )
             include(charts/charts.pri)
             TARGET = chartviewer
             QT += opengl
             INCLUDEPATH += .
-            SOURCES += main.cpp window.cpp view.cpp
+            SOURCES += main.cpp window.cpp view.cpp grid.cpp
-            HEADERS += window.h view.h charts.h model.h
+            HEADERS += window.h view.h charts.h model.h grid.h

demos/chartviewer/window.cpp +31 -198

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "window.h"
             #include "view.h"
+            #include "grid.h"
             #include "charts.h"
             #include <QChartView>
             #include <QAreaSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QGraphicsScene>
-            #include <QGraphicsGridLayout>
             #include <QGraphicsLinearLayout>
             #include <QGraphicsProxyWidget>
             #include <QGLWidget>
             #include <QApplication>
             #include <QDebug>
             #include <QMenu>
             Window::Window(const QVariantHash& parameters,QWidget *parent) :
                 QMainWindow(parent),
-                m_listCount(3),
-                m_valueMax(10),
-                m_valueCount(7),
                 m_scene(new QGraphicsScene(this)),
                 m_view(0),
-                m_dataTable(Model::generateRandomData(m_listCount, m_valueMax, m_valueCount)),
                 m_form(0),
                 m_themeComboBox(0),
                 m_antialiasCheckBox(0),
                 m_animatedComboBox(0),
                 m_legendComboBox(0),
                 m_templateComboBox(0),
                 m_openGLCheckBox(0),
                 m_zoomCheckBox(0),
                 m_scrollCheckBox(0),
-                m_rubberBand(new QGraphicsRectItem()),
+                m_baseLayout(new QGraphicsLinearLayout()),
-                m_baseLayout(new QGraphicsGridLayout()),
                 m_menu(createMenu()),
-                m_state(NoState),
+                m_template(0),
-                m_currentState(NoState),
+                m_grid(new Grid(3))
-                m_template(0)
             {
                 createProxyWidgets();
                 // create layout
                 QGraphicsLinearLayout *settingsLayout = new QGraphicsLinearLayout();
                 settingsLayout->setOrientation(Qt::Vertical);
                 settingsLayout->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
                 settingsLayout->addItem(m_widgetHash["openGLCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["antialiasCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["themeLabel"]);
                 settingsLayout->addItem(m_widgetHash["themeComboBox"]);
                 settingsLayout->addItem(m_widgetHash["animationsLabel"]);
                 settingsLayout->addItem(m_widgetHash["animatedComboBox"]);
                 settingsLayout->addItem(m_widgetHash["legendLabel"]);
                 settingsLayout->addItem(m_widgetHash["legendComboBox"]);
                 settingsLayout->addItem(m_widgetHash["templateLabel"]);
                 settingsLayout->addItem(m_widgetHash["templateComboBox"]);
                 settingsLayout->addItem(m_widgetHash["scrollCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["zoomCheckBox"]);
                 settingsLayout->addStretch();
-                m_baseLayout->addItem(settingsLayout, 0, 3, 2, 1);
-                //create charts
+                m_grid->createCharts();
-                Charts::ChartList list = Charts::chartList();
-                for (int i = 0; i < 9; ++i) {
+                m_baseLayout->setOrientation(Qt::Horizontal);
-                    QChart *chart = 0;
+                m_baseLayout->addItem(m_grid);
-                    if (i < list.size()) {
+                m_baseLayout->addItem(settingsLayout);
-                        chart = list.at(i)->createChart(m_dataTable);
-                    } else {
-                        chart = new QChart();
-                        chart->setTitle(tr("Empty"));
-                    m_baseLayout->addItem(chart, i / 3, i % 3);
-                    m_chartHash[chart] = i;
                 m_form = new QGraphicsWidget();
                 m_form->setLayout(m_baseLayout);
                 m_scene->addItem(m_form);
-                m_scene->addItem(m_rubberBand);
-                m_rubberBand->setVisible(false);
                 m_view = new View(m_scene, m_form);
                 m_view->setMinimumSize(m_form->minimumSize().toSize());
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
                 initializeFromParamaters(parameters);
                 updateUI();
                 setCentralWidget(m_view);
                 connectSignals();
             }
             Window::~Window()
             {
             }
             void Window::connectSignals()
             {
                 QObject::connect(m_form, SIGNAL(geometryChanged()), this , SLOT(handleGeometryChanged()));
                 QObject::connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_openGLCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_zoomCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_scrollCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_templateComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
+                QObject::connect(m_grid, SIGNAL(chartSelected(QChart*)),this,SLOT(handleChartSelected(QChart*)));
             }
             void Window::createProxyWidgets()
             {
                 m_themeComboBox = createThemeBox();
                 m_antialiasCheckBox = new QCheckBox(tr("Anti-aliasing"));
                 m_animatedComboBox = createAnimationBox();
                 m_legendComboBox = createLegendBox();
                 m_openGLCheckBox = new QCheckBox(tr("OpenGL"));
                 m_zoomCheckBox = new QCheckBox(tr("Zoom"));
                 m_scrollCheckBox = new QCheckBox(tr("Scroll"));
                 m_templateComboBox = createTempleteBox();
                 m_widgetHash["themeComboBox"] = m_scene->addWidget(m_themeComboBox);
                 m_widgetHash["antialiasCheckBox"] = m_scene->addWidget(m_antialiasCheckBox);
                 m_widgetHash["animatedComboBox"] = m_scene->addWidget(m_animatedComboBox);
                 m_widgetHash["legendComboBox"] = m_scene->addWidget(m_legendComboBox);
                 m_widgetHash["openGLCheckBox"] = m_scene->addWidget(m_openGLCheckBox);
                 m_widgetHash["themeLabel"] = m_scene->addWidget(new QLabel("Theme"));
                 m_widgetHash["animationsLabel"] = m_scene->addWidget(new QLabel("Animations"));
                 m_widgetHash["legendLabel"] = m_scene->addWidget(new QLabel("Legend"));
                 m_widgetHash["templateLabel"] = m_scene->addWidget(new QLabel("Chart template"));
                 m_widgetHash["templateComboBox"] = m_scene->addWidget(m_templateComboBox);
                 m_widgetHash["zoomCheckBox"] = m_scene->addWidget(m_zoomCheckBox);
                 m_widgetHash["scrollCheckBox"] = m_scene->addWidget(m_scrollCheckBox);
             }
             QComboBox *Window::createThemeBox()
             {
                 QComboBox *themeComboBox = new ComboBox(this);
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox *Window::createAnimationBox()
             {
                 QComboBox *animationComboBox = new ComboBox(this);
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QComboBox *Window::createLegendBox()
             {
                 QComboBox *legendComboBox = new ComboBox(this);
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", Qt::AlignTop);
                 legendComboBox->addItem("Legend Bottom", Qt::AlignBottom);
                 legendComboBox->addItem("Legend Left", Qt::AlignLeft);
                 legendComboBox->addItem("Legend Right", Qt::AlignRight);
                 return legendComboBox;
             }
             QComboBox *Window::createTempleteBox()
             {
                 QComboBox *templateComboBox = new ComboBox(this);
                 templateComboBox->addItem("No Template", 0);
                 Charts::ChartList list = Charts::chartList();
                 QMultiMap<QString, Chart *> categoryMap;
                 foreach (Chart *chart, list)
                     categoryMap.insertMulti(chart->category(), chart);
                 foreach (const QString &category, categoryMap.uniqueKeys())
                     templateComboBox->addItem(category, category);
                 return templateComboBox;
             }
             void Window::initializeFromParamaters(const QVariantHash& parameters)
             {
                 if (parameters.contains("template")) {
                     QString t = parameters["template"].toString();
                     for (int i = 0; i < m_templateComboBox->count(); ++i) {
                         if (m_templateComboBox->itemText(i) == t) {
                             m_templateComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
                 if (parameters.contains("opengl")) {
                     bool checked = parameters["opengl"].toBool();
                     m_openGLCheckBox->setChecked(checked);
                 }
                 if (parameters.contains("theme")) {
                     QString t = parameters["theme"].toString();
                     for (int i = 0; i < m_themeComboBox->count(); ++i) {
                         if (m_themeComboBox->itemText(i) == t) {
                             m_themeComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
                 if (parameters.contains("animation")) {
                     QString t = parameters["animation"].toString();
                     for (int i = 0; i < m_animatedComboBox->count(); ++i) {
                         if (m_animatedComboBox->itemText(i) == t) {
                             m_animatedComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
                 if (parameters.contains("legend")) {
                     QString t = parameters["legend"].toString();
                     for (int i = 0; i < m_legendComboBox->count(); ++i) {
                         if (m_legendComboBox->itemText(i) == t) {
                             m_legendComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
             }
             void Window::updateUI()
             {
                 checkTemplate();
                 checkOpenGL();
                 checkTheme();
                 checkAnimationOptions();
                 checkLegend();
                 checkState();
             }
             void Window::checkLegend()
             {
                 Qt::Alignment alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
-                    foreach (QChart *chart, m_chartHash.keys())
+                    foreach (QChart *chart, m_grid->charts())
                         chart->legend()->hide();
                 } else {
-                    foreach (QChart *chart, m_chartHash.keys()) {
+                    foreach (QChart *chart, m_grid->charts()) {
                         chart->legend()->setAlignment(alignment);
                         chart->legend()->show();
                     }
                 }
             }
             void Window::checkOpenGL()
             {
                 bool opengl = m_openGLCheckBox->isChecked();
                 bool isOpengl = qobject_cast<QGLWidget *>(m_view->viewport());
                 if ((isOpengl && !opengl) || (!isOpengl && opengl)) {
                     m_view->deleteLater();
                     m_view = new View(m_scene, m_form);
                     m_view->setViewport(!opengl ? new QWidget() : new QGLWidget());
                     setCentralWidget(m_view);
                 }
                 bool antialias = m_antialiasCheckBox->isChecked();
                 if (opengl)
                     m_view->setRenderHint(QPainter::HighQualityAntialiasing, antialias);
                 else
                     m_view->setRenderHint(QPainter::Antialiasing, antialias);
             }
             void Window::checkAnimationOptions()
             {
                 QChart::AnimationOptions options(
                     m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
-                if (!m_chartHash.isEmpty() && m_chartHash.keys().at(0)->animationOptions() != options) {
+                QList<QChart*> charts = m_grid->charts();
-                    foreach (QChart *chart, m_chartHash.keys())
+                if (!charts.isEmpty() && charts.at(0)->animationOptions() != options) {
+                    foreach (QChart *chart, charts)
                         chart->setAnimationOptions(options);
                 }
             }
             void Window::checkState()
             {
                 bool scroll = m_scrollCheckBox->isChecked();
-                if (m_state != ScrollState && scroll) {
-                    m_state = ScrollState;
+                if (m_grid->state() != Grid::ScrollState && scroll) {
+                    m_grid->setState(Grid::ScrollState);
                     m_zoomCheckBox->setChecked(false);
-                } else if (!scroll && m_state == ScrollState) {
+                } else if (!scroll && m_grid->state() == Grid::ScrollState) {
-                    m_state = NoState;
+                    m_grid->setState(Grid::NoState);
                 }
                 bool zoom = m_zoomCheckBox->isChecked();
-                if (m_state != ZoomState && zoom) {
+                if (m_grid->state() != Grid::ZoomState && zoom) {
-                    m_state = ZoomState;
+                    m_grid->setState(Grid::ZoomState);
                     m_scrollCheckBox->setChecked(false);
-                } else if (!zoom && m_state == ZoomState) {
+                } else if (!zoom && m_grid->state() == Grid::ZoomState) {
-                    m_state = NoState;
+                    m_grid->setState(Grid::NoState);
                 }
             }
             void Window::checkTemplate()
             {
                 int index = m_templateComboBox->currentIndex();
                 if (m_template == index || index == 0)
                     return;
                 m_template = index;
                 QString category = m_templateComboBox->itemData(index).toString();
-                Charts::ChartList list = Charts::chartList();
+                m_grid->createCharts(category);
-                QList<QChart *> qchartList = m_chartHash.keys();
-                foreach (QChart *qchart, qchartList) {
-                    for (int i = 0 ; i < m_baseLayout->count(); ++i) {
-                        if (m_baseLayout->itemAt(i) == qchart) {
-                            m_baseLayout->removeAt(i);
-                            break;
-                m_chartHash.clear();
-                qDeleteAll(qchartList);
-                QChart *qchart(0);
-                int j = 0;
-                for (int i = 0; i < list.size(); ++i) {
-                    Chart *chart = list.at(i);
-                    if (chart->category() == category && j < 9) {
-                        qchart = list.at(i)->createChart(m_dataTable);
-                        m_baseLayout->addItem(qchart, j / 3, j % 3);
-                        m_chartHash[qchart] = j;
-                        j++;
-                for (; j < 9; ++j) {
-                    qchart = new QChart();
-                    qchart->setTitle(tr("Empty"));
-                    m_baseLayout->addItem(qchart, j / 3, j % 3);
-                    m_chartHash[qchart] = j;
-                m_baseLayout->activate();
             }
             void Window::checkTheme()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(
                                                m_themeComboBox->currentIndex()).toInt();
-                foreach (QChart *chart, m_chartHash.keys())
+                foreach (QChart *chart, m_grid->charts())
                     chart->setTheme(theme);
                 QPalette pal = window()->palette();
                 if (theme == QChart::ChartThemeLight) {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeDark) {
                     pal.setColor(QPalette::Window, QRgb(0x121218));
                     pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                 } else if (theme == QChart::ChartThemeBlueCerulean) {
                     pal.setColor(QPalette::Window, QRgb(0x40434a));
                     pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                 } else if (theme == QChart::ChartThemeBrownSand) {
                     pal.setColor(QPalette::Window, QRgb(0x9e8965));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeBlueNcs) {
                     pal.setColor(QPalette::Window, QRgb(0x018bba));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeHighContrast) {
                     pal.setColor(QPalette::Window, QRgb(0xffab03));
                     pal.setColor(QPalette::WindowText, QRgb(0x181818));
                 } else if (theme == QChart::ChartThemeBlueIcy) {
                     pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 }
                 foreach (QGraphicsProxyWidget *widget, m_widgetHash)
                     widget->setPalette(pal);
                 m_view->setBackgroundBrush(pal.color((QPalette::Window)));
-                m_rubberBand->setPen(pal.color((QPalette::WindowText)));
+                m_grid->setRubberPen(pal.color((QPalette::WindowText)));
-            void Window::mousePressEvent(QMouseEvent *event)
-                if (event->button() == Qt::LeftButton) {
-                    m_origin = event->pos();
-                    m_currentState = NoState;
-                    foreach (QChart *chart, m_chartHash.keys()) {
-                        QRectF geometryRect = chart->geometry();
-                        QRectF plotArea = chart->plotArea();
-                        plotArea.translate(geometryRect.topLeft());
-                        if (plotArea.contains(m_origin)) {
-                            m_currentState = m_state;
-                            if (m_currentState == NoState && m_templateComboBox->currentIndex() == 0)
-                                handleMenu(chart);
-                            break;
-                    if (m_currentState == ZoomState) {
-                        m_rubberBand->setRect(QRectF(m_origin, QSize()));
-                        m_rubberBand->setVisible(true);
-                    event->accept();
-                if (event->button() == Qt::RightButton) {
-                    m_origin = event->pos();
-                    m_currentState = m_state;
-            void Window::mouseMoveEvent(QMouseEvent *event)
-                if (m_currentState != NoState) {
-                    foreach (QChart *chart, m_chartHash.keys()) {
-                        QRectF geometryRect = chart->geometry();
-                        QRectF plotArea = chart->plotArea();
-                        plotArea.translate(geometryRect.topLeft());
-                        if (plotArea.contains(m_origin)) {
-                            if (m_currentState == ScrollState) {
-                                QPointF delta = m_origin - event->pos();
-                                chart->scroll(delta.x(), -delta.y());
-                            if (m_currentState == ZoomState && plotArea.contains(event->pos()))
-                                m_rubberBand->setRect(QRectF(m_origin, event->pos()).normalized());
-                            break;
-                    if (m_currentState == ScrollState)
-                        m_origin = event->pos();
-                    event->accept();
-            void Window::mouseReleaseEvent(QMouseEvent *event)
-                if (event->button() == Qt::LeftButton) {
-                    if (m_currentState == ZoomState) {
-                        m_rubberBand->setVisible(false);
-                        foreach (QChart *chart, m_chartHash.keys()) {
-                            QRectF geometryRect = chart->geometry();
-                            QRectF plotArea = chart->plotArea();
-                            plotArea.translate(geometryRect.topLeft());
-                            if (plotArea.contains(m_origin)) {
-                                QRectF rect = m_rubberBand->rect();
-                                rect.translate(-geometryRect.topLeft());
-                                chart->zoomIn(rect);
-                                break;
-                    m_currentState = NoState;
-                    event->accept();
-                if (event->button() == Qt::RightButton) {
-                    if (m_currentState == ZoomState) {
-                        foreach (QChart *chart, m_chartHash.keys()) {
-                            QRectF geometryRect = chart->geometry();
-                            QRectF plotArea = chart->plotArea();
-                            plotArea.translate(geometryRect.topLeft());
-                            if (plotArea.contains(m_origin)) {
-                                chart->zoomOut();
-                                break;
             }
             void Window::comboBoxFocused(QComboBox *combobox)
             {
                 foreach (QGraphicsProxyWidget *widget , m_widgetHash) {
                     if (widget->widget() == combobox)
                         widget->setZValue(2.0);
                     else
                         widget->setZValue(0.0);
                 }
             }
-            void Window::handleMenu(QChart *qchart)
+            void Window::handleChartSelected(QChart *qchart)
             {
+                if(m_templateComboBox->currentIndex() != 0) return;
                 QAction *chosen = m_menu->exec(QCursor::pos());
                 if (chosen) {
                     Chart *chart = (Chart *) chosen->data().value<void *>();
-                    int index = m_chartHash[qchart];
+                    m_grid->replaceChart(qchart,chart);
-                    //not in 4.7.2 m_baseLayout->removeItem(qchart);
-                    for (int i = 0 ; i < m_baseLayout->count(); ++i) {
-                        if (m_baseLayout->itemAt(i) == qchart) {
-                            m_baseLayout->removeAt(i);
-                            break;
-                    m_chartHash.remove(qchart);
-                    QChart *newChart = chart->createChart(m_dataTable);
-                    m_baseLayout->addItem(newChart, index / 3, index % 3);
-                    m_chartHash[newChart] = index;
-                    delete qchart;
                     updateUI();
                 }
             }
             QMenu *Window::createMenu()
             {
                 Charts::ChartList list = Charts::chartList();
                 QMultiMap<QString, Chart *> categoryMap;
                 QMenu *result = new QMenu(this);
                 foreach (Chart *chart, list)
                     categoryMap.insertMulti(chart->category(), chart);
                 foreach (const QString &category, categoryMap.uniqueKeys()) {
                     QMenu *menu(0);
                     QMultiMap<QString, Chart *> subCategoryMap;
                     if (category.isEmpty()) {
                         menu = result;
                     } else {
                         menu = new QMenu(category, this);
                         result->addMenu(menu);
                     }
                     foreach (Chart *chart, categoryMap.values(category))
                         subCategoryMap.insert(chart->subCategory(), chart);
                     foreach (const QString &subCategory, subCategoryMap.uniqueKeys()) {
                         QMenu *subMenu(0);
                         if (subCategory.isEmpty()) {
                             subMenu = menu;
                         } else {
                             subMenu = new QMenu(subCategory, this);
                             menu->addMenu(subMenu);
                         }
                         foreach (Chart *chart, subCategoryMap.values(subCategory)) {
                             createMenuAction(subMenu, QIcon(), chart->name(),
                                              qVariantFromValue((void *) chart));
                         }
                     }
                 }
                 return result;
             }
             QAction *Window::createMenuAction(QMenu *menu, const QIcon &icon, const QString &text,
                                               const QVariant &data)
             {
                 QAction *action = menu->addAction(icon, text);
                 action->setCheckable(false);
                 action->setData(data);
                 return action;
             }
             void Window::handleGeometryChanged()
             {
                 QSizeF size = m_baseLayout->sizeHint(Qt::MinimumSize);
                 m_view->scene()->setSceneRect(0, 0, this->width(), this->height());
                 m_view->setMinimumSize(size.toSize());
             }

demos/chartviewer/window.h +8 -17

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef WINDOW_H
             #define WINDOW_H
-            #include "model.h"
             #include <QMainWindow>
             #include <QChartGlobal>
             #include <QHash>
             #include <QComboBox>
             class QCheckBox;
             class QGraphicsRectItem;
             class QGraphicsScene;
             class QGraphicsWidget;
             class View;
-            class QGraphicsGridLayout;
+            class QGraphicsLinearLayout;
             class Chart;
+            class Grid;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             QTCOMMERCIALCHART_END_NAMESPACE
             QTCOMMERCIALCHART_USE_NAMESPACE
             class Window: public QMainWindow
             {
                 Q_OBJECT
-                enum State { NoState = 0, ZoomState, ScrollState};
             public:
                 explicit Window(const QVariantHash& parameters, QWidget *parent = 0);
                 ~Window();
             private Q_SLOTS:
                 void updateUI();
                 void handleGeometryChanged();
+                void handleChartSelected(QChart *chart);
             private:
                 QComboBox *createThemeBox();
                 QComboBox *createAnimationBox();
                 QComboBox *createLegendBox();
                 QComboBox *createTempleteBox();
                 void connectSignals();
                 void createProxyWidgets();
                 void comboBoxFocused(QComboBox *combox);
                 inline void checkAnimationOptions();
                 inline void checkLegend();
                 inline void checkOpenGL();
                 inline void checkTheme();
                 inline void checkState();
                 inline void checkTemplate();
                 QMenu *createMenu();
-                void handleMenu(QChart *chart);
                 QAction *createMenuAction(QMenu *menu, const QIcon &icon, const QString &text, const QVariant &data);
                 void initializeFromParamaters(const QVariantHash& parameters);
             protected:
-                void mousePressEvent(QMouseEvent *event);
+                //void mousePressEvent(QMouseEvent *event);
-                void mouseMoveEvent(QMouseEvent *event);
+                //void mouseMoveEvent(QMouseEvent *event);
-                void mouseReleaseEvent(QMouseEvent *event);
+                //void mouseReleaseEvent(QMouseEvent *event);
             private:
-                int m_listCount;
-                int m_valueMax;
-                int m_valueCount;
                 QGraphicsScene *m_scene;
                 View *m_view;
                 QHash<QString, QGraphicsProxyWidget *> m_widgetHash;
-                QHash<QChart *, int> m_chartHash;
-                DataTable m_dataTable;
                 QGraphicsWidget *m_form;
                 QComboBox *m_themeComboBox;
                 QCheckBox *m_antialiasCheckBox;
                 QComboBox *m_animatedComboBox;
                 QComboBox *m_legendComboBox;
                 QComboBox *m_templateComboBox;
                 QCheckBox *m_openGLCheckBox;
                 QCheckBox *m_zoomCheckBox;
                 QCheckBox *m_scrollCheckBox;
-                QPoint m_origin;
+                QGraphicsLinearLayout *m_baseLayout;
-                QGraphicsRectItem *m_rubberBand;
-                QGraphicsGridLayout *m_baseLayout;
                 QMenu *m_menu;
-                State m_state;
-                State m_currentState;
                 int m_template;
+                Grid* m_grid;
                 friend class ComboBox;
             };
             class ComboBox: public QComboBox
             {
             public:
                 ComboBox(Window *window, QWidget *parent = 0): QComboBox(parent), m_window(window)
                 {}
             protected:
                 void focusInEvent(QFocusEvent *e) {
                     QComboBox::focusInEvent(e);
                     m_window->comboBoxFocused(this);
                 }
             private:
                 Window *m_window;
             };
             #endif

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages