HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r262:461b2e61910e

Adds ZOrder enum to presenter

Michal Klocek -

r262:461b2e61910e

parent child

Context file:

r262:461b2e61910e

Collapse all files

src/axisitem.cpp +5 -4

             #include "axisitem_p.h"
             #include "qchartaxis.h"
+            #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_type(type),
             m_labelsAngle(0),
             m_shadesEnabled(true),
             m_grid(parent),
             m_shades(parent),
-            m_labels(parent)
+            m_labels(parent),
+            m_origin(0,0)
             {
                 //initial initialization
-                m_shades.setZValue(0);
+                m_shades.setZValue(ChartPresenter::ShadesZValue);
-                m_grid.setZValue(2);
+                m_grid.setZValue(ChartPresenter::GridZValue);
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
             void AxisItem::createItems(int count)
             {
                 for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem(this));
                        m_labels.addToGroup(new QGraphicsSimpleTextItem(this));
                        if(i%2) m_shades.addToGroup(new QGraphicsRectItem(this));
                    }
             }
             void AxisItem::clear()
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     delete item;
                 }
                 m_thicksList.clear();
             }
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             }
             void AxisItem::updateItem(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 switch (m_type)
                   {
                       case X_AXIS:
                       {
                           const qreal deltaX = m_rect.width() / (count-1);
                           m_axis.setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                           for (int i = 0; i < count; ++i) {
                               int x = i * deltaX + m_rect.left();
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(x, m_rect.top(), x, m_rect.bottom());
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                               labelItem->setText(m_thicksList.at(i));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(x - center.x(), m_rect.bottom() + label_padding);
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(x,m_rect.top(),deltaX,m_rect.height());
                               }
                           }
                       }
                       break;
                       case Y_AXIS:
                       {
                           const qreal deltaY = m_rect.height()/ (count-1);
                           m_axis.setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                           for (int i = 0; i < count; ++i) {
                               int y = i * -deltaY + m_rect.bottom();
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(m_rect.left() , y, m_rect.right(), y);
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                               labelItem->setText(m_thicksList.at(i));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(m_rect.left() -  labelItem->boundingRect().width() - label_padding , y-center.y());
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(m_rect.left(),y,m_rect.width(),deltaY);
                               }
                           }
                       }
                       break;
                       default:
                       qDebug()<<"Unknown axis type";
                       break;
                   }
             }
             void AxisItem::handleAxisUpdate(QChartAxis* axis)
             {
                 if(axis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(axis->isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(axis->isLabelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(axis->isShadesVisible()) {
                     setShadesOpacity(axis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(axis->labelsAngle());
                 setAxisPen(axis->axisPen());
                 setLabelsPen(axis->labelsPen());
                 setLabelsBrush(axis->labelsBrush());
                 setLabelsFont(axis->labelFont());
                 setGridPen(axis->gridPen());
                 setShadesPen(axis->shadesPen());
                 setShadesBrush(axis->shadesBrush());
             }
             void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_thicksList=labels;
                 QList<QGraphicsItem*> items = m_labels.childItems();
                 if(items.size()!=m_thicksList.size()){
                    clear();
                    m_thicksList=labels;
                    createItems(m_thicksList.size());
                    updateItem(m_thicksList.size());
                    items = m_labels.childItems();
                    handleAxisUpdate(axis);
                  }
                 Q_ASSERT(items.size()==m_thicksList.size());
                 int i=0;
                 foreach(QGraphicsItem* item, items){
                     static_cast<QGraphicsSimpleTextItem*>(item)->setText(m_thicksList.at(i));
                     i++;
                 }
                 update();
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 updateItem(m_thicksList.size());
                 update();
             }
             void AxisItem::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
             qreal AxisItem::axisOpacity() const
             {
                 return m_axis.opacity();
             }
             void AxisItem::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal AxisItem::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void AxisItem::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal AxisItem::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void AxisItem::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal AxisItem::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void AxisItem::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void AxisItem::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void AxisItem::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setAxisPen(const QPen& pen)
             {
                 m_axis.setPen(pen);
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +4 -3

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "domain_p.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class AxisItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
                 ~AxisItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 AxisType axisType() const {return m_type;};
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setShadesBrush(const QBrush& brush);
                 void setShadesPen(const QPen& pen);
                 void setAxisPen(const QPen& pen);
                 void setGridPen(const QPen& pen);
                 void setLabelsPen(const QPen& pen);
                 void setLabelsBrush(const QBrush& brush);
                 void setLabelsFont(const QFont& font);
             public slots:
-                void handleAxisUpdate(QChartAxis* axis);
+                void handleAxisUpdate(QChartAxis* axis); //look and feel
-                void handleLabelsChanged(QChartAxis* axis,const QStringList& labels);
+                void handleLabelsChanged(QChartAxis* axis,const QStringList& labels); //labels from dataset
-                void handleGeometryChanged(const QRectF& size);
+                void handleGeometryChanged(const QRectF& size); // geometry from presenter
             protected:
                 void updateItem(int count);
             private:
                 void clear();
                 void createItems(int count);
             private:
                 AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 bool m_shadesEnabled;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
                 QGraphicsLineItem m_axis;
                 QStringList m_thicksList;
+                QPointF m_origin;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/chartpresenter_p.h +2 0

             #ifndef CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class ChartDataSet;
             //class QChart;
             class Domain;
             class AxisItem;
             class ChartTheme;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
+                enum ZValues { BackgroundZValue = -1 , ShadesZValue, GridZValue,  AxisZValue , LineChartZValue };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 void setMargin(int margin);
                 int margin() const;
                 QRectF geometry() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme();
             private:
                 void createConnections();
             public slots:
                 void handleSeriesAdded(QChartSeries* series);
                 void handleSeriesRemoved(QChartSeries* series);
                 void handleAxisAdded(QChartAxis* axis);
                 void handleAxisRemoved(QChartAxis* axis);
                 void handleSeriesDomainChanged(QChartSeries* series, const Domain& domain);
                 void handleAxisLabelsChanged(QChartAxis* axis, const QStringList& labels);
                 void handleSeriesChanged(QChartSeries* series);
                 void handleGeometryChanged();
             signals:
                 void geometryChanged(const QRectF& rect);
             private:
                 QMap<QChartSeries*,ChartItem*> m_chartItems;
                 QMap<QChartAxis*,AxisItem*> m_axisItems;
                 QChart* m_chart;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 int m_marginSize;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/linechart/linechartitem.cpp +1 -1

             #include "linechartitem_p.h"
             #include "qlinechartseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimazie : remove points which are not visible
             LineChartItem::LineChartItem(ChartPresenter* presenter, QLineChartSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_presenter(presenter),
             m_series(series),
             m_dirtyData(false),
             m_dirtyGeometry(false),
             m_dirtyDomain(false)
             {
+                setZValue(ChartPresenter::LineChartZValue);
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::addPoints(const QVector<QPointF>& points)
             {
                 m_data = points;
                 for(int i=0; i<m_data.size();i++){
                 const QPointF& point =m_data[i];
                 QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
                 item->setPos(point.x()-1,point.y()-1);;
                 if(!m_clipRect.contains(point) || !m_series->isPointsVisible()) item->setVisible(false);
                 m_points << item;
                 }
             }
             void LineChartItem::addPoint(const QPointF& point)
             {
             	m_data << point;
             	QGraphicsRectItem* item = new QGraphicsRectItem(0,0,3,3,this);
             	m_clipRect.contains(point);
             	item->setPos(point.x()-1,point.y()-1);
             	if(!m_clipRect.contains(point) || !m_series->isPointsVisible()) item->setVisible(false);
             	m_points << item;
             }
             void LineChartItem::removePoint(const QPointF& point)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 int index = m_data.lastIndexOf(point,0);
                 m_data.remove(index);
                 delete(m_points.takeAt(index));
             }
             void LineChartItem::setPoint(const QPointF& oldPoint,const QPointF& newPoint)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 int index = m_data.lastIndexOf(oldPoint,0);
                 if(index > -1){
                 m_data.replace(index,newPoint);
                 QGraphicsItem* item = m_points.at(index);
                 item->setPos(newPoint.x()-1,newPoint.y()-1);
                 }
             }
             void LineChartItem::setPoint(int index,const QPointF& point)
             {
                 Q_ASSERT(m_data.count() == m_points.count());
                 Q_ASSERT(index>=0);
                 m_data.replace(index,point);
                 QGraphicsItem* item = m_points.at(index);
                 item->setPos(point.x()-1,point.y()-1);
             }
             void LineChartItem::clear()
             {
             	 qDeleteAll(m_points);
             	 m_points.clear();
             	 m_hash.clear();
             	 m_path = QPainterPath();
             	 m_rect = QRect();
             	 m_data.clear();
             }
             void LineChartItem::clearView()
             {
                  qDeleteAll(m_points);
                  m_points.clear();
                  m_path = QPainterPath();
                  m_rect = QRect();
                  m_data.clear();
             }
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(widget);
                 Q_UNUSED(option);
                 painter->save();
                 painter->setPen(m_pen);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 painter->restore();
             }
             void LineChartItem::calculatePoint(QPointF& point, int index, const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const
             {
                 const qreal deltaX = size.width()/domain.spanX();
                 const qreal deltaY = size.height()/domain.spanY();
                 qreal x = (series->x(index) - domain.m_minX)* deltaX;
                 qreal y = (series->y(index) - domain.m_minY)*-deltaY + size.height();
                 point.setX(x);
                 point.setY(y);
             }
             void LineChartItem::calculatePoints(QVector<QPointF>& points, QHash<int,int>& hash,const QLineChartSeries* series,const QSizeF& size, const Domain& domain) const
             {
                 const qreal deltaX = size.width()/domain.spanX();
                 const qreal deltaY = size.height()/domain.spanY();
                 for (int i = 0; i < series->count(); ++i) {
                   qreal x = (series->x(i) - domain.m_minX)* deltaX;
                   qreal y = (series->y(i) - domain.m_minY)*-deltaY + size.height();
                   hash[i] = points.size();
                   points << QPointF(x,y);
                 }
             }
             void LineChartItem::updateDomain()
             {
                 clear();
                 prepareGeometryChange();
             	calculatePoints(m_data,m_hash,m_series,m_size, m_domain);
             	addPoints(m_data);
             }
             void LineChartItem::updateData()
             {
                 //for now the same
                 updateDomain();
             }
             void LineChartItem::updateGeometry()
             {
                if(m_data.size()==0) return;
                prepareGeometryChange();
                QPainterPath path;
                const QPointF& point = m_data.at(0);
                path.moveTo(point);
                foreach( const QPointF& point , m_data) {
                    path.lineTo(point);
                }
                m_path = path;
                m_rect = path.boundingRect();
             }
             void LineChartItem::setPen(const QPen& pen)
             {
                 m_pen = pen;
             }
             //handlers
             void LineChartItem::handleModelChanged(int index)
             {
                 Q_ASSERT(index<m_series->count());
                 if(m_hash.contains(index)){
                     int i = m_hash.value(index);
                     QPointF point;
                     calculatePoint(point,index,m_series,m_size,m_domain);
                     setPoint(i,point);
                 }
                 update();
             }
             void LineChartItem::handleDomainChanged(const Domain& domain)
             {
                 m_domain = domain;
                 updateDomain();
                 update();
             }
             void LineChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
                 m_size=rect.size();
                 m_clipRect=rect.translated(-rect.topLeft());
                 updateDomain();
                 updateGeometry();
                 setPos(rect.topLeft());
                 update();
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +5 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* series,QChartAxis* axisY)
             {
                 m_dataset->addSeries(series,axisY);
             }
             void QChart::removeSeries(QChartSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setPlainText(title);
             }
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
-                    m_backgroundItem->setZValue(-1);
+                    m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
-                if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
+                if(!m_titleItem) {
+                    m_titleItem = new QGraphicsTextItem(this);
+                    m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
+                }
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             void QChart::zoomIn()
             {
                 if (!m_dataset->nextDomain()) {
                     QRectF rect = m_presenter->geometry();
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_presenter->geometry().center());
                     zoomIn(rect);
                 }
             }
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                    QRectF r = rect.normalized();
                    int margin = m_presenter->margin();
                    r.translate(-margin, -margin);
                    m_dataset->addDomain(r,m_presenter->geometry());
             }
             void QChart::zoomOut()
             {
                 m_dataset->previousDomain();
             }
             void QChart::zoomReset()
             {
                 m_dataset->clearDomains();
             }
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

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