HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1032:f1315a97f81e

Changes QChartAxisCategories -> QAxisCategories

Michal Klocek -

r1032:f1315a97f81e

parent child

Context file:

r1032:f1315a97f81e

Collapse all files

config.pri +1 -1

             LIBRARY_NAME = QtCommercialChart
             ##################### SHADOW CONFIG #################################################
             !contains($${PWD}, $${OUT_PWD}){
                 search = "$$PWD:::"
                 temp = $$split(search,"/")
                 temp = $$last(temp)
                 path = $$replace(search,$$temp,'')
                 temp = $$split(OUT_PWD,$$path)
                 temp = $$split(temp,'/')
                 temp = $$first(temp)
                 path = "$${path}$${temp}"
                 SHADOW=$$path
             }else{
                 SHADOW=$$PWD
                 CONFIG-=development_build
             }
             ##################### BUILD PATHS ##################################################
             CHART_BUILD_PUBLIC_HEADER_DIR = $$SHADOW/include
             CHART_BUILD_PRIVATE_HEADER_DIR = $$CHART_BUILD_PUBLIC_HEADER_DIR/private
             CHART_BUILD_LIB_DIR = $$SHADOW/lib
             CHART_BUILD_DIR = $$SHADOW/build
             CHART_BUILD_BIN_DIR = $$SHADOW/bin
             CHART_BUILD_PLUGIN_DIR = $$CHART_BUILD_BIN_DIR/QtCommercial/Chart
             CHART_BUILD_DOC_DIR = $$SHADOW/doc
             win32:{
                 CHART_BUILD_PUBLIC_HEADER_DIR = $$replace(CHART_BUILD_PUBLIC_HEADER_DIR, "/","\\")
                 CHART_BUILD_PRIVATE_HEADER_DIR = $$replace(CHART_BUILD_PRIVATE_HEADER_DIR, "/","\\")
                 CHART_BUILD_BUILD_DIR = $$replace(CHART_BUILD_BUILD_DIR, "/","\\")
                 CHART_BUILD_BIN_DIR = $$replace(CHART_BUILD_BIN_DIR, "/","\\")
                 CHART_BUILD_PLUGIN_DIR = $$replace(CHART_BUILD_PLUGIN_DIR, "/","\\")
                 CHART_BUILD_DOC_DIR = $$replace(CHART_BUILD_DOC_DIR, "/","\\")
                 CHART_BUILD_LIB_DIR = $$CHART_BUILD_BIN_DIR
             }
             mac: {
                 # TODO: The following qmake flags are a work-around to make QtCommercial Charts compile on
                 # QtCommercial 4.8. On the other hand Charts builds successfully with Qt open source 4.8
                 # without these definitions, so this is probably a configuration issue on QtCommercial 4.8;
                 # it should probably define the minimum OSX version to be 10.5...
                 QMAKE_CXXFLAGS *= -mmacosx-version-min=10.5
                 QMAKE_LFLAGS *= -mmacosx-version-min=10.5
             }
             ##################### DEVELOPMENT BUILD ###################################################
             development_build: {
                 DEFINES+=DEVELOPMENT_BUILD
                 CONFIG+=debug_and_release
             }
             ##################### BUILD CONFIG ########################################################
             !system_build:{
                 INCLUDEPATH += $$CHART_BUILD_PUBLIC_HEADER_DIR
                 !win32: {
                     LIBS += -L $$CHART_BUILD_LIB_DIR -Wl,-rpath,$$CHART_BUILD_LIB_DIR
                 }else{
                     win32-msvc*: {
                         # hack fix for error:
                         #   "LINK : fatal error LNK1146: no argument specified with option '/LIBPATH:'"
                         QMAKE_LIBDIR += $$CHART_BUILD_LIB_DIR
                     }else{
                         LIBS += -L $$CHART_BUILD_LIB_DIR
                     }
                 }
                 CONFIG(debug, debug|release) {
                   mac: LIBRARY_NAME = $$join(LIBRARY_NAME,,,_debug)
                   win32: LIBRARY_NAME = $$join(LIBRARY_NAME,,,d)
                 }
                 LIBS += -l$$LIBRARY_NAME
                 mac: {
                     # This is a hack to make binaries to use the internal version of the QtCommercial Charts library on OSX
                     CHARTS_LIB_NAME = libQtCommercialChart.1.dylib
                     CONFIG(debug, debug|release) {
                         CHARTS_LIB_NAME = libQtCommercialChartd.1.dylib
                     }
                     BIN_TARGET_PATH = ""
                     exists ($$CHART_BUILD_BIN_DIR"/"$$TARGET".app/Contents/MacOS/"$$TARGET) {
                         BIN_TARGET_PATH = $$CHART_BUILD_BIN_DIR"/"$$TARGET".app/Contents/MacOS/"$$TARGET
                     }
                     exists ($$CHART_BUILD_BIN_DIR"/test/"$$TARGET".app/Contents/MacOS/"$$TARGET) {
                         # Executable in test folder
                         BIN_TARGET_PATH = $$CHART_BUILD_BIN_DIR"/test/"$$TARGET".app/Contents/MacOS/"$$TARGET
                     }
                     exists ($$CHART_BUILD_BIN_DIR"/test/tst_"$$TARGET".app/Contents/MacOS/tst_"$$TARGET) {
                         # Executable in test folder with custom target "tst_NNN"
                         BIN_TARGET_PATH = $$CHART_BUILD_BIN_DIR"/test/tst_"$$TARGET".app/Contents/MacOS/tst_"$$TARGET
                     }
                     exists($$CHART_BUILD_PLUGIN_DIR"/lib"$$TARGET".dylib") {
                         # Plugin
                         BIN_TARGET_PATH = $$CHART_BUILD_PLUGIN_DIR"/lib"$$TARGET".dylib"
                     }
                     !isEmpty (BIN_TARGET_PATH) {
                         QMAKE_POST_LINK += install_name_tool -change $$CHARTS_LIB_NAME $$CHART_BUILD_LIB_DIR"/"$$CHARTS_LIB_NAME $$BIN_TARGET_PATH
                     }
                 }
-            }else {
+            } else {
                 CONFIG += qtcommercialchart
             }

examples/customchart/main.cpp +2 -2

             /****************************************************************************
             **
             ** 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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QLineSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QLineSeries* series = new QLineSeries();
                 *series << QPointF(0, 6) << QPointF(2, 4) << QPointF(3, 8) << QPointF(7, 4) << QPointF(10,5);
                 QChart* chart = new QChart();
                 chart->addSeries(series);
             //![1]
             //![2]
                 // Customize series
                 QPen pen(QRgb(0xfdb157));
                 pen.setWidth(5);
                 series->setPen(pen);
                 // Customize chart title
                 QFont font;
                 font.setPixelSize(18);
                 chart->setTitleFont(font);
                 chart->setTitleBrush(QBrush(Qt::white));
                 chart->setTitle("Customchart example");
                 // Customize chart background
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setStart(QPointF(0,0));
                 backgroundGradient.setFinalStop(QPointF(0,1));
                 backgroundGradient.setColorAt(0.0, QRgb(0xd2d0d1));
                 backgroundGradient.setColorAt(1.0, QRgb(0x4c4547));
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setBackgroundBrush(backgroundGradient);
             //![2]
             //![3]
                 QAxis* axisX = chart->axisX();
                 QAxis* axisY = chart->axisY();
                 // Customize axis label font
                 QFont labelsFont;
                 labelsFont.setPixelSize(12);
                 axisX->setLabelsFont(labelsFont);
                 axisY->setLabelsFont(labelsFont);
                 // Customize axis colors
                 QPen axisPen(QRgb(0xd18952));
                 axisPen.setWidth(2);
                 axisX->setAxisPen(axisPen);
                 axisY->setAxisPen(axisPen);
                 // Customize axis label colors
                 QBrush axisBrush(Qt::white);
                 axisX->setLabelsBrush(axisBrush);
                 axisY->setLabelsBrush(axisBrush);
                 // Customize grid lines and shades
                 axisX->setGridLineVisible(false);
                 axisY->setGridLineVisible(false);
                 axisY->setShadesPen(Qt::NoPen);
                 axisY->setShadesBrush(QBrush(QRgb(0xa5a2a3)));
                 axisY->setShadesVisible(true);
             //![3]
             //![4]
-                QChartAxisCategories* categoriesX = chart->axisX()->categories();
+                QAxisCategories* categoriesX = chart->axisX()->categories();
                 categoriesX->insert(1,"low");
                 categoriesX->insert(5,"optimal");
                 categoriesX->insert(10,"high");
-                QChartAxisCategories* categoriesY = chart->axisY()->categories();
+                QAxisCategories* categoriesY = chart->axisY()->categories();
                 categoriesY->insert(1,"slow");
                 categoriesY->insert(5,"med");
                 categoriesY->insert(10,"fast");
                 axisX->setRange(0,10);
                 axisX->setTicksCount(4);
                 axisY->setRange(0,10);
                 axisY->setTicksCount(4);
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

src/axis/axis.pri +3 -3

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/chartaxis.cpp \
                 $$PWD/qaxis.cpp \
-                $$PWD/qchartaxiscategories.cpp
+                $$PWD/qaxiscategories.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxis_p.h \
                 $$PWD/qaxis_p.h \
-                $$PWD/qchartaxiscategories_p.h
+                $$PWD/qaxiscategories_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qaxis.h \
-                $$PWD/qchartaxiscategories.h   
  No newline at end of file
+                $$PWD/qaxiscategories.h   
  No newline at end of file

src/axis/chartaxis.cpp +2 -2

             /****************************************************************************
             **
             ** 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 "chartaxis_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
-            #include "qchartaxiscategories_p.h"
+            #include "qaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
                 m_chartAxis(axis),
                 m_type(type),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_axis(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(0)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QObject::connect(m_chartAxis->categories()->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_axis->children().size() == 0)
                     m_axis->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_axis->addToGroup(new QGraphicsLineItem());
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem());
                    }
             }
             void ChartAxis::deleteItems(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) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this,layout);
                 } else {
                     setLayout(layout);
                 }
             }
             bool ChartAxis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>1);
-                QChartAxisCategories* categories = m_chartAxis->categories();
+                QAxisCategories* categories = m_chartAxis->categories();
                 bool category = categories->count()>0;
                 if (!category) {
                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                     n++;
                     for (int i=0; i< ticks; i++) {
                         qreal value = min + (i * (max - min)/ (ticks-1));
                         labels << QString::number(value,'f',n);
                     }
                 } else {
                     QList<qreal> values = categories->values();
                     for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
                         for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
                         if (j!=0) value=values.at(j-1);
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return category;
             }
             void ChartAxis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal ChartAxis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             QVector<qreal> ChartAxis::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int x = i * deltaX + m_rect.left();
                              points[i] = x;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i] = y;
                         }
                     }
                     break;
                 }
                 return points;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
             	int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
             		deleteItems(diff);
                 } else if (diff<0) {
             		createItems(-diff);
             	}
                 if( diff!=0) handleAxisUpdated();
             	QStringList ticksList;
                 bool categories = createLabels(ticksList,m_min,m_max,layout.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() == ticksList.size());
             	Q_ASSERT(layout.size() == ticksList.size());
             	qreal minWidth = 0;
             	qreal minHeight = 0;
             	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 < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                             if (!categories || i<1) {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth+=rect.width();
             				    minHeight=qMax(rect.height(),minHeight);
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                             } else {
             				    labelItem->setText(ticksList.at(i));
             			        const QRectF& rect = labelItem->boundingRect();
             			        minWidth+=rect.width();
             			        minHeight=qMax(rect.height()+label_padding,minHeight);
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
             				}
                             if ((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(layout[i],m_rect.bottom(),layout[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 < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                             if (!categories || i<1) {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth=qMax(rect.width()+label_padding,minWidth);
             				    minHeight+=rect.height();
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                             } else {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth=qMax(rect.width(),minWidth);
             				    minHeight+=rect.height();
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
             				}
                             if ((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
             			}
             		}
             		break;
             		default:
             		    qWarning()<<"Unknown axis type";
             		break;
             	}
                 m_layoutVector=layout;
                 presenter()->setMinimumMarginWidth(this,minWidth);
                 presenter()->setMinimumMarginHeight(this,minHeight);
             }
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
             void ChartAxis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 } else {
                     setAxisOpacity(0);
                 }
                 if (m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 } else {
                     setGridOpacity(0);
                 }
                 if (m_chartAxis->labelsVisible()) {
                     setLabelsOpacity(100);
                 } else {
                     setLabelsOpacity(0);
                 }
                 if (m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
                 } else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void ChartAxis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if (qFuzzyIsNull(min - max) || tickCount < 2)
                     return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qaxis.cpp +1 -1

             /****************************************************************************
             **
             ** 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 "qaxis.h"
             #include "qaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAxis
                 \brief The QAxis 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 QAxis::isAxisVisible() const
                \brief Returns if axis is visible
                \sa setAxisVisible()
             */
             /*!
                \fn QPen QAxis::axisPen() const
                \brief  Returns pen used to draw axis and ticks.
                 \sa setAxisPen()
             */
             /*!
                \fn bool QAxis::isGridLineVisible() const
                \brief Returns if grid is visible
                \sa setGridLineVisible()
             */
             /*!
                \fn QPen QAxis::gridLinePen() const
                \brief  Returns pen used to draw grid.
                 \sa setGridLinePen()
             */
             /*!
                \fn  bool QAxis::labelsVisible() const
                \brief Returns if grid is visible
                \sa setLabelsVisible()
             */
             /*!
                \fn QPen QAxis::labelsPen() const
                \brief Returns the pen used to labels.
                 \sa setLabelsPen()
             */
             /*!
                \fn QBrush QAxis::labelsBrush() const
                \brief Returns brush used to draw labels.
                 \sa setLabelsBrush()
             */
             /*!
                \fn QFont QAxis::labelsFont() const
                \brief Returns font used to draw labels.
                 \sa setLabelsFont()
             */
             /*!
                \fn QFont QAxis::labelsAngle() const
                \brief Returns angle used to draw labels.
                 \sa setLabelsAngle()
             */
             /*!
                \fn bool QAxis::shadesVisible() const
                \brief Returns if shades are visible.
                \sa setShadesVisible()
             */
             /*!
               \fn  qreal QAxis::shadesOpacity() const
               \brief Returns opacity of shades.
              */
             /*!
                \fn QPen QAxis::shadesPen() const
                \brief Returns pen used to draw shades.
                 \sa setShadesPen()
             */
             /*!
                \fn QBrush QAxis::shadesBrush() const
                \brief Returns brush used to draw shades.
                 \sa setShadesBrush()
             */
             /*!
                \fn qreal QAxis::min() const
                \brief Returns minimum value on the axis.
                \sa setMin()
             */
             /*!
                \fn qreal QAxis::max() const
                \brief Returns maximim value on the axis.
                \sa setMax()
             */
             /*!
                \fn void QAxis::minChanged(qreal min)
                \brief Axis emits signal when \a min of axis has changed.
             */
             /*!
                \fn void QAxis::maxChanged(qreal max)
                \brief Axis emits signal when \a max of axis has changed.
             */
             /*!
                \fn void QAxis::rangeChanged(qreal min, qreal max)
                \brief Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                \fn int QAxis::ticksCount() const
                \brief Return number of ticks on the axis
                \sa setTicksCount()
             */
             /*!
                 \fn QChartAxisCategories* QAxis::categories()
                 \brief Returns pointer to the list of categories which correspond to the values on the axis.
             */
             /*!
                 \fn void QAxis::ticksCountChanged(int count)
                 \brief Emits the new \a count of ticks on the axis
                 Signal is emitted when the number of the ticks on the axis has been changed to a different value.
                 Parementer count\a count is the new number of ticks on the axis.
             */
             /*!
                 Constructs new axis object which is a child of \a parent. Ownership is taken by
                 QChart when axis added.
             */
             QAxis::QAxis(QObject *parent) : QObject(parent),
             d_ptr(new QAxisPrivate(this))
             {
             }
             /*!
                 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAxis::~QAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAxis::setAxisPen(const QPen &pen)
             {
             	if (d_ptr->m_axisPen!=pen) {
             	    d_ptr->m_axisPen = pen;
                     emit d_ptr->updated();
             	}
             }
             QPen QAxis::axisPen() const
             {
                 return d_ptr->m_axisPen;
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAxis::setAxisVisible(bool visible)
             {
                 if (d_ptr->m_axisVisible != visible) {
                     d_ptr->m_axisVisible = visible;
                     emit d_ptr->updated();
             	}
             }
             bool QAxis::isAxisVisible() const
             {
                 return d_ptr->m_axisVisible;
             }
             /*!
               Sets if grid line is \a visible.
              */
             void QAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit d_ptr->updated();
             	}
             }
             bool QAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
              */
             void QAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit d_ptr->updated();
             	}
             }
             QPen QAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             /*!
               Sets if axis' labels are \a visible.
              */
             void QAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->updated();
             	}
             }
             bool QAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
              */
             void QAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit d_ptr->updated();
             	}
             }
             QPen QAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit d_ptr->updated();
             	}
             }
             QBrush  QAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
              */
             void QAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit d_ptr->updated();
             	}
             }
             QFont QAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             /*!
               Sets \a angle for all the labels on given axis.
              */
             void QAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit d_ptr->updated();
             	}
             }
             int QAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             /*!
               Sets if shades are \a visible.
              */
             void QAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit d_ptr->updated();
             	}
             }
             bool QAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
              */
             void QAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit d_ptr->updated();
             	}
             }
             QPen QAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
              */
             void QAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit d_ptr->updated();
             	}
             }
             QBrush QAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             /*!
               Sets \a opacity of the shades.
              */
             void QAxis::setShadesOpacity(qreal opacity)
             {
                 if (d_ptr->m_shadesOpacity != opacity) {
                     d_ptr->m_shadesOpacity=opacity;
                     emit d_ptr->updated();
             	}
             }
             qreal QAxis::shadesOpacity() const
             {
                 return d_ptr->m_shadesOpacity;
             }
             /*!
              Sets \a min value on the axis.
              */
             void QAxis::setMin(qreal min)
             {
             	setRange(min,d_ptr->m_max);
             }
             qreal QAxis::min() const
             {
                 return d_ptr->m_min;
             }
             /*!
              Sets \a max value on the axis.
              */
             void QAxis::setMax(qreal max)
             {
                 setRange(d_ptr->m_min,max);
             }
             qreal QAxis::max() const
             {
                 return d_ptr->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
              */
             void QAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
                 if (!qFuzzyIsNull(d_ptr->m_min - min)) {
                     d_ptr->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d_ptr->m_max - max)) {
                     d_ptr->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(d_ptr->m_min,d_ptr->m_max);
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
              */
             void QAxis::setTicksCount(int count)
             {
                 if (d_ptr->m_ticksCount != count) {
                     d_ptr->m_ticksCount = count;
             		emit ticksCountChanged(count);
             		emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
             	}
             }
             int QAxis::ticksCount() const
             {
                 return d_ptr->m_ticksCount;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
              */
             void QAxis::show()
             {
                 d_ptr->m_axisVisible=true;
                 d_ptr->m_gridLineVisible=true;
                 d_ptr->m_labelsVisible=true;
                 d_ptr->m_shadesVisible=true;
                 emit d_ptr->updated();
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
              */
             void QAxis::hide()
             {
                 d_ptr->m_axisVisible = false;
                 d_ptr->m_gridLineVisible = false;
                 d_ptr->m_labelsVisible = false;
                 d_ptr->m_shadesVisible = false;
                 emit d_ptr->updated();
             }
             /*!
                 Sets the nice numbers state to \a enable
             */
             void QAxis::setNiceNumbersEnabled(bool enable)
             {
                 if (d_ptr->m_niceNumbers != enable){
                     d_ptr->m_niceNumbers = enable;
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             /*!
                 Returns whether nice numbers are enabled or not.
             */
             bool  QAxis::niceNumbersEnabled() const
             {
                 return d_ptr->m_niceNumbers;
             }
-            QChartAxisCategories* QAxis::categories()
+            QAxisCategories* QAxis::categories()
             {
                 return &d_ptr->m_category;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAxisPrivate::QAxisPrivate(QAxis* q):
             q_ptr(q),
             m_axisVisible(true),
             m_gridLineVisible(true),
             m_labelsVisible(true),
             m_labelsAngle(0),
             m_shadesVisible(false),
             m_shadesOpacity(1.0),
             m_min(0),
             m_max(0),
             m_ticksCount(5),
             m_niceNumbers(false)
             {
             }
             QAxisPrivate::~QAxisPrivate()
             {
             }
             void QAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                q_ptr->setRange(min,max);
                q_ptr->setTicksCount(count);
             }
             #include "moc_qaxis.cpp"
             #include "moc_qaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qaxis.h +2 -2

             /****************************************************************************
             **
             ** 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 QAXIS_H
             #define QAXIS_H
             #include <qchartglobal.h>
-            #include <qchartaxiscategories.h>
+            #include <qaxiscategories.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QAxis : public QObject
             {
             	Q_OBJECT
             public:
                 QAxis(QObject *parent =0);
                 ~QAxis();
                 //axis handling
                 bool isAxisVisible() const;
                 void setAxisVisible(bool visible = true);
                 void setAxisPen(const QPen &pen);
                 QPen axisPen() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 //range handling
                 void setMin(qreal min);
                 qreal min() const;
                 void setMax(qreal max);
                 qreal max() const;
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const;
                 void setNiceNumbersEnabled(bool enable = true);
                 bool niceNumbersEnabled() const;
-                QChartAxisCategories* categories();
+                QAxisCategories* categories();
                 void show();
                 void hide();
             Q_SIGNALS:
             	void minChanged(qreal min);
             	void maxChanged(qreal max);
             	void rangeChanged(qreal min, qreal max);
             	void ticksCountChanged(int count);
             private:
             	QScopedPointer<QAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAxis);
                 friend class ChartDataSet;
                 friend class ChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/axis/qaxis_p.h +1 -1

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QAXIS_P_H
             #define QAXIS_P_H
             #include "qaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAxisPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAxisPrivate(QAxis *q);
                 ~QAxisPrivate();
             Q_SIGNALS:
                 void updated();
                 void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             public Q_SLOTS:
                 void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 QAxis *q_ptr;
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 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;
-                QChartAxisCategories m_category;
+                QAxisCategories m_category;
                 bool m_niceNumbers;
                 friend class QAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qaxiscategories.cpp ~~src/axis/qchartaxiscategories.cpp~~ renamed +16 -16

             /****************************************************************************
             **
             ** 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 "qchartaxiscategories.h"
+            #include "qaxiscategories.h"
-            #include "qchartaxiscategories_p.h"
+            #include "qaxiscategories_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QChartAxisCategories::QChartAxisCategories():
+            QAxisCategories::QAxisCategories():
-            d_ptr(new QChartAxisCategoriesPrivate(this))
+            d_ptr(new QAxisCategoriesPrivate(this))
             {
             }
-            QChartAxisCategories::~QChartAxisCategories()
+            QAxisCategories::~QAxisCategories()
             {
             }
-            void QChartAxisCategories::insert(const QBarCategories &categories)
+            void QAxisCategories::insert(const QBarCategories &categories)
             {
                 int i=1;
                 foreach (const QString& string , categories) {
                     d_ptr->m_map.insert(i,string);
                     i++;
                 }
                 emit d_ptr->updated();
             }
-            void QChartAxisCategories::insert(qreal value,QString label)
+            void QAxisCategories::insert(qreal value,QString label)
             {
                 d_ptr->m_map.insert(value,label);
                 emit d_ptr->updated();
             }
-            void QChartAxisCategories::remove(qreal value)
+            void QAxisCategories::remove(qreal value)
             {
                 d_ptr->m_map.remove(value);
                 emit d_ptr->updated();
             }
-            void QChartAxisCategories::clear()
+            void QAxisCategories::clear()
             {
                 d_ptr->m_map.clear();
                 emit d_ptr->updated();
             }
-            int QChartAxisCategories::count()
+            int QAxisCategories::count()
             {
                 return d_ptr->m_map.count();
             }
-            QList<qreal> QChartAxisCategories::values() const
+            QList<qreal> QAxisCategories::values() const
             {
                 return d_ptr->m_map.keys();
             }
-            QString QChartAxisCategories::label(qreal value) const
+            QString QAxisCategories::label(qreal value) const
             {
                 return d_ptr->m_map.value(value);
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChartAxisCategoriesPrivate::QChartAxisCategoriesPrivate(QChartAxisCategories *q):
+            QAxisCategoriesPrivate::QAxisCategoriesPrivate(QAxisCategories *q):
             q_ptr(q)
             {
             }
-            QChartAxisCategoriesPrivate::~QChartAxisCategoriesPrivate()
+            QAxisCategoriesPrivate::~QAxisCategoriesPrivate()
             {
             }
-            #include "moc_qchartaxiscategories.cpp"
+            #include "moc_qaxiscategories.cpp"
-            #include "moc_qchartaxiscategories_p.cpp"
+            #include "moc_qaxiscategories_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qaxiscategories.h ~~src/axis/qchartaxiscategories.h~~ renamed +7 -7

             /****************************************************************************
             **
             ** 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 QCHARTAXISCATEGORIES_H
+            #ifndef QAXISCATEGORIES_H
-            #define QCHARTAXISCATEGORIES_H
+            #define QAXISCATEGORIES_H
             #include <qchartglobal.h>
             #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChartAxisCategoriesPrivate;
+            class QAxisCategoriesPrivate;
-            class QTCOMMERCIALCHART_EXPORT QChartAxisCategories : public QObject
+            class QTCOMMERCIALCHART_EXPORT QAxisCategories : public QObject
             {
                 Q_OBJECT
             private:
-                QChartAxisCategories();
+                QAxisCategories();
             public:
-                ~QChartAxisCategories();
+                ~QAxisCategories();
                 void insert(const QBarCategories &category);
                 void insert(qreal value,QString label);
                 void remove(qreal value);
                 QList<qreal> values() const;
                 QString label(qreal value) const;
                 void clear();
                 int count();
             private:
-                QScopedPointer<QChartAxisCategoriesPrivate> d_ptr;
+                QScopedPointer<QAxisCategoriesPrivate> d_ptr;
                 friend class QAxisPrivate;
                 friend class ChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXISCATEGORIES_H_ */

src/axis/qaxiscategories_p.h ~~src/axis/qchartaxiscategories_p.h~~ renamed +8 -8

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
-            #ifndef QCHARTAXISCATEGORIES_P_H
+            #ifndef QAXISCATEGORIES_P_H
-            #define QCHARTAXISCATEGORIES_P_H
+            #define QAXISCATEGORIES_P_H
-            #include "qchartaxiscategories.h"
+            #include "qaxiscategories.h"
             #include <QMap>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChartAxisCategoriesPrivate : public QObject
+            class QAxisCategoriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
-                QChartAxisCategoriesPrivate(QChartAxisCategories *q);
+                QAxisCategoriesPrivate(QAxisCategories *q);
-                ~QChartAxisCategoriesPrivate();
+                ~QAxisCategoriesPrivate();
             Q_SIGNALS:
                 void updated();
             private:
-                QChartAxisCategories *q_ptr;
+                QAxisCategories *q_ptr;
                 QMap<qreal,QString> m_map;
-                friend class QChartAxisCategories;
+                friend class QAxisCategories;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/barchartitem.cpp 0 -2

             /****************************************************************************
             **
             ** 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 "barchartitem_p.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qchart.h"
-            //#include "qchartaxis.h"
-            #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_layoutSet(false),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleModelChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::dataChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->categoryCount(); c++) {
                     QString category = m_series->d_func()->categoryName(c);
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         Bar *bar = new Bar(set,category,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(QString)), set, SIGNAL(clicked(QString)));
                         connect(bar, SIGNAL(clicked(QBarSet*,QString)), m_series, SIGNAL(clicked(QBarSet*,QString)));
                         connect(bar, SIGNAL(hovered(bool)), set, SIGNAL(hovered(bool)));
                         connect(bar, SIGNAL(hovered(QBarSet*,bool)), m_series, SIGNAL(hovered(QBarSet*,bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create labels
                 for (int category = 0; category < m_series->categoryCount(); category++) {
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         BarLabel *value = new BarLabel(*set, this);
                         m_labels.append(value);
                         connect(set->d_ptr.data(),SIGNAL(labelsVisibleChanged(bool)),value,SLOT(labelsVisibleChanged(bool)));
                     }
                 }
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy
                 qreal categoryCount = m_series->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal range = m_domainMaxY - m_domainMinY;
                 qreal scale = (height / range);
                 qreal categoryWidth = width / categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + barWidth / 2 + geometry().topLeft().x();
                     qreal yPos = height + scale * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSet* barSet = m_series->d_func()->barsetAt(set);
                         qreal barHeight = barSet->at(category) * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->pen());
                         bar->setBrush(barSet->brush());
                         BarLabel* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->at(category))) {
                             label->setText(QString::number(barSet->at(category)));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->labelFont());
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, m_layout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++)
                     m_bars.at(i)->setRect(layout.at(i));
                 update();
             }
             //handlers
             void BarChartItem::handleModelChanged()
             {
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
                 m_layoutSet = true;
             }
             void BarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem_p.h +1 -1

             /****************************************************************************
             **
             ** 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 BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class BarLabel;
-            class QChartAxisCategories;
+            class QAxisCategories;
             class QChart;
             //typedef QVector<QRectF> BarLayout;
             class BarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 virtual QVector<QRectF> calculateLayout();
                 void applyLayout(const QVector<QRectF> &layout);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 QRectF geometry() const { return m_rect;}
             public Q_SLOTS:
                 void handleModelChanged();
                 void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF &size);
                 void handleLayoutChanged();
             protected:
                 qreal m_domainMinX;
                 qreal m_domainMaxX;
                 qreal m_domainMinY;
                 qreal m_domainMaxY;
                 QRectF m_rect;
                 bool m_layoutSet;    // True, if component has been laid out.
                 QVector<QRectF> m_layout;
                 // Not owned.
                 QBarSeries *m_series;
                 QList<Bar *> m_bars;
                 QList<BarLabel *> m_labels;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/chartdataset.cpp +1 -1

             /****************************************************************************
             **
             ** 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 "chartdataset_p.h"
             #include "qaxis.h"
             #include "qaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QAxis(this)),
                 m_axisY(new QAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
             }
             void ChartDataSet::addSeries(QAbstractSeries* series, QAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axisX()->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    emit axisAdded(axisX(),domain);
                    m_axisXInitialized=true;
                 }
                 series->d_ptr->scaleDomain(*domain);
                 if(series->type() == QAbstractSeries::SeriesTypeBar
                         || series->type() == QAbstractSeries::SeriesTypeStackedBar
                         || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 emit seriesAdded(series,domain);
             }
             QAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
                 QAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
                 QList<QAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=axisY()){
                         axis->setParent(0);
                     }
                     delete domain;
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
                 QList<QAxis*> axes;
                 foreach(QAbstractSeries *s , series) {
                     QAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==0);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
-               QChartAxisCategories* categories = axisX()->categories();
+               QAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
             int ChartDataSet::seriesCount(QAbstractSeries::QSeriesType type)
             {
                 int count=0;
                 QMapIterator<QAbstractSeries*, QAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
             QAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
             	QAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
             	 QMapIterator<QAxis*, Domain*> i( m_axisDomainMap);
             	 	while (i.hasNext()) {
             	        i.next();
             	        i.value()->move(dx,dy,size);
             	    }
             }
             #include "moc_chartdataset_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