HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1458:1e5e1b9c40c3

moved legend offset to private side

sauimone -

r1458:1e5e1b9c40c3

parent child

Context file:

r1458:1e5e1b9c40c3

Collapse all files

src/legend/legendscroller_p.h +3 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef LEGENDSCROLLER_P_H
             #define LEGENDSCROLLER_P_H
             #include "qlegend.h"
+            #include "qlegend_p.h"
             #include "scroller_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class LegendScroller: public QLegend, public Scroller
             {
             public:
                 LegendScroller(QChart *chart):QLegend(chart)
                 {
                 }
                 void setOffset(const QPointF& point)
                 {
-                    QLegend::setOffset(point);
+                    d_ptr->setOffset(point.x(), point.y());
                 }
                 QPointF offset() const
                 {
-                    return QLegend::offset();
+                    return d_ptr->offset();
                 }
                 void mousePressEvent(QGraphicsSceneMouseEvent* event){
                     Scroller::mousePressEvent(event);
-                    //QLegend::mousePressEvent(event);
                 }
                 void mouseMoveEvent(QGraphicsSceneMouseEvent* event){
                     Scroller::mouseMoveEvent(event);
-                    //QLegend::mouseMoveEvent(event);
                 }
                 void mouseReleaseEvent(QGraphicsSceneMouseEvent* event){
                     Scroller::mouseReleaseEvent(event);
-                    //QLegend::mouseReleaseEvent(event);
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/legend/qlegend.cpp +5 -16

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief part of QtCommercial chart API.
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is referenced via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background color.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \fn void QLegend::alignmentChanged(Qt::Alignment)
                 Emitted when the \a alignment of the legend changes.
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
              \fn qreal QLegend::minWidth() const
              Returns minimum width of the legend
              */
             /*!
              \fn qreal QLegend::minHeight() const
              Returns minimum height of the legend
              */
             /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              Paints the legend to given \a painter. Paremeters \a option and \a widget arent used.
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
             }
             /*!
              Bounding rect of legend.
              */
             QRectF QLegend::boundingRect() const
             {
                 return d_ptr->m_rect;
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setBrush(b);
                     emit colorChanged(color);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                     emit borderColorChanged(color);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
                     alignmentChanged(alignment);
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->attachToChart();
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
-                Sets the legend's scrolling offset to value defined by \a point.
-            */
-            void QLegend::setOffset(const QPointF& point)
-                d_ptr->setOffset(point.x(),point.y());
-            /*!
-                Returns the legend's scrolling offset.
-            */
-            QPointF QLegend::offset() const
-                return QPointF(d_ptr->m_offsetX,d_ptr->m_offsetY);
-            /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 const QRectF& rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 if(d_ptr->m_rect != rect) {
                     d_ptr->m_rect = rect;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 setEnabled(false);
                 d_ptr->updateLayout();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 setEnabled(true);
                 d_ptr->updateLayout();
             }
             qreal QLegend::minWidth() const
             {
                 return d_ptr->m_minWidth;
             }
             qreal QLegend::minHeight() const
             {
                 return d_ptr->m_minHeight;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
                 m_chart(chart),
                 m_markers(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
                 m_offsetX(0),
                 m_offsetY(0),
                 m_minWidth(0),
                 m_minHeight(0),
                 m_width(0),
                 m_height(0),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch(m_alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         scrollHorizontal = true;
                         break;
                     }
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         scrollHorizontal = false;
                         break;
                     }
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_attachedToChart) {
                     scrollHorizontal = !scrollHorizontal;
                 }
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if(m_width<=m_rect.width()) return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_markers->setPos(-m_offsetX,m_rect.top());
                     }
                 } else {
                     if(m_height<=m_rect.height()) return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_markers->setPos(m_rect.left(),-m_offsetY);
                     }
                 }
             }
+            QPointF QLegendPrivate::offset() const
+            {
+                return QPointF(m_offsetX,m_offsetY);
+            }
             void QLegendPrivate::updateLayout()
             {
                 if (!m_attachedToChart) {
                     updateDetachedLayout();
                     return;
                 }
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point.x(),m_rect.height()/2 -item->boundingRect().height()/2);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             m_minWidth=qMax(m_minWidth,w);
                             m_minHeight=qMax(m_minHeight,rect.height());
                             m_width+=w;
                             point.setX(point.x() + w);
                         }
                         if(m_width<m_rect.width()) {
                             m_markers->setPos(m_rect.width()/2-m_width/2,m_rect.top());
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_height=m_minHeight;
                     }
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         QPointF point = m_rect.topLeft();
                         m_height = 0;
                         foreach (QGraphicsItem *item, items) {
                             item->setPos(point);
                             const QRectF& rect = item->boundingRect();
                             qreal h = rect.height();
                             m_minWidth=qMax(m_minWidth,rect.width());
                             m_minHeight=qMax(m_minHeight,h);
                             m_height+=h;
                             point.setY(point.y() + h);
                         }
                         if(m_height<m_rect.height()) {
                             m_markers->setPos(m_rect.left(),m_rect.height()/2-m_height/2);
                         }
                         else {
                             m_markers->setPos(m_rect.topLeft());
                         }
                         m_width=m_minWidth;
                     }
                     break;
                 }
                 m_minOffsetX = 0;
                 m_minOffsetY = 0;
                 m_maxOffsetX = m_width - m_rect.width();
                 m_maxOffsetY = m_height - m_rect.height();
                 m_presenter->updateLayout();
             }
             void QLegendPrivate::updateDetachedLayout()
             {
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 m_offsetX=0;
                 m_offsetY=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth = 0;
                 m_minHeight = 0;
                 switch (m_alignment) {
                     case Qt::AlignTop: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             qreal h = rect.height();
                             m_minWidth = qMax(m_minWidth,w);
                             m_minHeight = qMax(m_minHeight,rect.height());
                             m_height = qMax(m_height,h);
                             item->setPos(point.x(),point.y());
                             point.setX(point.x() + w);
                             if (point.x() + w > m_rect.topLeft().x() + m_rect.width()) {
                                 // Next item would go off rect.
                                 point.setX(m_rect.topLeft().x());
                                 point.setY(point.y() + h);
                                 if (i+1 < items.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                         m_markers->setPos(m_rect.topLeft());
                         m_width = m_minWidth;
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     case Qt::AlignBottom: {
                         QPointF point = m_rect.bottomLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             qreal h = rect.height();
                             m_minWidth = qMax(m_minWidth,w);
                             m_minHeight = qMax(m_minHeight,rect.height());
                             m_height = qMax(m_height,h);
                             item->setPos(point.x(),point.y() - h);
                             point.setX(point.x() + w);
                             if (point.x() + w > m_rect.bottomLeft().x() + m_rect.width()) {
                                 // Next item would go off rect.
                                 point.setX(m_rect.bottomLeft().x());
                                 point.setY(point.y() - h);
                                 if (i+1 < items.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                         m_markers->setPos(m_rect.topLeft());
                         m_width = m_minWidth;
                         m_minOffsetX = 0;
                         m_minOffsetY = qMin(m_rect.topLeft().y(), m_rect.topLeft().y() - m_height + m_rect.height());
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = 0;
                     }
                     break;
                     case Qt::AlignLeft: {
                         QPointF point = m_rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             qreal h = rect.height();
                             m_minWidth = qMax(m_minWidth,rect.width());
                             m_minHeight = qMax(m_minHeight,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x(),point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
                                 // Next item would go off rect.
                                 point.setX(point.x() + maxWidth);
                                 point.setY(m_rect.topLeft().y());
                                 if (i+1 < items.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_markers->setPos(m_rect.topLeft());
                         m_height = m_minHeight;
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - m_rect.width();
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     case Qt::AlignRight: {
                         QPointF point = m_rect.topRight();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             const QRectF& rect = item->boundingRect();
                             qreal w = rect.width();
                             qreal h = rect.height();
                             m_minWidth = qMax(m_minWidth,rect.width());
                             m_minHeight = qMax(m_minHeight,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x() - w,point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > m_rect.topLeft().y() + m_rect.height()) {
                                 // Next item would go off rect.
                                 point.setX(point.x() - maxWidth);
                                 point.setY(m_rect.topLeft().y());
                                 if (i+1 < items.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_markers->setPos(m_rect.topLeft());
                         m_height = m_minHeight;
                         m_minOffsetX = qMin(m_rect.topLeft().x(), m_rect.topLeft().x() - m_width + m_rect.width());
                         m_minOffsetY = 0;
                         m_maxOffsetX = 0;
                         m_maxOffsetY = m_height - m_rect.height();
                     }
                     break;
                     default:
                     break;
                 }
             }
             void QLegendPrivate::attachToChart()
             {
                 m_attachedToChart = true;
                 q_ptr->setParent(m_chart);
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers)
                     m_markers->addToGroup(marker);
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 foreach (QGraphicsItem *markers, items) {
                     LegendMarker *marker = static_cast<LegendMarker*>(markers);
                     if (marker->series() == series) {
                         delete marker;
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.h 0 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QLEGEND_H
             #define QLEGEND_H
             #include <QChartGlobal>
             #include <QGraphicsWidget>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain;
             class LegendMarker;
             class QPieSlice;
             class QXYSeries;
             class QBarSet;
             class QBarSeries;
             class QPieSeries;
             class QAreaSeries;
             class LegendScrollButton;
             class QChart;
             class QLegendPrivate;
             class QTCOMMERCIALCHART_EXPORT QLegend : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_PROPERTY(Qt::Alignment alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible NOTIFY backgroundVisibleChanged)
                 Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
                 Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
             private:
                 explicit QLegend(QChart *chart);
             public:
                 ~QLegend();
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
                 void setBrush(const QBrush &brush);
                 QBrush brush() const;
                 void setColor(QColor color);
                 QColor color();
                 void setPen(const QPen &pen);
                 QPen pen() const;
                 void setBorderColor(QColor color);
                 QColor borderColor();
                 void setAlignment(Qt::Alignment alignment);
                 Qt::Alignment alignment() const;
                 void detachFromChart();
                 void attachToChart();
                 bool isAttachedToChart();
                 qreal minWidth() const;
                 qreal minHeight() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
-                void setOffset(const QPointF& point);
-                QPointF offset() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
                 void hideEvent(QHideEvent *event);
                 void showEvent(QShowEvent *event);
             Q_SIGNALS:
                 void alignmentChanged(Qt::Alignment alignment);
                 void backgroundVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void borderColorChanged(QColor color);
             private:
                 QScopedPointer<QLegendPrivate> d_ptr;
                 Q_DISABLE_COPY(QLegend)
                 friend class LegendScroller;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QLEGEND_H

src/legend/qlegend_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QLEGEND_P_H
             #define QLEGEND_P_H
             #include "qlegend.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class ChartPresenter;
             class QAbstractSeries;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(qreal x, qreal y);
+                QPointF offset() const;
                 void updateLayout();
                 void updateDetachedLayout();
                 void attachToChart();
                 int roundness(qreal size);
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleSeriesUpdated(QAbstractSeries *series);
                 void handleUpdatePieSeries(); //TODO remove this function
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 QChart* m_chart;
                 QGraphicsItemGroup* m_markers;
                 Qt::Alignment m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QRectF m_rect;
                 qreal m_offsetX;
                 qreal m_offsetY;
                 qreal m_minOffsetX;
                 qreal m_minOffsetY;
                 qreal m_maxOffsetX;
                 qreal m_maxOffsetY;
                 qreal m_minWidth;
                 qreal m_minHeight;
                 qreal m_width;
                 qreal m_height;
                 qreal m_diameter;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
             friend class QLegend;
             };
             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