HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1987:7467f026c4a8

QCategoryAxis: some commented out code removed

Marek Rosa -

r1987:7467f026c4a8

parent child

Context file:

r1987:7467f026c4a8

Collapse all files

src/axis/categoryaxis/chartcategoryaxisy.cpp 0 -10

             /****************************************************************************
             **
             ** 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 "chartcategoryaxisy_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoryAxisY::ChartCategoryAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartCategoryAxisY::~ChartCategoryAxisY()
             {
             }
             QVector<qreal> ChartCategoryAxisY::calculateLayout() const
             {
                 QCategoryAxis *axis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 int tickCount = axis->categoriesLabels().count() + 1;
                 QVector<qreal> points;
                 if (tickCount < 2)
                     return points;
                 QRectF rect = presenter()->chartsGeometry();
                 qreal range = axis->max() - axis->min();
                 if (range > 0) {
                     points.resize(tickCount);
                     qreal scale = rect.height() / range;
                     for (int i = 0; i < tickCount; ++i)
                         if (i < tickCount - 1) {
                             int y = -(axis->startValue(axis->categoriesLabels().at(i)) - axis->min()) * scale + rect.bottom();
                             points[i] = y;
                         } else {
                             int y = -(axis->endValue(axis->categoriesLabels().at(i - 1)) - axis->min())  * scale + rect.bottom();
                             points[i] = y;
                         }
                 }
                 return points;
             }
             void ChartCategoryAxisY::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if(layout.isEmpty()) {
                     return;
                 }
                 QCategoryAxis *categoryAxis = qobject_cast<QCategoryAxis *>(m_chartAxis);
                 QStringList ticksList = categoryAxis->categoriesLabels();
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
-            //    qreal height =  2*m_rect.bottom();
                 for (int i = 0; i < labels.count(); i++) {
                     labels.at(i)->setVisible(false);
                 }
                 QRectF chartRect = presenter()->chartsGeometry();
                 // axis base line
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(chartRect.left() , chartRect.top(), chartRect.left(), chartRect.bottom());
                 for (int i = 0; i < layout.size(); ++i) {
                     // label items
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (i < ticksList.count()) {
                         labelItem->setText(ticksList.at(i));
                     }
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     if (i < layout.size() - 1)
                         labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i] + (layout[i + 1] - layout[i]) / 2 - center.y());
                     else
                         labelItem->setPos(chartRect.left() - rect.width() - label_padding , layout[i]-center.y());
                     // check if the label should be shown
                     if (labelItem->pos().y() + center.y() < chartRect.top() || labelItem->pos().y() + center.y() > chartRect.bottom())
                         labelItem->setVisible(false);
                     else
                         labelItem->setVisible(true);
-            //        if(labelItem->pos().y()+rect.height()>height) {
-            //            labelItem->setVisible(false);
-            //        }
-            //        else {
-            //            labelItem->setVisible(true);
-            //            height=labelItem->pos().y();
-            //        }
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(chartRect.left(),layout[i],chartRect.width(),layout[i-1]-layout[i]);
                     }
                     // grid lines and axis line ticks
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setPos(chartRect.left(), layout[i]);
                     lineItem->setLine(0, 0, chartRect.width(), 0);
                     QGraphicsLineItem *tickLineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     tickLineItem->setPos(chartRect.left(), layout[i]);
                     tickLineItem->setLine(-5, 0, 0, 0);
                     // check if the grid line and the axis tick should be shown
                     if (lineItem->pos().y() < chartRect.top() || lineItem->pos().y() > chartRect.bottom()) {
                         lineItem->setVisible(false);
                         tickLineItem->setVisible(false);
                     } else {
                         lineItem->setVisible(true);
                         tickLineItem->setVisible(true);
                     }
                 }
             }
             void ChartCategoryAxisY::handleAxisUpdated()
             {
                 updateGeometry();
                 ChartAxis::handleAxisUpdated();
             }
             QSizeF ChartCategoryAxisY::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                 QFontMetrics fn(m_font);
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList; //TODO::
                 qreal width=0;
                 qreal height=0;
                   switch (which) {
                     case Qt::MinimumSize:
                         width = fn.boundingRect("...").width()+label_padding;
                         height = fn.height();
                         width=qMax(width,base.width());
                         height+=base.height();
                         sh = QSizeF(width,height);
                         break;
                     case Qt::PreferredSize:{
                         for (int i = 0; i < ticksList.size(); ++i)
                         {
                             QRectF rect = fn.boundingRect(ticksList.at(i));
                             height+=rect.height();
                             width=qMax(rect.width()+label_padding,width);
                         }
                         height=qMax(height,base.height());
                         width+=base.width();
                         sh = QSizeF(width,height);
                         break;
                     }
                     default:
                       break;
                   }
                   return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoryaxis/qcategoryaxis.cpp 0 -6

             /****************************************************************************
             **
             ** 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 "qcategoryaxis.h"
             #include "qcategoryaxis_p.h"
             #include "chartcategoryaxisx_p.h"
             #include "chartcategoryaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QCategoryAxis
                 \brief The QCategoryAxis class allows putting a named ranges on the axis.
                 \mainclass
                 This class can be used when the underlying data needs to be given extra meaning.
                 Unlike with the QBarCategoryAxis the QCategoryAxis allows the categories ranges widths to be specified freely.
                 Example code on how to use QCategoryAxis.
                 \code
                 QChartView *chartView = new QChartView;
                 QLineSeries *series = new QLineSeries;
                 // ...
                 chartView->chart()->addSeries(series);
                 QCategoryAxis *axisX = new QCategoryAxis;
                 axisX->setStartValue(15);
                 axisX->append("First", 20);
                 axisX->append("Second", 37);
                 axisX->append("Third", 52);
                 chartView->chart()->setAxisX(series, axisX);
                 \endcode
             */
             /*!
                 \qmlclass CategoryAxis QCategoryAxis
                 \inherits AbstractAxis
                 \brief CategoryAxis allows putting a named ranges on the axis.
                 For example:
                 \code
                     CategoryAxis {
                         startValue: 0.0
                         CategoryRange { endValue: 1.0; label: "min (0-1)" }
                         CategoryRange { endValue: 3.0; label: "standard (1-3)" }
                         CategoryRange { endValue: 4.0; label: "high (3-4)" }
                     }
                 \endcode
             */
             /*!
               \property QCategoryAxis::startValue
               Defines the low end of the first category on the axis.
             */
             /*!
               \qmlproperty int CategoryAxis::startValue
               Defines the low end of the first category on the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QCategoryAxis::QCategoryAxis(QObject *parent):
                 QValueAxis(*new QCategoryAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QCategoryAxis::~QCategoryAxis()
             {
-                //    Q_D(QValueAxis);
-                //    if(d->m_dataset) {
-                //        d->m_dataset->removeAxis(this);
-                //    }
             }
             /*!
                 \internal
             */
             QCategoryAxis::QCategoryAxis(QCategoryAxisPrivate &d,QObject *parent):QValueAxis(d,parent)
             {
             }
             /*!
                 \qmlmethod CategoryAxis::append(string label, real endValue)
                 Appends new category to the axis with an \a label. Category label has to be unique.
                 Parameter \a endValue specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             /*!
                 Appends new category to the axis with an \a categoryLabel.
                 Category label has to be unique.
                 Parameter \a categoryEndValue specifies the high end limit of the category.
                 It has to be greater than the high end limit of the previous category.
                 Otherwise the method returns without adding a new category.
             */
             void QCategoryAxis::append(const QString& categoryLabel, qreal categoryEndValue)
             {
                 Q_D(QCategoryAxis);
                 if (!d->m_categories.contains(categoryLabel))
                 {
                     if(d->m_categories.isEmpty()){
                         Range range(d->m_categoryMinimum, categoryEndValue);
                         d->m_categoriesMap.insert(categoryLabel, range);
                         d->m_categories.append(categoryLabel);
                     }else if (categoryEndValue > endValue(d->m_categories.last())){
                         Range previousRange = d->m_categoriesMap.value(d->m_categories.last());
                         d->m_categoriesMap.insert(categoryLabel, Range(previousRange.second, categoryEndValue));
                         d->m_categories.append(categoryLabel);
                     }
                 }
             }
             /*!
                 Sets \a min to be the low end limit of the first category on the axis.
                 If there is already some categories added to the axis then passed value must be lower than the high end value of the already defined first category range.
                 Otherwise nothing is done.
             */
             void QCategoryAxis::setStartValue(qreal min)
             {
                 Q_D(QCategoryAxis);
                 if(d->m_categories.isEmpty()){
                     d->m_categoryMinimum = min;
                 }else{
                     Range range = d->m_categoriesMap.value(d->m_categories.first());
                     if (min < range.second)
                         d->m_categoriesMap.insert(d->m_categories.first(), Range(min, range.second));
                 }
             }
             /*!
                 Returns the low end limit of the category specified by an \a categoryLabel
             */
             qreal QCategoryAxis::startValue(const QString& categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 if (categoryLabel.isEmpty())
                     return d->m_categoryMinimum;
                 else
                     return d->m_categoriesMap.value(categoryLabel).first;
             }
             /*!
                 Returns the high end limit of the interval specified by an \a categoryLabel
             */
             qreal QCategoryAxis::endValue(const QString& categoryLabel) const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categoriesMap.value(categoryLabel).second;
             }
             /*!
                 \qmlmethod CategoryAxis::remove(string label)
                 Removes a category specified by the \a label from the axis
             */
             /*!
                 Removes an interval specified by the \a categoryLabel from the axis
             */
             void QCategoryAxis::remove(const QString &categoryLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(categoryLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.removeAt(labelIndex);
                     d->m_categoriesMap.remove(categoryLabel);
                     // the range of the interval that follows (if exists) needs to be updated
                     if (labelIndex < d->m_categories.count()) {
                         QString label = d->m_categories.at(labelIndex);
                         Range range = d->m_categoriesMap.value(label);
                         // set the range
                         if (labelIndex == 0) {
                             range.first = d->m_categoryMinimum;
                             d->m_categoriesMap.insert(label, range);
                         } else {
                             range.first = d->m_categoriesMap.value(d->m_categories.at(labelIndex - 1)).second;
                             d->m_categoriesMap.insert(label, range);
                         }
                     }
                     d->emitUpdated();
                 }
             }
             /*!
               \qmlmethod CategoryAxis::replace(string oldLabel, string newLabel)
               Replaces \a oldLabel of an existing category with a \a newLabel.
               If the old label does not exist the method returns without making any changes.
             */
             /*!
               Replaces \a oldLabel of an existing category with a \a newLabel
               If the old label does not exist the method returns without making any changes.
              */
             void QCategoryAxis::replaceLabel(const QString& oldLabel, const QString& newLabel)
             {
                 Q_D(QCategoryAxis);
                 int labelIndex = d->m_categories.indexOf(oldLabel);
                 // check if such label exists
                 if (labelIndex != -1) {
                     d->m_categories.replace(labelIndex, newLabel);
                     Range range = d->m_categoriesMap.value(oldLabel);
                     d->m_categoriesMap.remove(oldLabel);
                     d->m_categoriesMap.insert(newLabel, range);
                     d->emitUpdated();
                 }
             }
             /*!
               Returns the list of the intervals labels
              */
             QStringList QCategoryAxis::categoriesLabels()
             {
                 Q_D(QCategoryAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of intervals.
              */
             int QCategoryAxis::count() const
             {
                 Q_D(const QCategoryAxis);
                 return d->m_categories.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QCategoryAxis::type() const
             {
                 return QAbstractAxis::AxisTypeCategory;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QCategoryAxisPrivate::QCategoryAxisPrivate(QCategoryAxis* q):
                 QValueAxisPrivate(q),
                 m_categoryMinimum(0)
             {
             }
             QCategoryAxisPrivate::~QCategoryAxisPrivate()
             {
             }
             int QCategoryAxisPrivate::ticksCount() const
             {
                 return m_categories.count() + 1;
             }
             void QCategoryAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 Q_UNUSED(count);
                 Q_UNUSED(min);
                 Q_UNUSED(max);
-                //m_min = min;
-                //m_max = max;
             }
             ChartAxis* QCategoryAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QCategoryAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoryAxisY(q,presenter);
                 }else{
                     return new ChartCategoryAxisX(q,presenter);
                 }
             }
             #include "moc_qcategoryaxis.cpp"
             #include "moc_qcategoryaxis_p.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