HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r115:8cafc623ea10

Adds layout support for charts....

Michal Klocek -

r115:8cafc623ea10

parent child

Context file:

r115:8cafc623ea10

Expand all files

src/axisitem.cpp +1 -1

             #include "axisitem_p.h"
             #include <QPainter>
             #include <QDebug>
             #define LABEL_PADDING 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
                 ChartItem(parent),
                 m_ticks(4),
                 m_type(type)
             {
             }
             AxisItem::~AxisItem()
             {
             }
             void AxisItem::setLength(int length)
             {
                 QPainterPath path;
                 path.moveTo(QPointF(0,0));
                 path.lineTo(length,0);
                // path.lineTo(length-4,0);
                // path.lineTo(length,3);
                // path.lineTo(length-4,6);
                // path.lineTo(length-4,4);
                // path.lineTo(0,4);
                // path.lineTo(0,2);
                 m_path=path;
                 update();
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
             void AxisItem::setPlotDomain(const PlotDomain& plotDomain)
             {
                 m_plotDomain = plotDomain;
                 createItems();
             }
-            void AxisItem::setSize(const QSize &size)
+            void AxisItem::setSize(const QSizeF &size)
             {
                 m_rect = QRectF(QPoint(0,0),size);
                 createItems();
             }
             /*
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget)
             {
                 if (!m_rect.isValid())
                 return;
                 if(m_type==X_AXIS) {
                     const qreal deltaX = m_rect.width() / m_ticks;
                     for (int i = 0; i <= m_ticks; ++i) {
                         int x = i * deltaX + m_rect.left();
                         if(i==0) x--;
                         if(i==m_ticks) x++;
                         qreal label = m_plotDomain.m_minX + (i * m_plotDomain.spanX()
                             / m_ticks);
                         painter->drawLine(x, m_rect.top()-1, x, m_rect.bottom()+1);
                        // painter->drawLine(x, m_rect.bottom()-1, x, m_rect.bottom()-1 + 5);
                         painter->drawText(x - 50, m_rect.bottom() + 5, 100, 20,Qt::AlignHCenter | Qt::AlignTop, QString::number(label));
                     }
                 }
                 if(m_type==Y_AXIS) {
                     const qreal deltaY = (m_rect.height()) / m_ticks;
                     for (int j = 0; j <= m_ticks; ++j) {
                         int y = j * -deltaY + m_rect.bottom();
                         if(j==0) y++;
                         if(j==m_ticks) y--;
                         qreal label = m_plotDomain.m_minY + (j * m_plotDomain.spanY()
                             / m_ticks);
                         painter->drawLine(m_rect.left()-1, y, m_rect.right()+1, y);
                         //painter->drawLine(m_rect.left() - 5, y, m_rect.left(), y);
                         //TODO : margin = 50 ;
                         painter->drawText(m_rect.left() - 50, y - 10, 50 - 5, 20,
                             Qt::AlignRight | Qt::AlignVCenter,
                             QString::number(label));
                     }
                 }
                 //painter->drawRect(m_rect.adjusted(0, 0, -1, -1));
             }
             */
             void AxisItem::createItems()
             {
                 //TODO: this is very inefficient handling
                     qDeleteAll(m_shades);
                     m_shades.clear();
                     qDeleteAll(m_grid);
                     m_grid.clear();
                     qDeleteAll(m_labels);
                     m_labels.clear();
                    if(m_type==X_AXIS) {
                      const qreal deltaX = m_rect.width() / m_ticks;
                      for (int i = 0; i <= m_ticks; ++i) {
                          int x = i * deltaX + m_rect.left();
                          qreal label = m_plotDomain.m_minX + (i * m_plotDomain.spanX()/ m_ticks);
                          m_grid<<new QGraphicsLineItem(x, m_rect.top(), x, m_rect.bottom(),this);
                          QGraphicsSimpleTextItem* text = new QGraphicsSimpleTextItem(QString::number(label),this);
                          QPointF center = text->boundingRect().center();
                          text->setPos(x - center.x(), m_rect.bottom() + LABEL_PADDING);
                          //text->rotate(-45);
                          m_labels<<text;
                      }
                    }
                    if(m_type==Y_AXIS) {
                      const qreal deltaY = m_rect.height()/ m_ticks;
                      for (int j = 0; j <= m_ticks; ++j) {
                          int y = j * -deltaY + m_rect.bottom();
                          qreal label = m_plotDomain.m_minY + (j * m_plotDomain.spanY()
                              / m_ticks);
                          m_grid<<new QGraphicsLineItem(m_rect.left()  , y, m_rect.right(), y,this);
                          QGraphicsSimpleTextItem* text = new QGraphicsSimpleTextItem(QString::number(label),this);
                          QPointF center = text->boundingRect().center();
                          text->setPos(m_rect.left() - text->boundingRect().width() - LABEL_PADDING , y-center.y());
                          //text->rotate(-45);
                           m_labels<<text;
                      }
                    }
                    //painter->drawRect(m_rect.adjusted(0, 0, -1, -1));
             }
             //TODO "nice numbers algorithm"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +1 -1

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "plotdomain_p.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem : public ChartItem
             {
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
                 ~AxisItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){};
             public: // from ChartItem
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
             public:
                 void setLength(int length);
                 void setWidth(int width);
                 AxisType axisType() const {return m_type;};
             private:
                 void createItems();
             private:
                 QRectF m_rect;
                 int m_ticks;
                 PlotDomain m_plotDomain;
                 QPainterPath m_path;
                 QList<QGraphicsLineItem*> m_grid;
                 QList<QGraphicsRectItem*> m_shades;
                 QList<QGraphicsSimpleTextItem*> m_labels;
                 AxisType m_type;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/barchart/bar.cpp +1 -1

             #include "bar.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QGraphicsItem *parent)
                 : ChartItem(parent)
             {
             }
-            void Bar::setSize(const QSize& size)
+            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.h +1 -1

             #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 QSize &size);
+                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/bargroup.cpp +1 -1

             #include "bargroup.h"
             #include "bar.h"
             #include "barlabel_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarGroup::BarGroup(BarChartSeries& series, QGraphicsItem *parent) :
                 ChartItem(parent)
                 ,mSeries(series)
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
                 ,mBarDefaultWidth(10)
             {
                 dataChanged();
             }
-            void BarGroup::setSize(const QSize& size)
+            void BarGroup::setSize(const QSizeF& size)
             {
                 qDebug() << "BarGroup::setSize";
                 mWidth = size.width();
                 mHeight = size.height();
                 layoutChanged();
                 mLayoutSet = true;
             }
             void BarGroup::setPlotDomain(const PlotDomain& data)
             {
                 qDebug() << "BarGroup::setPlotDomain";
                 // TODO:
                 mPlotDomain = data;
             }
             void BarGroup::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             int BarGroup::addColor( QColor color )
             {
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
             void BarGroup::resetColors()
             {
                 mColors.clear();
             }
             void BarGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "QBarChart::paint called without layout set. Aborting.";
                     return;
                 }
                 if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     mLayoutDirty = false;
                     }
                 }
             }
             QRectF BarGroup::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarGroup::dataChanged()
             {
                 qDebug() << "QBarChart::dataChanged mSeries";
                 // Find out maximum and minimum of all series
                 mMax = mSeries.max();
                 mMin = mSeries.min();
                 // Delete old bars
                 // Is this correct way to delete childItems?
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mSeries.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 // TODO: labels from series. This creates just some example labels
                 int count = mSeries.countColumns();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     QString text("Label " + QString::number(i));
                     label->set(text);
                     childItems().append(label);
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             void BarGroup::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries.countRows() <= 0) {
                     // Nothing to do.
                     return;
                 }
                 // TODO: better way to auto-layout?
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int columnCount = mSeries.countColumns();
                 int rowCount = mSeries.countRows();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mMax;
                 qreal scale = (tH/tM);
                 qreal tC = columnCount+1;
                 qreal xStepPerSeries = (tW/tC);
                 // Scaling.
                 int itemIndex(0);
                 int labelIndex = mSeries.countColumns() * mSeries.countRows();
                 for (int column=0; column < columnCount; column++) {
                     qreal xPos = xStepPerSeries * column + ((tW + mBarDefaultWidth*rowCount)/(columnCount*2));
                     qreal yPos = mHeight;
                     for (int row = 0; row < rowCount; row++) {
                         qreal barHeight = mSeries.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + series * mBarDefaultWidth, mHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                     // TODO: Layout for labels, remove magic number
                     xPos = xStepPerSeries * column + ((tW + mBarDefaultWidth*rowCount)/(columnCount*2));
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bargroup.h +1 -1

             #ifndef QBARGROUP_H
             #define QBARGROUP_H
             #include "chartitem_p.h"
             #include "bar.h"
             #include "barchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class BarGroup : public ChartItem
             {
             public:
                 explicit BarGroup(BarChartSeries& series, QGraphicsItem *parent = 0);
             public: // from ChartItem
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
                 // Layout "api"
                 void setPos(qreal x, qreal y);
                 void setBarWidth( int w );          // Default width for each bar
                 int addColor( QColor color );
                 void resetColors();
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             private:
                 void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
                 BarChartSeries& mSeries;
                 int mMin;                                   // Min and max values of data. (updated when data is changed, used when drawing)
                 int mMax;
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 QList<QColor> mColors;  // List of colors for series for now
                 PlotDomain mPlotDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARGROUP_H

src/barchart/percentbargroup.cpp +1 -1

             #include "percentbargroup.h"
             #include "bar.h"
             #include "barlabel_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarGroup::PercentBarGroup(PercentBarChartSeries& series, QGraphicsItem *parent) :
               ChartItem(parent)
               ,mSeries(series)
               ,mLayoutSet(false)
               ,mLayoutDirty(true)
               ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
             {
                 dataChanged();
             }
-            void PercentBarGroup::setSize(const QSize& size)
+            void PercentBarGroup::setSize(const QSizeF& size)
             {
             //    qDebug() << "PercentBarGroup::setSize";
                 mWidth = size.width();
                 mHeight = size.height();
                 layoutChanged();
                 mLayoutSet = true;
             }
             void PercentBarGroup::setPlotDomain(const PlotDomain& data)
             {
                 qDebug() << "PercentBarGroup::setPlotDomain";
                 // TODO:
             }
             void PercentBarGroup::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             int PercentBarGroup::addColor( QColor color )
             {
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
             void PercentBarGroup::resetColors()
             {
                 mColors.clear();
             }
             void PercentBarGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "QBarChart::paint called without layout set. Aborting.";
                     return;
                 }
                 if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
                     mLayoutDirty = false;
                 }
             }
             QRectF PercentBarGroup::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void PercentBarGroup::dataChanged()
             {
                 qDebug() << "QBarChart::dataChanged mSeries";
                 // Find out maximum and minimum of all series
                 mMax = mSeries.max();
                 mMin = mSeries.min();
                 // Delete old bars
                 // Is this correct way to delete childItems?
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mSeries.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 // TODO: labels from series. This creates just some example labels
                 int count = mSeries.countColumns();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     QString text("Label " + QString::number(i));
                     label->set(text);
                     childItems().append(label);
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             void PercentBarGroup::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries.countRows() <= 0) {
                     // Nothing to do.
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int count = mSeries.countColumns();
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
             //    qreal xPos = ((tW/tC) + mBarDefaultWidth / 2);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 int labelIndex = mSeries.countColumns() * mSeries.countRows();
                 for (int column = 0; column < mSeries.countColumns(); column++) {
                     qreal colSum = mSeries.columnSum(column);
                     qreal h = mHeight;
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int row=0; row < mSeries.countRows(); row++) {
                         qreal barHeight = mSeries.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbargroup.h +1 -1

             #ifndef PERCENTBARGROUP_H
             #define PERCENTBARGROUP_H
             #include "chartitem_p.h"
             #include "bar.h"
             #include "percentbarchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PercentBarGroup : public ChartItem
             {
             public:
                 PercentBarGroup(PercentBarChartSeries& series, QGraphicsItem *parent = 0);
             public: // From ChartItem
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
             public:
                 // Layout "api"
                 void setPos(qreal x, qreal y);
                 void setBarWidth( int w );          // Default width for each bar
                 int addColor( QColor color );
                 void resetColors();
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             private:
                 void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
                 PercentBarChartSeries& mSeries;
                 int mMin;                                   // Min and max values of data. (updated when data is changed, used when drawing)
                 int mMax;
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 QList<QColor> mColors;  // List of colors for series for now
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PERCENTBARGROUP_H

src/barchart/stackedbargroup.cpp +1 -1

             #include "stackedbargroup.h"
             #include "bar.h"
             #include "barlabel_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarGroup::StackedBarGroup(StackedBarChartSeries& series, QGraphicsItem *parent) :
               ChartItem(parent)
               ,mSeries(series)
               ,mLayoutSet(false)
               ,mLayoutDirty(true)
               ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
               ,mTheme(0)
             {
                 dataChanged();
             }
-            void StackedBarGroup::setSize(const QSize& size)
+            void StackedBarGroup::setSize(const QSizeF& size)
             {
             //    qDebug() << "StackedBarGroup::setSize";
                 mWidth = size.width();
                 mHeight = size.height();
                 layoutChanged();
                 mLayoutSet = true;
             }
             void StackedBarGroup::setPlotDomain(const PlotDomain& data)
             {
                 qDebug() << "StackedBarGroup::setPlotDomain";
                 // TODO:
             }
             void StackedBarGroup::themeChanged(ChartTheme *theme)
             {
                 mTheme = theme;
             }
             void StackedBarGroup::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
             int StackedBarGroup::addColor( QColor color )
             {
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
             void StackedBarGroup::resetColors()
             {
                 mColors.clear();
             }
             void StackedBarGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "QBarChart::paint called without layout set. Aborting.";
                     return;
                 }
                 if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
                     mLayoutDirty = false;
                 //TODO: draw labels.
                 }
             }
             QRectF StackedBarGroup::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void StackedBarGroup::dataChanged()
             {
                 qDebug() << "QBarChart::dataChanged mSeries";
                 // Find out maximum and minimum of all series
                 mMax = mSeries.max();
                 mMin = mSeries.min();
                 // Delete old bars
                 // Is this correct way to delete childItems?
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mSeries.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 // TODO: labels from series. This creates just some example labels
                 int count = mSeries.countColumns();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     QString text("Label " + QString::number(i));
                     label->set(text);
                     childItems().append(label);
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             void StackedBarGroup::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries.countRows() <= 0) {
                     // Nothing to do.
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 qreal maxSum = mSeries.maxColumnSum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int count = mSeries.countColumns();
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 int labelIndex = mSeries.countColumns() * mSeries.countRows();
                 for (int column = 0; column < mSeries.countColumns(); column++) {
                     qreal yPos = h;
                     for (int row=0; row < mSeries.countRows(); row++) {
                         qreal barHeight = mSeries.valueAt(row, column) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         // TODO: how to get color for series(x) from theme?
             //            mTheme->themeForSeries();
                         bar->resize(mBarDefaultWidth, barHeight);
                         bar->setColor(mColors.at(row));
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbargroup.h +1 -1

             #ifndef STACKEDBARGROUP_H
             #define STACKEDBARGROUP_H
             #include "charttheme_p.h"
             #include "chartitem_p.h"
             #include "barlabel_p.h"
             #include "bar.h"
             #include "stackedbarchartseries.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // TODO: derive this from ChartObjectInterface, when setSize is back in ChartItem
             class StackedBarGroup : public ChartItem, public ChartThemeObserver
             {
             public:
                 StackedBarGroup(StackedBarChartSeries& series, QGraphicsItem *parent = 0);
             public: // From ChartItem
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
                 // From ChartThemeObserver
                 void themeChanged(ChartTheme *theme);
             public: // Layout "api"
                 void setPos(qreal x, qreal y);
                 void setBarWidth( int w );          // Default width for each bar
                 int addColor( QColor color );
                 void resetColors();
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             private:
                 void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 void layoutChanged();   // layout has changed -> need to recalculate bar sizes
             private:
                 // Data
                 StackedBarChartSeries& mSeries;
                 int mMin;                                   // Min and max values of data. (updated when data is changed, used when drawing)
                 int mMax;
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 QList<QColor> mColors;  // List of colors for series for now
                 ChartTheme* mTheme;
             //    QList<BarLabel*> mLabels;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // STACKEDBARGROUP_H

src/chartitem_p.h +1 -1

             #ifndef CHARTITEM_H_
             #define CHARTITEM_H_
             #include "plotdomain_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem : public QGraphicsItem
             {
                 enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM};
             public:
                 ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent){};
                 virtual ~ChartItem(){};
-                virtual void setSize(const QSize &size) = 0;
+                virtual void setSize(const QSizeF &size) = 0;
                 virtual void setPlotDomain(const PlotDomain& data) = 0;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTITEM_H_ */

src/plotdomain.cpp +1 -1

             #include "plotdomain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PlotDomain::PlotDomain():
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0)
             {
             }
             PlotDomain::~PlotDomain()
             {
             	// TODO Auto-generated destructor stub
             }
             qreal PlotDomain::spanX() const
             {
             	Q_ASSERT(m_maxX >= m_minX);
             	return m_maxX - m_minX;
             }
             qreal PlotDomain::spanY() const
             {
             	Q_ASSERT(m_maxY >= m_minY);
             	return m_maxY - m_minY;
             }
-            PlotDomain PlotDomain::subDomain(const QRect& rect, qreal maxWidth,qreal maxHeight) const
+            PlotDomain PlotDomain::subDomain(const QRectF& rect, qreal maxWidth,qreal maxHeight) const
             {
               PlotDomain domain;
               qreal dx = spanX() / maxWidth;
               qreal dy = spanY() / maxHeight;
               domain.m_minX = m_minX + dx * rect.left();
               domain.m_maxX = m_minX + dx * rect.right();
               domain.m_minY = m_maxY - dy * rect.bottom();
               domain.m_maxY = m_maxY - dy * rect.top();
               return domain;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/plotdomain_p.h +1 -1

             #ifndef PLOTDOMAIN_H_
             #define PLOTDOMAIN_H_
             #include "qchartglobal.h"
             #include <QRect>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PlotDomain {
             public:
             	PlotDomain();
             	virtual ~PlotDomain();
             	qreal spanX() const;
             	qreal spanY() const;
-            	PlotDomain subDomain(const QRect& rect, qreal maxWidth, qreal maxHeight) const;
+            	PlotDomain subDomain(const QRectF& rect, qreal maxWidth, qreal maxHeight) const;
             public:
             	qreal m_minX;
             	qreal m_maxX;
             	qreal m_minY;
             	qreal m_maxY;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* PLOTTER_H_ */

src/qchart.cpp +38 -34

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qxychartseries.h"
             #include "qchartaxis.h"
             #include "barchartseries.h"
             #include "bargroup.h"
             #include "stackedbarchartseries.h"
             #include "stackedbargroup.h"
             #include "percentbarchartseries.h"
             #include "percentbargroup.h"
             #include "charttheme_p.h"
             #include "chartitem_p.h"
             #include "xylinechartitem_p.h"
             #include "plotdomain_p.h"
             #include "axisitem_p.h"
             #include <QGraphicsScene>
+            #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QChart::QChart(QGraphicsObject* parent) : QGraphicsObject(parent),
+            QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_axisXItem(new AxisItem(AxisItem::X_AXIS, this)),
                 m_plotDataIndex(0),
                 m_marginSize(0),
                 m_chartTheme(new ChartTheme(this))
             {
                 // TODO: the default theme?
                 setTheme(QChart::ChartThemeDefault);
                 PlotDomain domain;
                 m_plotDomainList << domain;
                 m_axisYItem << new AxisItem(AxisItem::Y_AXIS,this);
                 m_chartItems << m_axisXItem;
                 m_chartItems << m_axisYItem.at(0);
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
                 return m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 m_plotDataIndex = 0 ;
                 m_plotDomainList.resize(1);
                 PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                 switch(series->type())
                 {
                 case QChartSeries::SeriesTypeLine: {
                     QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
                     for (int i = 0 ; i < xyseries->count() ; i++) {
                         qreal x = xyseries->x(i);
                         qreal y = xyseries->y(i);
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     XYLineChartItem* item = new XYLineChartItem(xyseries,this);
                     m_chartItems << item;
                     // TODO:
                     //m_chartTheme->addObserver(xyseries);
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     qDebug() << "barSeries added";
                     BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                     BarGroup* barGroup = new BarGroup(*barSeries,this);
                     // Add some fugly colors for 5 fist series...
                     barGroup->addColor(QColor(255,0,0,128));
                     barGroup->addColor(QColor(255,255,0,128));
                     barGroup->addColor(QColor(0,255,0,128));
                     barGroup->addColor(QColor(0,0,255,128));
                     barGroup->addColor(QColor(255,128,0,128));
                     m_chartItems << barGroup;
                     childItems().append(barGroup);
                     qreal x = barSeries->countColumns();
                     qreal y = barSeries->max();
                     domain.m_minX = qMin(domain.m_minX,x);
                     domain.m_minY = qMin(domain.m_minY,y);
                     domain.m_maxX = qMax(domain.m_maxX,x);
                     domain.m_maxY = qMax(domain.m_maxY,y);
                     break;
                     }
                 case QChartSeries::SeriesTypeStackedBar: {
                     qDebug() << "barSeries added";
                     StackedBarChartSeries* stackedBarSeries = static_cast<StackedBarChartSeries*>(series);
                     StackedBarGroup* stackedBarGroup = new StackedBarGroup(*stackedBarSeries,this);
                     // Add some fugly colors for 5 fist series...
                     stackedBarGroup->addColor(QColor(255,0,0,128));
                     stackedBarGroup->addColor(QColor(255,255,0,128));
                     stackedBarGroup->addColor(QColor(0,255,0,128));
                     stackedBarGroup->addColor(QColor(0,0,255,128));
                     stackedBarGroup->addColor(QColor(255,128,0,128));
                     m_chartItems << stackedBarGroup;
                     childItems().append(stackedBarGroup);
                     qreal x = stackedBarSeries->countColumns();
                     qreal y = stackedBarSeries->maxColumnSum();
                     domain.m_minX = qMin(domain.m_minX,x);
                     domain.m_minY = qMin(domain.m_minY,y);
                     domain.m_maxX = qMax(domain.m_maxX,x);
                     domain.m_maxY = qMax(domain.m_maxY,y);
                     break;
                     }
                 case QChartSeries::SeriesTypePercentBar: {
                     qDebug() << "barSeries added";
                     PercentBarChartSeries* percentBarSeries = static_cast<PercentBarChartSeries*>(series);
                     PercentBarGroup* percentBarGroup = new PercentBarGroup(*percentBarSeries,this);
                     // Add some fugly colors for 5 fist series...
                     percentBarGroup->addColor(QColor(255,0,0,128));
                     percentBarGroup->addColor(QColor(255,255,0,128));
                     percentBarGroup->addColor(QColor(0,255,0,128));
                     percentBarGroup->addColor(QColor(0,0,255,128));
                     percentBarGroup->addColor(QColor(255,128,0,128));
                     m_chartItems << percentBarGroup;
                     childItems().append(percentBarGroup);
                     qreal x = percentBarSeries->countColumns();
                     domain.m_minX = qMin(domain.m_minX,x);
                     domain.m_minY = 0;
                     domain.m_maxX = qMax(domain.m_maxX,x);
                     domain.m_maxY = 100;
                     break;
                     }
                 case QChartSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     scatterSeries->d->m_theme = m_chartTheme->themeForSeries();
                     scatterSeries->d->setParentItem(this);
                     scatterSeries->d->m_boundingRect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                     m_chartItems << scatterSeries->d;
                     m_chartTheme->addObserver(scatterSeries->d);
                     foreach (qreal x, scatterSeries->d->m_x) {
                         domain.m_minX = qMin(domain.m_minX, x);
                         domain.m_maxX = qMax(domain.m_maxX, x);
                     }
                     foreach (qreal y, scatterSeries->d->m_y) {
                         domain.m_minY = qMin(domain.m_minY, y);
                         domain.m_maxY = qMax(domain.m_maxY, y);
                     }
                     break;
                     }
                 case QChartSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                     pieSeries->d->setParentItem(this);
                     m_chartItems << pieSeries->d;
                     pieSeries->d->m_chartTheme = m_chartTheme;
                     m_chartTheme->addObserver(pieSeries->d);
                     break;
                     }
                 }
                 // Update all the items to match the new visible area of the chart
                 foreach(ChartItem* i, m_chartItems)
                     i->setPlotDomain(m_plotDomainList.at(m_plotDataIndex));
             }
             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 = QXYChartSeries::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::setSize(const QSize& size)
-                m_rect = QRect(QPoint(0,0),size);
-                QRect 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);
-                    if (m_bacgroundOrinetation == HorizonatlGradientOrientation)
-                        m_backgroundGradient.setFinalStop(m_backgroundItem->rect().width(), 0);
-                    else
-                        m_backgroundGradient.setFinalStop(0, m_backgroundItem->rect().height());
-                    m_backgroundItem->setBrush(m_backgroundGradient);
-                // resize and reposition childs
-                foreach (ChartItem *item, m_chartItems) {
-                    item->setPos(rect.topLeft());
-                    item->setSize(rect.size());
-                update();
             void QChart::setBackground(const QColor& startColor, const QColor& endColor, GradientOrientation orientation)
             {
                 if(!m_backgroundItem){
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setZValue(-1);
                 }
                 m_bacgroundOrinetation = orientation;
                 m_backgroundGradient.setColorAt(0.0, startColor);
                 m_backgroundGradient.setColorAt(1.0, endColor);
                 m_backgroundGradient.setStart(0,0);
                 if(orientation == VerticalGradientOrientation){
                     m_backgroundGradient.setFinalStop(0,m_rect.height());
                 }else{
                     m_backgroundGradient.setFinalStop(m_rect.width(),0);
                 }
                 m_backgroundItem->setBrush(m_backgroundGradient);
                 m_backgroundItem->setPen(Qt::NoPen);
                 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_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
                 m_chartTheme->setTheme(theme);
                 setBackground(m_chartTheme->d->m_gradientStartColor,
                               m_chartTheme->d->m_gradientEndColor,
                               m_bacgroundOrinetation);
                 // TODO: Move the controlling of the series presentations into private implementation of the
                 // series instead of QChart controlling themes for each
                 // In other words, the following should be used when creating xy series:
                 // m_chartTheme->addObserver(xyseries)
                 foreach (QChartSeries *series, m_chartSeries) {
                     if (series->type() == QChartSeries::SeriesTypeLine) {
                         QXYChartSeries *xyseries = static_cast<QXYChartSeries *>(series);
                         SeriesTheme seriesTheme = m_chartTheme->themeForSeries();
                         xyseries->setPen(seriesTheme.linePen);
                     }
                 }
                 update();
             }
-            void QChart::zoomInToRect(const QRect& rectangle)
+            void QChart::zoomInToRect(const QRectF& rectangle)
             {
                 if(!rectangle.isValid()) return;
                 qreal margin = this->margin();
-                QRect rect = rectangle.normalized();
+                QRectF rect = rectangle.normalized();
                 rect.translate(-margin, -margin);
                 PlotDomain& oldDomain = m_plotDomainList[m_plotDataIndex];
                 PlotDomain domain = oldDomain.subDomain(rect,m_rect.width() - 2 * margin,m_rect.height() - 2 * margin);
                 m_plotDomainList.resize(m_plotDataIndex + 1);
                 m_plotDomainList<<domain;
                 m_plotDataIndex++;
                 foreach (ChartItem* item, m_chartItems)
                     item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                 update();
             }
             void QChart::zoomIn()
             {
                 if (m_plotDataIndex < m_plotDomainList.count() - 1) {
                     m_plotDataIndex++;
                     foreach (ChartItem* item, m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 } else {
-                    QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
+                    QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     zoomInToRect(rect);
                 }
             }
             void QChart::zoomOut()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex--;
                     foreach (ChartItem* item, m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             void QChart::zoomReset()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex = 0;
                     foreach (ChartItem* item, m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
                 setAxis(m_axisXItem,axis);
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
                 setAxis(m_axisYItem.at(0),axis);
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
                 item->setVisible(axis.isAxisVisible());
             }
+            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);
+                    if (m_bacgroundOrinetation == HorizonatlGradientOrientation)
+                    m_backgroundGradient.setFinalStop(m_backgroundItem->rect().width(), 0);
+                    else
+                    m_backgroundGradient.setFinalStop(0, m_backgroundItem->rect().height());
+                    m_backgroundItem->setBrush(m_backgroundGradient);
+                }
+                // resize and reposition childs
+                foreach (ChartItem *item, m_chartItems) {
+                    item->setPos(rect.topLeft());
+                    item->setSize(rect.size());
+                }
+                update();
+            }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +10 -6

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
-            #include <QGraphicsObject>
+            #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
+            class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class BarGroup;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             // TODO: We don't need to have QChart tied to QGraphicsItem:
             //class QTCOMMERCIALCHART_EXPORT QChart
             //class QTCOMMERCIALCHART_EXPORT QChartGraphicsItem : public QGraphicsItem {
             // public: QChartGraphicsItem(QChart &chart);
             /*!
              * TODO: define the responsibilities
              */
-            class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsObject
+            class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum GradientOrientation {
                     HorizonatlGradientOrientation,
                     VerticalGradientOrientation
                 };
                 enum ChartThemeId {
                     ChartThemeInvalid = -1,
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     //ChartThemeScientific,
                     ChartThemeUnnamed1
                 };
             public:
-                QChart(QGraphicsObject* parent = 0);
+                QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter */*painter*/, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/) {}
                 void addSeries(QChartSeries* series);
                 //TODO: QChartSeries* createSeries(QSeriesData *data, QChartSeries::QChartSeriesType type);
                 // TODO: who owns the series now? maybe owned by chart and returned a reference instead...
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
-                void setSize(const QSize& size);
                 void setMargin(int margin);
                 int margin() const;
                 void setTheme(QChart::ChartThemeId theme);
                 void setTitle(const QString& title,const QFont& font = QFont());
                 void setBackground(const QColor& startColor, const QColor& endColor = Qt::white, GradientOrientation orientation = VerticalGradientOrientation);
-                void zoomInToRect(const QRect& rectangle);
+                void zoomInToRect(const QRectF& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void zoomReset();
                 void setAxisX(const QChartAxis& axis);
                 void setAxisY(const QChartAxis& axis);
                 void setAxisY(const QList<QChartAxis>& axis);
+            protected:
+                void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 void setAxis(AxisItem *item, const QChartAxis& axis);
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QLinearGradient m_backgroundGradient;
                 GradientOrientation m_bacgroundOrinetation;
                 QGraphicsTextItem* m_titleItem;
                 AxisItem* m_axisXItem;
                 QList<AxisItem*> m_axisYItem;
-                QRect m_rect;
+                QRectF m_rect;
                 QList<QChartSeries *> m_chartSeries;
                 QList<ChartItem *> m_chartItems;
                 QVector<PlotDomain> m_plotDomainList;
                 int m_plotDataIndex;
                 int m_marginSize;
                 ChartTheme *m_chartTheme;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.cpp +1 -1

             #include "qchartview.h"
             #include "qchart.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartView::QChartView(QWidget *parent) :
                 QGraphicsView(parent),
                 m_scene(new QGraphicsScene()),
                 m_chart(new QChart())
             {
             	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartView::~QChartView()
             {
             }
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
-                m_chart->setSize(size());
+                m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
             void QChartView::addSeries(QChartSeries* series)
             {
                 m_chart->addSeries(series);
             }
             QChartSeries* QChartView::createSeries(QChartSeries::QChartSeriesType type)
             {
                 return m_chart->createSeries(type);
             }
             void QChartView::zoomInToRect(const QRect& rectangle)
             {
                 m_chart->zoomInToRect(rectangle);
             }
             void QChartView::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             void QChartView::setTitle(const QString& title)
             {
                 m_chart->setTitle(title);
             }
             void QChartView::setBackground(const QColor& startColor, const QColor& endColor, QChart::GradientOrientation orientation)
             {
                 m_chart->setBackground(startColor,endColor,orientation);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartwidget.cpp +1 -1

             #include "qchartwidget.h"
             #include "qchartseries.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartWidget::QChartWidget(QWidget *parent) :
                 QGraphicsView(parent),
                 m_rubberBand(QRubberBand::Rectangle, this),
                 m_originX(0)
             {
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
                 m_scene = new QGraphicsScene();
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart = new QChart();
                 // TODO: currently setting the margins explicitly is required, if you wish to have axis labels visible
                 m_chart->setMargin(25);
                 m_scene->addItem(m_chart);
                 m_rubberBand.setEnabled(true); // TODO: should zoom be enabled by default?
                 show();
             }
             QChartWidget::~QChartWidget()
             {
             }
             void QChartWidget::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
-                m_chart->setSize(size());
+                m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
             QSize QChartWidget::sizeHint() const
             {
                 // TODO: calculate size hint based on contents?
                 return QSize(100, 100);
             }
             void QChartWidget::mousePressEvent(QMouseEvent *event)
             {
                 if(m_rubberBand.isEnabled() && event->button() == Qt::LeftButton) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     if (rect.contains(event->pos())) {
                         m_originX = event->pos().x();
                         m_rubberBand.setGeometry(QRect(m_originX, 0, 0, height()));
                         m_rubberBand.show();
                         event->accept();
                     }
                 }
             }
             void QChartWidget::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand.isVisible())
                     m_rubberBand.setGeometry(QRect(m_originX, 0,
                         event->pos().x() - m_originX, height()).normalized());
             }
             void QChartWidget::mouseReleaseEvent(QMouseEvent *event)
             {
                 if (event->button() == Qt::LeftButton && m_rubberBand.isVisible()) {
                     m_rubberBand.hide();
                     QRect rect = m_rubberBand.geometry();
                     m_chart->zoomInToRect(rect);
                     event->accept();
                 }
                 if(event->button()==Qt::RightButton)
                     m_chart->zoomReset();
             }
             void QChartWidget::addSeries(QChartSeries* series)
             {
                 m_chart->addSeries(series);
             }
             QChartSeries* QChartWidget::createSeries(QChartSeries::QChartSeriesType type)
             {
                 return m_chart->createSeries(type);
             }
             void QChartWidget::setTheme(QChart::ChartThemeId theme)
             {
                 m_chart->setTheme(theme);
             }
             void QChartWidget::setZoomEnabled(bool enabled)
             {
                 m_rubberBand.setEnabled(enabled);
             }
             #include "moc_qchartwidget.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qpieseries.cpp +1 -1

             #include "qpieseries_p.h"
             #include "qpieseries.h"
             #include <QGraphicsObject>
             #include "pieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QPieSeriesPrivate::QPieSeriesPrivate(QGraphicsItem *parent) :
                 ChartItem(parent),
                 m_sizeFactor(1.0),
                 m_position(QPieSeries::PiePositionMaximized),
                 m_chartTheme(0)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
                 while (m_slices.count())
                     delete m_slices.takeLast();
             }
             bool QPieSeriesPrivate::setData(QList<qreal> data)
             {
                 m_data = data;
                 if (parentItem()) {
                     // Create slices
                     qreal fullPie = 360;
                     qreal total = 0;
                     foreach (qreal value, m_data)
                         total += value;
                     m_chartSize = parentItem()->boundingRect();
                     qreal angle = 0;
                     // TODO: no need to create new slices in case size changed; we should re-use the existing ones
                     foreach (qreal value, m_data) {
                         qreal span = value / total * fullPie;
                         PieSlice *slice = new PieSlice(QColor(), angle, span, parentItem()->boundingRect());
                         slice->setParentItem(parentItem());
                         m_slices.append(slice);
                         angle += span;
                     }
                     themeChanged(m_chartTheme);
                     resizeSlices(m_chartSize);
                 }
                 return true;
             }
-            void QPieSeriesPrivate::setSize(const QSize &size)
+            void QPieSeriesPrivate::setSize(const QSizeF &size)
             {
                 // TODO: allow user setting the size?
                 // TODO: allow user defining the margins?
                 m_chartSize = QRect(0, 0, size.width(), size.height());
                 resizeSlices(m_chartSize);
             }
             void QPieSeriesPrivate::setPlotDomain(const PlotDomain& plotDomain)
             {
                 // TODO
             }
             void QPieSeriesPrivate::themeChanged(ChartTheme *theme)
             {
                 if (theme) {
                     m_chartTheme = theme;
                     for (int i(0); i < m_slices.count(); i++)
                         m_slices.at(i)->m_theme = theme->themeForSeries();
                 }
             }
             void QPieSeriesPrivate::resizeSlices(QRectF rect)
             {
                 QRectF tempRect = rect;
                 if (tempRect.width() < tempRect.height()) {
                     tempRect.setWidth(tempRect.width() * m_sizeFactor);
                     tempRect.setHeight(tempRect.width());
                     tempRect.moveCenter(rect.center());
                 } else {
                     tempRect.setHeight(tempRect.height() * m_sizeFactor);
                     tempRect.setWidth(tempRect.height());
                     tempRect.moveCenter(rect.center());
                 }
                 switch (m_position) {
                     case QPieSeries::PiePositionTopLeft: {
                         tempRect.setHeight(tempRect.height() / 2);
                         tempRect.setWidth(tempRect.height());
                         tempRect.moveCenter(QPointF(rect.center().x() / 2, rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionTopRight: {
                         tempRect.setHeight(tempRect.height() / 2);
                         tempRect.setWidth(tempRect.height());
                         tempRect.moveCenter(QPointF((rect.center().x() / 2) * 3, rect.center().y() / 2));
                         break;
                     }
                     case QPieSeries::PiePositionBottomLeft: {
                         tempRect.setHeight(tempRect.height() / 2);
                         tempRect.setWidth(tempRect.height());
                         tempRect.moveCenter(QPointF(rect.center().x() / 2, (rect.center().y() / 2) * 3));
                         break;
                     }
                     case QPieSeries::PiePositionBottomRight: {
                         tempRect.setHeight(tempRect.height() / 2);
                         tempRect.setWidth(tempRect.height());
                         tempRect.moveCenter(QPointF((rect.center().x() / 2) * 3, (rect.center().y() / 2) * 3));
                         break;
                     }
                     default:
                         break;
                 }
                 foreach (PieSlice *slice, m_slices)
                     slice->m_rect = tempRect;
             }
             QPieSeries::QPieSeries(QGraphicsObject *parent) :
                 QChartSeries(parent),
                 d(new QPieSeriesPrivate(parent))
             {
             }
             QPieSeries::~QPieSeries()
             {
                 delete d;
             }
             bool QPieSeries::setData(QList<qreal> data)
             {
                 return d->setData(data);
             }
             void QPieSeries::setSliceColor(int index, QColor color)
             {
                 if (index >= 0 && index < d->m_slices.count())
                     d->m_slices.at(index)->m_color = color;
             }
             QColor QPieSeries::sliceColor(int index)
             {
                 if (index >= 0 && index < d->m_slices.count())
                     return d->m_slices.at(index)->m_color;
                 else
                     return QColor();
             }
             int QPieSeries::sliceCount()
             {
                 return d->m_slices.count();
             }
             void QPieSeries::setSizeFactor(qreal factor)
             {
                 if (factor > 0.0)
                     d->m_sizeFactor = factor;
                 d->resizeSlices(d->m_chartSize);
                 // Initiate update via the parent graphics item
                 // TODO: potential issue: what if this function is called from the parent context?
                 if (d->parentItem())
                     d->parentItem()->update();
             }
             qreal QPieSeries::sizeFactor()
             {
                 return d->m_sizeFactor;
             }
             void QPieSeries::setPosition(PiePosition position)
             {
                 d->m_position = position;
                 d->resizeSlices(d->m_chartSize);
                 // Initiate update via the parent graphics item
                 // TODO: potential issue: what if this function is called from the parent context?
                 QGraphicsItem *parentItem = qobject_cast<QGraphicsItem *>(parent());
                 Q_ASSERT(parentItem);
                 parentItem->update();
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qpieseries_p.h +1 -1

             #ifndef PIESERIESPRIVATE_H
             #define PIESERIESPRIVATE_H
             #include "chartitem_p.h"
             #include "charttheme_p.h"
             #include "qpieseries.h"
             #include <QRectF>
             #include <QColor>
             class QGraphicsItem;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class PieSlice;
             class QPieSeriesPrivate : public ChartItem, public ChartThemeObserver
             {
             public:
                 // TODO: use a generic data class instead of x and y
                 QPieSeriesPrivate(QGraphicsItem *parent);
                 ~QPieSeriesPrivate();
             public: // from ChartItem
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
                 // This is a dummy QGraphicsItem; dummy implementation
                 QRectF boundingRect() const { return parentItem()->boundingRect(); }
                 // This is a dummy QGraphicsItem; no implementation
                 void paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) {}
             public: // from ChartThemeObserver
                 void themeChanged(ChartTheme *theme);
             public:
                 bool setData(QList<qreal> data);
                 void resizeSlices(QRectF rect);
                 QList<qreal> m_data;
                 QList<PieSlice*> m_slices;
                 QRectF m_chartSize;
                 qreal m_sizeFactor;
                 QPieSeries::PiePosition m_position;
                 ChartTheme *m_chartTheme;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESERIESPRIVATE_H

src/qscatterseries.cpp +1 -1

             #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_markerColor(QColor()),
                 m_visibleChartArea(),
                 m_boundingRect()
             {
                 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 QSize &size)
+            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)
             {
                 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 +1 -1

             #ifndef QSCATTERSERIESPRIVATE_H
             #define QSCATTERSERIESPRIVATE_H
             #include "qchartseries.h"
             #include "charttheme_p.h"
             #include "chartitem_p.h"
             #include "plotdomain_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              * The PIMPL class of QScatterSeries.
              */
             class QScatterSeriesPrivate : public ChartItem, public ChartThemeObserver
             {
             public:
                 QScatterSeriesPrivate(QGraphicsItem *parent);
             public: // from ChartObjectInterface
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& 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;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QSCATTERSERIESPRIVATE_H

src/xylinechart/xylinechartitem.cpp +1 -1

             #include "xylinechartitem_p.h"
             #include "axisitem_p.h"
             #include "qxychartseries.h"
             #include <QPainter>
             #include <QStyleOptionGraphicsItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYLineChartItem::XYLineChartItem(QXYChartSeries* series,QGraphicsItem *parent) :
                 ChartItem(parent),
                 m_series(series),
                 m_pathItem(new QGraphicsPathItem(this))
             {
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
             }
-            void XYLineChartItem::setSize(const QSize &size)
+            void XYLineChartItem::setSize(const QSizeF &size)
             {
                 m_rect = QRect(0, 0, size.width(), size.height());
                 prepareGeometryChange();
                 updateGeometry();
             }
             void XYLineChartItem::setPlotDomain(const PlotDomain& data)
             {
                 m_plotDomain=data;
                 prepareGeometryChange();
                 updateGeometry();
             }
             QRectF XYLineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void XYLineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 m_pathItem->setPen(m_series->pen());
             }
             /*
             QPainterPath XYLineChartItem::shape() const
             {
                 return m_pathItem->shape();
             }
             */
             void XYLineChartItem::updateGeometry()
             {
                if (!m_rect.isValid()) return;
                const qreal deltaX = m_rect.width()/m_plotDomain.spanX();
                const qreal deltaY = m_rect.height()/m_plotDomain.spanY();
                QPainterPath path;
                for (int j = 0; j < m_series->count(); ++j) {
                    qreal dx = m_series->x(j) - m_plotDomain.m_minX;
                    qreal dy = m_series->y(j) - m_plotDomain.m_minY;
                    qreal x = (dx * deltaX) + m_rect.left();
                    qreal y = - (dy * deltaY) + m_rect.bottom();
                    if(j==0) path.moveTo(x,y);
                    else path.lineTo(x,y);
                }
                m_pathItem->setPath(path);
                m_pathItem->setPen(m_series->pen());
                m_pathItem->setBrush(Qt::NoBrush);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/xylinechartitem_p.h +1 -1

             #ifndef XYLINECHARTITEM_H
             #define XYLINECHARTITEM_H
             #include "qchartglobal.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYChartSeries;
             class XYLineChartItem : public ChartItem
             {
             public:
                 XYLineChartItem(QXYChartSeries* m_series,QGraphicsItem *parent = 0);
                 ~ XYLineChartItem(){};
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                // virtual QPainterPath shape() const;
             public: // from ChartItem
-                void setSize(const QSize &size);
+                void setSize(const QSizeF &size);
                 void setPlotDomain(const PlotDomain& data);
             private:
                 void updateGeometry();
             private:
                 QRect m_rect;
                 QPolygonF m_polyline;
                 QXYChartSeries* m_series;
                 PlotDomain m_plotDomain;
                 QGraphicsPathItem *m_pathItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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