HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1033:23725b97de5c

Fixes normalize signal socekt issue

Michal Klocek -

r1033:23725b97de5c

parent child

Context file:

r1033:23725b97de5c

Collapse all files

src/legend/qlegend.cpp +2 -2

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "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
             */
             /*!
              \enum QLegend::Alignment
              This enum describes the possible position for legend inside chart.
              \value AlignmentTop
              \value AlignmentBottom
              \value AlignmentLeft
              \value AlignmentRight
              */
             /*!
              \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,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 setEnabled(false); // By default legend is disabled
                 setVisible(false);
-                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(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(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(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->drawRect(boundingRect());
             }
             /*!
              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;
             }
             /*!
              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;
             }
             /*!
              Sets the \a alignment for legend. Legend tries to paint itself on the defined position in chart.
              \sa QLegend::Alignment
              */
             void QLegend::setAlignment(QLegend::Alignments alignment)
             {
                 if(d_ptr->m_alignment!=alignment && d_ptr->m_attachedToChart) {
                     d_ptr->m_alignment = alignment;
                     d_ptr->updateLayout();
                 }
             }
             /*!
              Returns the preferred layout for legend
              */
             QLegend::Alignments 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->m_attachedToChart = true;
             }
             /*!
              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();
                 }
             }
             /*!
              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,QLegend *q):
             q_ptr(q),
             m_presenter(presenter),
             m_markers(new QGraphicsItemGroup(q)),
             m_alignment(QLegend::AlignmentTop),
             m_offsetX(0),
             m_offsetY(0),
             m_minWidth(0),
             m_minHeight(0),
             m_width(0),
             m_height(0),
             m_attachedToChart(true),
             m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         if(m_width<=m_rect.width()) return;
                         if (x != m_offsetX) {
                             m_offsetX = qBound(qreal(0), x, m_width - m_rect.width());
                             m_markers->setPos(-m_offsetX,m_rect.top());
                         }
                         break;
                     }
                     case QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         if(m_height<=m_rect.height()) return;
                         if (y != m_offsetY) {
                             m_offsetY = qBound(qreal(0), y, m_height - m_rect.height());
                             m_markers->setPos(m_rect.left(),-m_offsetY);
                         }
                         break;
                     }
                 }
             }
             void QLegendPrivate::updateLayout()
             {
                 m_offsetX=0;
                 QList<QGraphicsItem *> items = m_markers->childItems();
                 if(items.isEmpty()) return;
                 m_minWidth=0;
                 m_minHeight=0;
                 switch(m_alignment) {
                     case QLegend::AlignmentTop:
                     case QLegend::AlignmentBottom: {
                         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 QLegend::AlignmentLeft:
                     case QLegend::AlignmentRight: {
                         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_presenter->updateLayout();
             }
             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);
                     QPieSeriesPrivate *d = QPieSeriesPrivate::seriesData(*pieSeries);
                     QObject::connect(d, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(d, 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);
                     QPieSeriesPrivate *d = QPieSeriesPrivate::seriesData(*pieSeries);
                     QObject::disconnect(d, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(d, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 updateLayout();
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeriesPrivate* d = qobject_cast<QPieSeriesPrivate *> (sender());
                 Q_ASSERT(d->q_func());
                 handleSeriesRemoved(d->q_func());
                 handleSeriesAdded(d->q_func(), 0);
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +2 -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$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qaxis.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter=0;
             }
             /*!
              Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              */
             void QChart::addSeries(QAbstractSeries *series, QAxis *axisY)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series, axisY);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setBrush(brush);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QBrush();
                 return (d_ptr->m_presenter->m_backgroundItem)->brush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setPen(pen);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QPen();
                 return d_ptr->m_presenter->m_backgroundItem->pen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setText(title);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 //TODO: refactor me
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->text();
                 else
                     return QString();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setFont(font);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->font();
                 else
                     return QFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setBrush(brush);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_titleItem) return QBrush();
                 return d_ptr->m_presenter->m_titleItem->brush();
             }
             /*!
              Sets the \a theme used by the chart for rendering the graphical representation of the data
              \sa theme()
              */
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             /*!
              Returns the theme enum used by the chart.
              \sa ChartTheme, setTheme()
              */
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->m_presenter->zoomIn();
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut();
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the \a series
              If no \a series is provided then default Y axis of the chart is returned.
              */
             QAxis* QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QRectF QChart::margins() const
             {
                 return d_ptr->m_presenter->margins();
             }
             /*!
              Resizes and updates the chart area using the \a event data
              */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 d_ptr->m_presenter->setGeometry(d_ptr->m_rect);
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             /*!
              Returns animation options for the chart
              */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart to the left by the distance between two x axis ticks
              */
             void QChart::scrollLeft()
             {
                 d_ptr->m_presenter->scroll(-d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart to the right by the distance between two x axis ticks
              */
             void QChart::scrollRight()
             {
                 d_ptr->m_presenter->scroll(d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart up by the distance between two y axis ticks
              */
             void QChart::scrollUp()
             {
                 d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Scrolls the visible area of the chart down by the distance between two y axis ticks
              */
             void QChart::scrollDown()
             {
                 d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Sets the chart background visibility state to \a visible
              */
             void QChart::setBackgroundVisible(bool visible)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setVisible(visible);
             }
             /*!
                 Returns the chart's background visibility state
              */
             bool QChart::isBackgroundVisible() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem)
                     return false;
                 return d_ptr->m_presenter->m_backgroundItem->isVisible();
             }
             /*!
                 Sets the background drop shadow effect state to \a enabled.
             */
             void QChart::setBackgroundDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setDropShadowEnabled(enabled);
             }
             /*!
                 Returns true if the drop shadow effect is enabled for the chart background.
             */
             bool QChart::isBackgroundDropShadowEnabled() const
             {
                 if (!d_ptr->m_presenter->m_backgroundItem)
                     return false;
                 return d_ptr->m_presenter->m_backgroundItem->isDropShadowEnabled();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
+                QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
-                QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries *, Domain *)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries *, Domain *)));
+                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries*)));
-                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries *)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries *)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QAxis*)),m_presenter,SLOT(handleAxisRemoved(QAxis*)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages