HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r149:23a271e217e1

Remove PlotDomain , use Domain insted...

Michal Klocek -

r149:23a271e217e1

parent child

Context file:

r149:23a271e217e1

Collapse all files

src/barchart/bar.cpp 0 -4

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QGraphicsItem *parent)
                 : ChartItem(parent)
             {
             }
             void Bar::setSize(const QSizeF& size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
-            void Bar::setPlotDomain(const PlotDomain& data)
-                mPlotDomain = data;
             void Bar::resize( qreal w, qreal h )
             {
             //    qDebug() << "bar::resize" << w << h;
                 mWidth = w;
                 mHeight = h;
             }
             void Bar::setColor( QColor col )
             {
                 mColor = col;
             }
             void Bar::setPos(qreal x, qreal y)
             {
              //   qDebug() << "Bar::setpos" << x << y;
                 mXpos = x;
                 mYpos = y;
             }
             void Bar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (0 == mHeight) {
                     return;
                 }
                 // TODO: accept brush instead of color
                 QBrush brush(mColor);
                 painter->setBrush(brush);
                 // This compensates for rounding errors. drawRect takes ints and cumulative error of pos + size may be over 1.
                 int x0 = mXpos;
                 int x1 = (mXpos + mWidth);
                 int w = x1-x0;
                 int y0 = mYpos;
                 int y1 = (mYpos + mHeight);
                 int h = y1-y0;
                 painter->drawRect(x0, y0 ,w ,h);
             }
             QRectF Bar::boundingRect() const
             {
                 QRectF r(mXpos, mYpos, mXpos + mWidth, mYpos + mHeight);
                 return r;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar_p.h 0 -2

             #ifndef BAR_H
             #define BAR_H
             #include "chartitem_p.h"
             #include "qchartglobal.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Single bar item of chart
             class Bar : public ChartItem
             {
             public:
                 Bar(QGraphicsItem *parent=0);
             public: // from ChartItem
                 void setSize(const QSizeF &size);
-                void setPlotDomain(const PlotDomain& data);
                 // Layout Stuff
                 void resize( qreal w, qreal h );   // Size of bar.
                 void setColor( QColor col );       // Color of bar
                 void setPos(qreal x, qreal y);
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
             private:
                 qreal mHeight;
                 qreal mWidth;
                 qreal mXpos;
                 qreal mYpos;
                 QColor mColor;
-                PlotDomain mPlotDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BAR_H

src/barchart/barlabel.cpp 0 -5

             #include "barlabel_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarLabel::BarLabel(QGraphicsItem* parent) : ChartItem(parent)
             {
             }
             void BarLabel::set(QString label)
             {
                 mLabel = label;
             }
             void BarLabel::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void BarLabel::setSize(const QSizeF &size)
             {
                 mSize = size;
             }
-            void BarLabel::setPlotDomain(const PlotDomain& data)
-                mDomain = data;
             void BarLabel::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 painter->drawText(boundingRect(),mLabel);
             }
             QRectF BarLabel::boundingRect() const
             {
                 QRectF r(mXpos, mYpos, mXpos + mSize.width(), mYpos + mSize.height());
                 return r;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barlabel_p.h 0 -2

             #ifndef BARLABEL_H
             #define BARLABEL_H
             #include "chartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class BarLabel : public ChartItem
             {
             public:
                 BarLabel(QGraphicsItem* parent = 0);
                 void set(QString label);
                 void setPos(qreal x, qreal y);
                 // From ChartItem
                 void setSize(const QSizeF &size);
-                void setPlotDomain(const PlotDomain& data);
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             private:
-                PlotDomain mDomain;
                 QSizeF mSize;
                 QString mLabel;
                 qreal mXpos;
                 qreal mYpos;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARLABEL_H

src/barchart/separator.cpp 0 -5

             #include "separator_p.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Separator::Separator(QGraphicsItem *parent)
                 : ChartItem(parent)
             {
             }
             void Separator::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void Separator::setColor(QColor color)
             {
                 mColor = color;
             }
             void Separator::setSize(const QSizeF &size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
-            void Separator::setPlotDomain(const PlotDomain& data)
             void Separator::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 qDebug() << "separator::paint" << boundingRect();
                 QPen pen(mColor);
                 painter->setPen(pen);
                 painter->drawLine(mXpos,mYpos,mXpos,mHeight);
             }
             QRectF Separator::boundingRect() const
             {
                 QRectF r(mXpos,mYpos,mWidth,mHeight);
                 return r;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/separator_p.h 0 -1

             #ifndef SEPARATOR_H
             #define SEPARATOR_H
             #include "chartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Separator : public ChartItem
             {
             public:
                 Separator(QGraphicsItem *parent = 0);
                 void setPos(qreal x, qreal y);
                 void setColor(QColor color);
                 // From ChartItem
                 void setSize(const QSizeF &size);
-                void setPlotDomain(const PlotDomain& data);
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
             private:
                 QColor mColor;
                 qreal mXpos;
                 qreal mYpos;
                 qreal mHeight;
                 qreal mWidth;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SEPARATOR_H

src/chartitem_p.h 0 -1

             #ifndef CHARTITEM_H_
             #define CHARTITEM_H_
-            #include "plotdomain_p.h"
             #include "domain_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartAnimationManager;
             class ChartItem : public QGraphicsItem
             {
                 enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM};
             public:
                 ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent){};
                 virtual ~ChartItem(){};
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTITEM_H_ */

src/piechart/piepresenter.cpp +4 -14

             #include "piepresenter.h"
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PiePresenter::PiePresenter(QGraphicsItem *parent, QPieSeries *series) :
                 ChartItem(parent),
                 m_pieSeries(series)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 m_rect = parentItem()->boundingRect();
                 setAcceptHoverEvents(true);
             }
             PiePresenter::~PiePresenter()
             {
                 while (m_slices.count())
                     delete m_slices.takeLast();
             }
             void PiePresenter::seriesChanged()
             {
                 const qreal fullPie = 360;
                 qreal total = 0;
                 // calculate total
                 foreach (QPieSlice sliceData, m_pieSeries->slices())
                     total += sliceData.m_value;
                 // TODO: no need to create new slices in case size changed; we should re-use the existing ones
                 while (m_slices.count())
                     delete m_slices.takeLast();
                 // create slices
                 qreal angle = 0;
                 for (int i=0; i<m_pieSeries->count(); i++) {
                     QPieSlice sliceData = m_pieSeries->slice(i);
                     qreal span = sliceData.m_value / total * fullPie;
                     PieSlice *slice = new PieSlice(this, i, angle, span);
                     m_slices.append(slice);
                     angle += span;
                 }
                 resize();
             }
-            void PiePresenter::setSize(const QSizeF &size)
-                // TODO: allow user setting the size?
-                // TODO: allow user defining the margins?
-                m_rect.setSize(size);
-                resize();
-            void PiePresenter::setPlotDomain(const PlotDomain& plotDomain)
-                // TODO
             void PiePresenter::resize()
             {
                 m_pieRect = m_rect;
                 if (m_pieRect.width() < m_pieRect.height()) {
                     m_pieRect.setWidth(m_pieRect.width() * m_pieSeries->m_sizeFactor);
                     m_pieRect.setHeight(m_pieRect.width());
                     m_pieRect.moveCenter(m_rect.center());
                 } else {
                     m_pieRect.setHeight(m_pieRect.height() * m_pieSeries->m_sizeFactor);
                     m_pieRect.setWidth(m_pieRect.height());
                     m_pieRect.moveCenter(m_rect.center());
                 }
                 switch (m_pieSeries->m_position) {
                     case QPieSeries::PiePositionTopLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, m_rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF(m_rect.center().x() / 2, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         m_pieRect.setHeight(m_pieRect.height() / 2);
                         m_pieRect.setWidth(m_pieRect.height());
                         m_pieRect.moveCenter(QPointF((m_rect.center().x() / 2) * 3, (m_rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 qDebug() << "presentation rect:" << m_rect;
                 qDebug() << "pie rect:" << m_pieRect;
             }
             void PiePresenter::handleDomainChanged(const Domain& domain)
             {
                 // TODO
             }
             void PiePresenter::handleGeometryChanged(const QRectF& rect)
             {
-                setSize(rect.size());
+                // TODO: allow user setting the size?
+                // TODO: allow user defining the margins?
+                m_rect.setSize(rect.size());
+                resize();
             }
             #include "moc_piepresenter.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piepresenter.h 0 -2

             #ifndef PIEPRESENTER_H
             #define PIEPRESENTER_H
             #include "chartitem_p.h"
             #include "qpieseries.h"
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
             class PiePresenter : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 // TODO: use a generic data class instead of x and y
                 PiePresenter(QGraphicsItem *parent, QPieSeries *series);
                 ~PiePresenter();
             public: // from ChartItem
-                void setSize(const QSizeF &size);
-                void setPlotDomain(const PlotDomain& data);
                 QRectF boundingRect() const { return m_rect; }
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public:
                 void seriesChanged();
                 void resize();
                 QRectF pieRect() const { return m_pieRect; }
             public Q_SLOTS:
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& rect);
             private:
                 friend class PieSlice;
                 QList<PieSlice*> m_slices;
                 QPieSeries *m_pieSeries;
                 QRectF m_rect;
                 QRectF m_pieRect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIEPRESENTER_H

src/qchart.cpp 0 -5

             #include "qchart.h"
-            #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qchartaxis.h"
-            #include "charttheme_p.h"
-            #include "chartitem_p.h"
-            #include "plotdomain_p.h"
-            #include "axisitem_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
             void QChart::addSeries(QChartSeries* series)
             {
                 m_dataset->addSeries(series);
             }
             //TODO on review, is it really needed ??
             QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 // TODO: support also other types; not only scatter and pie
                 QChartSeries *series(0);
                 switch (type) {
                     case QChartSeries::SeriesTypeLine: {
                         series = QLineChartSeries::create();
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         series = new BarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         series = new StackedBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         series = new PercentBarChartSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         series = new QScatterSeries(this);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         series = new QPieSeries(this);
                         break;
                     }
                     default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setTitle(const QString& title,const QFont& font)
             {
                 if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
                 m_titleItem->setPlainText(title);
                 m_titleItem->setFont(font);
             }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
                 m_presenter->setTheme(theme);
             }
             QChart::ChartThemeId QChart::theme()
             {
                 return (QChart::ChartThemeId) m_presenter->theme();
             }
             void QChart::zoomInToRect(const QRectF& rectangle)
             {
                 m_presenter->zoomInToRect(rectangle);
             }
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qscatterseries.cpp +2 -2

             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qchart.h"
             #include <QPainter>
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //#define QSeriesData QList<qreal>
             QScatterSeriesPrivate::QScatterSeriesPrivate(QGraphicsItem *parent) :
                 ChartItem(parent),
                 m_boundingRect(),
                 m_markerColor(QColor()),
                 m_visibleChartArea()
             {
                 if (parent)
                     m_boundingRect = parent->boundingRect();
             }
             void QScatterSeriesPrivate::changeGeometry()
             {
                 if (m_boundingRect.isValid()) {
                     prepareGeometryChange();
                     qreal scalex = m_boundingRect.width() / m_visibleChartArea.spanX();
                     qreal scaley = m_boundingRect.height() / m_visibleChartArea.spanY();
                     m_scenex.clear();
                     m_sceney.clear();
                     // Convert relative coordinates to absolute pixel coordinates that can be used for drawing
                     foreach(qreal x, m_x)
                         m_scenex.append(m_boundingRect.left() + x * scalex - m_visibleChartArea.m_minX * scalex);
                     foreach(qreal y, m_y)
                         m_sceney.append(m_boundingRect.bottom() - y * scaley + m_visibleChartArea.m_minY * scaley);
                 }
             }
             void QScatterSeriesPrivate::setSize(const QSizeF &size)
             {
             //    m_boundingRect = QRectF(pos().x(), pos().y(), size.width(), size.height());
                 m_boundingRect = QRectF(0, 0, size.width(), size.height());
                 changeGeometry();
             }
             void QScatterSeriesPrivate::themeChanged(ChartTheme *theme)
             {
                 //m_theme = theme->themeForSeries();
             }
-            void QScatterSeriesPrivate::setPlotDomain(const PlotDomain& plotDomain)
+            void QScatterSeriesPrivate::setPlotDomain(const Domain& plotDomain)
             {
-                m_visibleChartArea = plotDomain;
+                //m_visibleChartArea = plotDomain;
                 changeGeometry();
             }
             QRectF QScatterSeriesPrivate::boundingRect() const
             {
                 return m_boundingRect;
             }
             void QScatterSeriesPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
             {
                 // TODO: The opacity should be user definable?
                 //brush.setColor(QColor(255, 82, 0, 100));
                 if (m_markerColor.isValid()) {
                     QPen pen = painter->pen();
                     QBrush brush = pen.brush();
                     brush.setColor(m_markerColor);
                     pen.setBrush(brush);
                     pen.setWidth(4);
                     painter->setPen(pen);
                 }
                 else
                     //painter->setPen(m_theme.markerPen);
             //        brush.setColor(m_theme..lineColor);
                 // TODO: m_scenex and m_sceny are left empty during construction -> we would need a resize
                 // event right after construction or maybe given a size during initialization
                 for (int i(0); i < m_scenex.count() && i < m_sceney.count(); i++) {
                     if (scene()->width() > m_scenex.at(i) && scene()->height() > m_sceney.at(i))
                         //painter->drawArc(m_scenex.at(i), m_sceney.at(i), 2, 2, 0, 5760);
                         painter->drawPoint(m_scenex.at(i), m_sceney.at(i));
                 }
             }
             QScatterSeries::QScatterSeries(QObject *parent) :
                 QChartSeries(parent),
                 d(new QScatterSeriesPrivate(qobject_cast<QGraphicsItem *> (parent)))
             {
             }
             bool QScatterSeries::setData(QList<qreal> xlist, QList<qreal> ylist)
             {
                 // TODO: validate data
                 d->m_x = xlist;
                 d->m_y = ylist;
                 // TODO: the following updates the visible chart area setting of the series, we would instead
                 // need to update the _chart's_ visible area... this would require a callback or
                 // similar to the parenting QChart object...
                 foreach (qreal x, d->m_x) {
                     d->m_visibleChartArea.m_minX = qMin(d->m_visibleChartArea.m_minX, x);
                     d->m_visibleChartArea.m_maxX = qMax(d->m_visibleChartArea.m_maxX, x);
                 }
                 foreach (qreal y, d->m_y) {
                     d->m_visibleChartArea.m_minY = qMin(d->m_visibleChartArea.m_minY, y);
                     d->m_visibleChartArea.m_maxY = qMax(d->m_visibleChartArea.m_maxY, y);
                 }
                 d->changeGeometry();
                 return true;
             }
             void QScatterSeries::setMarkerColor(QColor color)
             {
                 d->m_markerColor = color;
             }
             QColor QScatterSeries::markerColor()
             {
                 return d->m_markerColor;
             }
             // TODO:
             //void QScatterSeries::chartScaleChanged(qreal xscale, qreal yscale)
             //{
             //    d->rescale(xscale, yscale);
             //}
             QScatterSeries::~QScatterSeries()
             {
                 delete d;
             }
             #include "moc_qscatterseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qscatterseries_p.h +3 -3

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartseries.h"
             #include "charttheme_p.h"
             #include "chartitem_p.h"
-            #include "plotdomain_p.h"
+            #include "domain_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
             class QScatterSeriesPrivate : public ChartItem
             {
             public:
                 QScatterSeriesPrivate(QGraphicsItem *parent);
             public: // from ChartObjectInterface
                 void setSize(const QSizeF &size);
-                void setPlotDomain(const PlotDomain& data);
+                void setPlotDomain(const Domain& data);
             public: // from ChartThemeObserver
                 void themeChanged(ChartTheme *theme);
             public: // from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
             public:
                 void changeGeometry();
                 QRectF m_boundingRect;
                 // TODO: use the chart data class instead of list of x and y values?
                 QList<qreal> m_x;
                 QList<qreal> m_y;
                 QList<qreal> m_scenex;
                 QList<qreal> m_sceney;
                 QColor m_markerColor;
                 //SeriesTheme m_theme;
-                PlotDomain m_visibleChartArea;
+                Domain m_visibleChartArea;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIESPRIVATE_H

src/src.pro 0 -2

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += barchart/barchartseries.cpp \
                 barchart/bargroup.cpp \
                 barchart/bar.cpp \
                 barchart/stackedbarchartseries.cpp \
                 barchart/stackedbargroup.cpp \
                 barchart/percentbarchartseries.cpp \
                 barchart/percentbargroup.cpp \
                 barchart/barlabel.cpp \
                 linechart/linechartanimationitem.cpp \
                 linechart/linechartitem.cpp \
                 linechart/qlinechartseries.cpp \
                 barchart/separator.cpp \
                 barchart/bargroupbase.cpp \
                 barchart/barchartseriesbase.cpp \
-                plotdomain.cpp \
                 qscatterseries.cpp \
                 qchart.cpp \
                 axisitem.cpp \
                 qchartview.cpp \
                 qchartseries.cpp \
                 qchartaxis.cpp \
                 charttheme.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 domain.cpp
             PRIVATE_HEADERS += linechart/linechartitem_p.h \
                 linechart/linechartanimationitem_p.h \
                 barchart/barlabel_p.h \
                 barchart/bar_p.h \
                 barchart/separator_p.h \
-                plotdomain_p.h \
                 qscatterseries_p.h \
                 axisitem_p.h \
                 chartitem_p.h \
                 charttheme_p.h \
                 chartdataset_p.h \
                 chartpresenter_p.h \
                 domain_p.h
             PUBLIC_HEADERS += linechart/qlinechartseries.h \
                 barchart/barchartseries.h \
                 barchart/bargroup.h \
                 barchart/stackedbarchartseries.h \
                 barchart/stackedbargroup.h \
                 barchart/percentbarchartseries.h \
                 barchart/percentbargroup.h \
                 barchart/barchartseriesbase.h \
                 barchart/bargroupbase.h \
                 qchartseries.h \
                 qscatterseries.h \
                 qchart.h \
                 qchartglobal.h \
                 qchartview.h \
                 qchartaxis.h
             include(piechart/piechart.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_headers.name = bild_headers
             install_build_headers.output = $$CHART_BUILD_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_headers.input = PUBLIC_HEADERS
             install_build_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_HEADER_DIR
             install_build_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR

src/plotdomain.cpp removed 0 -45

NO CONTENT: file was removed

src/plotdomain_p.h removed 0 -28

NO CONTENT: file was removed

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