HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r365:884af9f4ef86

Fix labels, shades visible naming convention

Michal Klocek -

r365:884af9f4ef86

parent child

Context file:

r365:884af9f4ef86

Collapse all files

src/axisitem.cpp +2 -2

             #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_grid(parent),
             m_shades(parent),
             m_labels(parent),
             m_axis(parent)
             {
                 //initial initialization
                 m_axis.setZValue(ChartPresenter::AxisZValue);
                 m_shades.setZValue(ChartPresenter::ShadesZValue);
                 m_grid.setZValue(ChartPresenter::GridZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return QRectF();
             }
             void AxisItem::createItems(int count)
             {
                 if(m_axis.children().size()==0)
                        m_axis.addToGroup(new QGraphicsLineItem());
                 for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem());
                        m_labels.addToGroup(new QGraphicsSimpleTextItem());
                        if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem());
                        m_axis.addToGroup(new QGraphicsLineItem());
                    }
             }
             void AxisItem::clear(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 QList<QGraphicsItem *> axis = m_axis.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     if(lines.size()%2) delete(shades.takeLast());
                     delete(axis.takeLast());
                 }
                 m_thicksList.clear();
             }
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             void AxisItem::updateItems(QVector<qreal>& vector)
             {
                 calculateLayout(vector);
                 if(vector.count()==0) return;
                 applyLayout(vector);
             }
             void AxisItem::handleAxisUpdate(QChartAxis* axis)
             {
                 if(m_layoutVector.count()==0) return;
                 if(axis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(axis->isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
-                if(axis->isLabelsVisible())
+                if(axis->labelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
-                if(axis->isShadesVisible()) {
+                if(axis->shadesVisible()) {
                     setShadesOpacity(axis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(axis->labelsAngle());
                 setAxisPen(axis->axisPen());
                 setLabelsPen(axis->labelsPen());
                 setLabelsBrush(axis->labelsBrush());
                 setLabelsFont(axis->labelsFont());
                 setGridPen(axis->gridPen());
                 setShadesPen(axis->shadesPen());
                 setShadesBrush(axis->shadesBrush());
             }
             void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 int diff = m_thicksList.size() - labels.size();
                 if(diff>0){
                     clear(diff);
                 }else if(diff<0){
                     createItems(-diff);
                 }
                 m_thicksList=labels;
                 m_layoutVector.resize(m_thicksList.size());
                 updateItems(m_layoutVector);
                 if(diff!=0) handleAxisUpdate(axis);
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 updateItems(m_layoutVector);
             }
             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)
             {
                 foreach(QGraphicsItem* item , m_axis.childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::calculateLayout(QVector<qreal>& points)
             {
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         const qreal deltaX = m_rect.width()/(m_thicksList.size()-1);
                         for (int i = 0; i < m_thicksList.size(); ++i) {
                              int x = i * deltaX + m_rect.left();
                              points[i]=x;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_thicksList.size()-1);
                         for (int i = 0; i < m_thicksList.size(); ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i]=y;
                         }
                     }
                     break;
                 }
             }
             void AxisItem::applyLayout(const QVector<qreal>& points)
             {
                 Q_ASSERT(points.size() == m_thicksList.size());
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 QList<QGraphicsItem *> axis = m_axis.childItems();
                 Q_ASSERT(labels.size() == m_thicksList.size());
                 switch (m_type)
                      {
                          case X_AXIS:
                          {
                              QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(axis.at(0));
                              lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                              for (int i = 0; i < points.size(); ++i) {
                                  QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                                  lineItem->setLine(points[i], m_rect.top(), points[i], 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(points[i] - center.x(), m_rect.bottom() + label_padding);
                                  if(i%2){
                                      QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                      rectItem->setRect(points[i],m_rect.top(),points[i+1]-points[i],m_rect.height());
                                  }
                                  lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
                                  lineItem->setLine(points[i],m_rect.bottom(),points[i],m_rect.bottom()+5);
                              }
                          }
                          break;
                          case Y_AXIS:
                          {
                              QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(axis.at(0));
                              lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                              for (int i = 0; i < points.size(); ++i) {
                                  QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                                  lineItem->setLine(m_rect.left() , points[i], m_rect.right(), points[i]);
                                  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 , points[i]-center.y());
                                  if(i%2){
                                      QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                      rectItem->setRect(m_rect.left(),points[i],m_rect.width(),points[i]-points[i+1]);
                                  }
                                  lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
                                  lineItem->setLine(m_rect.left()-5,points[i],m_rect.left(),points[i]);
                              }
                          }
                          break;
                          default:
                          qDebug()<<"Unknown axis type";
                          break;
                      }
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartaxis.cpp +2 -2

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QChartAxis
                 \brief The QChartAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the share common X axis.
                 Axis can be setup to show axis line with ticks, gird lines and shades.
             */
             /*!
                \fn bool QChartAxis::isAxisVisible() const
                \brief Returns if axis is visible
                \sa setAxisVisible()
             */
             /*!
                \fn QPen QChartAxis::axisPen() const
                \brief  Returns pen used to draw axis and ticks.
                 \sa setAxisPen()
             */
             /*!
                \fn bool QChartAxis::isGridVisible() const
                \brief Returns if grid is visible
                \sa setGridVisible()
             */
             /*!
                \fn QPen QChartAxis::gridPen() const
                \brief  Returns pen used to draw grid.
                 \sa setGridPen()
             */
             /*!
-               \fn  bool QChartAxis::isLabelsVisible() const
+               \fn  bool QChartAxis::labelsVisible() const
                \brief Returns if grid is visible
                \sa setLabelsVisible()
             */
             /*!
                \fn QPen QChartAxis::labelsPen() const
                \brief Returns the pen used to labels.
                 \sa setLabelsPen()
             */
             /*!
                \fn QBrush QChartAxis::labelsBrush() const
                \brief Returns brush used to draw labels.
                 \sa setLabelsBrush()
             */
             /*!
                \fn QFont QChartAxis::labelsFont() const
                \brief Returns font used to draw labels.
                 \sa setLabelsFont()
             */
             /*!
                \fn QFont QChartAxis::labelsAngle() const
                \brief Returns angle used to draw labels.
                 \sa setLabelsAngle()
             */
             /*!
-               \fn bool QChartAxis::isShadesVisible() const
+               \fn bool QChartAxis::shadesVisible() const
                \brief Returns if shades are visible.
                \sa setShadesVisible()
             */
             /*!
               \fn  qreal QChartAxis::shadesOpacity() const
               \brief Returns opacity of shades.
              */
             /*!
                \fn QPen QChartAxis::shadesPen() const
                \brief Returns pen used to draw shades.
                 \sa setShadesPen()
             */
             /*!
                \fn QBrush QChartAxis::shadesBrush() const
                \brief Returns brush used to draw shades.
                 \sa setShadesBrush()
             */
             /*!
                \fn qreal QChartAxis::min() const
                \brief Returns minimum value on the axis.
                \sa setMin()
             */
             /*!
                \fn qreal QChartAxis::max() const
                \brief Returns maximim value on the axis.
                \sa setMax()
             */
             /*!
                \fn void QChartAxis::minChanged(qreal min)
                \brief Axis emits signal when \a min of axis has changed.
             */
             /*!
                \fn void QChartAxis::maxChanged(qreal max)
                \brief Axis emits signal when \a max of axis has changed.
             */
             /*!
                \fn int QChartAxis::ticksCount() const
                \brief Return number of ticks on the axis
                \sa setTicksCount()
             */
             /*!
                 \fn void QChartAxis::update(QChartAxis*)
                 \brief \internal
             */
             /*!
                 \fn void QChartAxis::ticksChanged(QChartAxis*)
                 \brief \internal
             */
             /*!
                 Constructs new axis object which is a child of \a parent. Ownership is taken by
                 QChatView or QChart when axis added.
             */
             QChartAxis::QChartAxis(QObject* parent):QObject(parent),
             m_axisVisible(true),
             m_gridVisible(true),
             m_labelsVisible(true),
             m_labelsAngle(0),
             m_shadesVisible(true),
             m_shadesOpacity(1.0),
             m_min(0),
             m_max(0),
             m_ticksCount(5)
             {
             }
             /*!
                 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QChartAxis::~QChartAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QChartAxis::setAxisPen(const QPen& pen)
             {
                 m_axisPen=pen;
                 emit update(this);
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QChartAxis::setAxisVisible(bool visible)
             {
                 m_axisVisible=visible;
                 emit update(this);
             }
             /*!
               Sets if grid is \a visible.
              */
             void QChartAxis::setGridVisible(bool visible)
             {
                 m_gridVisible=visible;
                 emit update(this);
             }
             /*!
               Sets \a pen used to draw grid.
              */
             void QChartAxis::setGridPen(const QPen& pen)
             {
                 m_gridPen=pen;
                 emit update(this);
             }
             /*!
               Sets if axis' labels are \a visible.
              */
             void QChartAxis::setLabelsVisible(bool visible)
             {
                 m_labelsVisible=visible;
                 emit update(this);
             }
             /*!
               Sets \a pen used to draw labels.
              */
             void QChartAxis::setLabelsPen(const QPen& pen)
             {
                 m_labelsPen=pen;
                 emit update(this);
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QChartAxis::setLabelsBrush(const QBrush& brush)
             {
                 m_labelsBrush=brush;
                 emit update(this);
             }
             /*!
               Sets \a font used to draw labels.
              */
             void QChartAxis::setLabelsFont(const QFont& font)
             {
                 m_labelsFont=font;
                 emit update(this);
             }
             /*!
               Sets \a angle for all the labels on given axis.
              */
             void QChartAxis::setLabelsAngle(int angle)
             {
             	m_labelsAngle=angle;
             	 emit update(this);
             }
             /*!
               Sets if shades are \a visible.
              */
             void QChartAxis::setShadesVisible(bool visible)
             {
                 m_shadesVisible=visible;
                 emit update(this);
             }
             /*!
               Sets \a pen used to draw shades.
              */
             void QChartAxis::setShadesPen(const QPen& pen)
             {
                 m_shadesPen=pen;
                 emit update(this);
             }
             /*!
               Sets \a brush used to draw shades.
              */
             void QChartAxis::setShadesBrush(const QBrush& brush)
             {
                 m_shadesBrush=brush;
                 emit update(this);
             }
             /*!
               Sets \a opacity of the shades.
              */
             void QChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shadesOpacity=opacity;
                 emit update(this);
             }
             /*!
               Sets \a min value on the axis.
              */
             void QChartAxis::setMin(qreal min)
             {
             	if(m_min!=min){
             		m_min=min;
             		emit minChanged(m_min);
             	}
             }
             /*!
               Sets \a max value on the axis.
              */
             void QChartAxis::setMax(qreal max)
             {
             	if(m_max!=max){
             		m_max=max;
             		emit maxChanged(m_max);
             	}
             }
             /*!
               Sets range from \a min to \a max on the axis.
              */
             void QChartAxis::setRange(qreal min, qreal max)
             {
             	setMin(min);
             	setMax(max);
             }
             /*!
               Sets \a count for ticks on the axis.
              */
             void QChartAxis::setTicksCount(int count)
             {
             	m_ticksCount=count;
             	emit ticksChanged(this);
             }
             /*!
               TODO: refactor me. Sets string \a label for \a value on the axis.
              */
             void QChartAxis::addAxisTickLabel(qreal value,const QString& label)
             {
             	m_ticks.insert(value,label);
             	emit ticksChanged(this);
             }
             /*!
               TODO: refactor me. Removes label for \a value on the axis.
              */
             void QChartAxis::removeAxisTickLabel(qreal value)
             {
             	m_ticks.remove(value);
             	emit ticksChanged(this);
             }
             /*!
               TODO: refactor me. Returns label for \a value on the axis.
              */
             QString QChartAxis::axisTickLabel(qreal value) const
             {
             	return m_ticks.value(value);
             }
             /*!
               TODO: refactor me. Removes all the string labels for on the axis.
              */
             void QChartAxis::clearAxisTickLabels()
             {
             	m_ticks.clear();
             	emit ticksChanged(this);
             }
             #include "moc_qchartaxis.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartaxis.h +2 -2

             #ifndef QCHARTAXIS_H_
             #define QCHARTAXIS_H_
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
             {
             	Q_OBJECT
             public:
                 QChartAxis(QObject* parent =0);
                 ~QChartAxis();
                 //axis handling
                 bool isAxisVisible() const { return m_axisVisible;};
                 void setAxisVisible(bool visible);
                 void setAxisPen(const QPen& pen);
                 QPen axisPen() const { return m_axisPen;};
                 //grid handling
                 bool isGridVisible() const { return m_gridVisible;};
                 void setGridVisible(bool visible);
                 void setGridPen(const QPen& pen);
                 QPen gridPen() const {return m_gridPen;}
                 //labels handling
-                bool isLabelsVisible() const { return m_labelsVisible;};
+                bool labelsVisible() const { return m_labelsVisible;};
                 void setLabelsVisible(bool visible);
                 void setLabelsPen(const QPen& pen);
                 QPen labelsPen() const { return m_labelsPen;}
                 void setLabelsBrush(const QBrush& brush);
                 QBrush labelsBrush() const { return m_labelsBrush;}
                 void setLabelsFont(const QFont& font);
                 QFont labelsFont() const { return m_labelsFont;}
                 void setLabelsAngle(int angle);
                 int labelsAngle() const { return m_labelsAngle;};
                 //shades handling
-                bool isShadesVisible() const { return m_shadesVisible;};
+                bool shadesVisible() const { return m_shadesVisible;};
                 void setShadesVisible(bool visible);
                 void setShadesPen(const QPen& pen);
                 QPen shadesPen() const { return m_shadesPen;}
                 void setShadesBrush(const QBrush& brush);
                 QBrush shadesBrush() const { return m_shadesBrush;}
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const { return m_shadesOpacity;}
                 //range handling
                 void setMin(qreal min);
                 qreal min() const { return m_min;};
                 void setMax(qreal max);
                 qreal max() const { return m_max;};
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const { return m_ticksCount;}
                 void addAxisTickLabel(qreal value,const QString& label);
                 void removeAxisTickLabel(qreal value);
                 QString axisTickLabel(qreal value) const ;
                 void clearAxisTickLabels();
             signals:
             	void minChanged(qreal min);
             	void maxChanged(qreal max);
             //private signal
             	void update(QChartAxis*);
             	void ticksChanged(QChartAxis*);
             private:
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridVisible;
                 QPen m_gridPen;
                 bool m_labelsVisible;
                 QPen m_labelsPen;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 QMap<qreal, QString> m_ticks;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

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