HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2265:b004c42eda51

Fixed several documentation issues

Tero Ahola -

r2265:b004c42eda51

parent child

Context file:

r2265:b004c42eda51

Collapse all files

src/axis/qabstractaxis.cpp +36 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$
             **
             ****************************************************************************/
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 There is only one x Axis visible at the time, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass AbstractAxis QAbstractAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis visible at the time, however there can be multiple y axes on a ChartView.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the series object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \qmlproperty bool AbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
+              \property QAbstractAxis::titleVisible
+              The visibility of the axis title. By default the value is true.
+            */
+            /*!
+              \qmlproperty bool AbstractAxis::titleVisible
+              The visibility of the axis title. By default the value is true.
+            */
+            /*!
+              \property QAbstractAxis::titleFont
+              The font of the title of the axis.
+            */
+            /*!
+              \qmlproperty Font AbstractAxis::title
+              The font of the title of the axis.
+            */
+            /*!
+              \property QAbstractAxis::title
+              The title of the axis. Empty by default.
+            */
+            /*!
+              \qmlproperty string AbstractAxis::title
+              The title of the axis. Empty string by default.
+            */
+            /*!
+              \property QAbstractAxis::alignment
+              The alignment of the axis. Either Qt::AlignLeft or Qt::AlignBottom.
+            */
+            /*!
+              \qmlproperty alignment AbstractAxis::alignment
+              The alignment of the axis. Either Qt.AlignLeft or Qt.AlignBottom.
+            */
+            /*!
               \fn void QAbstractAxis::visibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::lineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onColorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
              \internal
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent)
                 : QObject(parent),
                   d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
                 if (d_ptr->m_dataset)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 return d_ptr->m_axisPen;
             }
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     d_ptr->emitUpdated();
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     d_ptr->emitUpdated();
                     emit gridVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     d_ptr->emitUpdated();
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAbstractAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     d_ptr->emitUpdated();
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     d_ptr->emitUpdated();
                 }
             }
             bool QAbstractAxis::titleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a pen used to draw title.
             */
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns the pen used to title.
             */
             QPen QAbstractAxis::titlePen() const
             {
                 return d_ptr->m_titlePen;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush  QAbstractAxis::titleBrush() const
             {
                 return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitle(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     d_ptr->emitUpdated();
                 }
             }
             QString QAbstractAxis::title() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     d_ptr->emitUpdated();
                     emit shadesVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     d_ptr->emitUpdated();
                 }
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     d_ptr->emitUpdated();
                     emit shadesColorChanged(brush.color());
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 b.setColor(color);
                 setShadesBrush(b);
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 p.setColor(color);
                 setShadesPen(p);
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     d_ptr->emitUpdated();
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             Qt::Orientation QAbstractAxis::orientation() const
             {
                 return d_ptr->m_orientation;
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             void QAbstractAxis::setAlignment(Qt::Alignment alignment)
             {
                 d_ptr->m_alignment = alignment;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_orientation(Qt::Orientation(0)),
                   m_alignment(0),
                   m_dataset(0),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_gridLineVisible(true),
                   m_labelsVisible(true),
                   m_labelsAngle(0),
                   m_shadesVisible(false),
                   m_shadesBrush(Qt::SolidPattern),
                   m_shadesOpacity(1.0),
                   m_dirty(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::emitUpdated()
             {
                 if (!m_dirty) {
                     m_dirty = true;
                     emit updated();
                 }
             }
             void QAbstractAxisPrivate::setDirty(bool dirty)
             {
                 m_dirty = dirty;
             }
             void QAbstractAxisPrivate::setOrientation(Qt::Orientation orientation)
             {
                 m_orientation = orientation;
                 if (m_orientation == Qt::Horizontal && !m_alignment)
                     m_alignment = Qt::AlignBottom;
                 else if (m_orientation == Qt::Vertical && !m_alignment)
                     m_alignment = Qt::AlignLeft;
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qarealegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qarealegendmarker.h"
             #include "qarealegendmarker_p.h"
             #include "qareaseries_p.h"
             #include <QAreaSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAreaLegendMarker
                 \brief QAreaLegendMarker object
                 \mainclass
                 QAreaLegendMarker is related to QAreaSeries. One QAreaSeries results in one marker.
                 \sa QLegend QAreaSeries
             */
             /*!
               \fn virtual LegendMarkerType QAreaLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypeArea
             */
             /*!
-              Constructor
+              \internal
             */
             QAreaLegendMarker::QAreaLegendMarker(QAreaSeries *series, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QAreaLegendMarkerPrivate(this,series,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Destructor
             */
             QAreaLegendMarker::~QAreaLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QAreaLegendMarker::QAreaLegendMarker(QAreaLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns related series of marker
             */
             QAreaSeries* QAreaLegendMarker::series()
             {
                 Q_D(QAreaLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAreaLegendMarkerPrivate::QAreaLegendMarkerPrivate(QAreaLegendMarker *q, QAreaSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(updated()));
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
             }
             QAreaLegendMarkerPrivate::~QAreaLegendMarkerPrivate()
             {
             }
             QAreaSeries* QAreaLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QAreaLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QAreaLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 if (m_item->brush() != m_series->brush()) {
                     m_item->setBrush(m_series->brush());
                     brushChanged = true;
                 }
                 if (m_item->label() != m_series->name()) {
                     m_item->setLabel(m_series->name());
                     labelChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
             }
             #include "moc_qarealegendmarker.cpp"
             #include "moc_qarealegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qbarlegendmarker.cpp +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$
             **
             ****************************************************************************/
             #include "qbarlegendmarker.h"
             #include "qbarlegendmarker_p.h"
             #include <QAbstractBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarLegendMarker
                 \brief QBarLegendMarker object
                 \mainclass
                 QBarLegendMarker is related to QAbstractBarSeries derived classes. With bar series, each marker is related to one QBarSet.
                 \sa QLegend QAbstractBarSeries QBarSet
             */
             /*!
               \fn virtual LegendMarkerType QBarLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypeBar
             */
             /*!
+              \internal
               Constructor
             */
             QBarLegendMarker::QBarLegendMarker(QAbstractBarSeries *series, QBarSet *barset, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QBarLegendMarkerPrivate(this,series,barset,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Desturctor
             */
             QBarLegendMarker::~QBarLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QBarLegendMarker::QBarLegendMarker(QBarLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns the related series of marker
             */
             QAbstractBarSeries *QBarLegendMarker::series()
             {
                 Q_D(QBarLegendMarker);
                 return d->m_series;
             }
             /*!
               Returns the related barset of marker
             */
             QBarSet* QBarLegendMarker::barset()
             {
                 Q_D(QBarLegendMarker);
                 return d->m_barset;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarLegendMarkerPrivate::QBarLegendMarkerPrivate(QBarLegendMarker *q, QAbstractBarSeries *series, QBarSet *barset, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series),
                 m_barset(barset)
             {
                 QObject::connect(m_barset, SIGNAL(penChanged()), this, SLOT(updated()));
                 QObject::connect(m_barset, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(m_barset, SIGNAL(brushChanged()), this, SLOT(updated()));
             }
             QBarLegendMarkerPrivate::~QBarLegendMarkerPrivate()
             {
             }
             QAbstractBarSeries* QBarLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QBarLegendMarkerPrivate::relatedObject()
             {
                 return m_barset;
             }
             void QBarLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 bool penChanged = false;
                 if (m_item->pen() != m_barset->pen()) {
                     m_item->setPen(m_barset->pen());
                     penChanged = true;
                 }
                 if (m_item->brush() != m_barset->brush()) {
                     m_item->setBrush(m_barset->brush());
                     brushChanged = true;
                 }
                 if (m_item->label() != m_barset->label()) {
                     m_item->setLabel(m_barset->label());
                     labelChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
                 if (penChanged)
                     emit q_ptr->penChanged();
             }
             #include "moc_qbarlegendmarker.cpp"
             #include "moc_qbarlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend.cpp 0 -4

             /****************************************************************************
              **
              ** 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 "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsItemGroup>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief Legend object
                 \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 used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
                 Please note that there is no QML API available for modifying legend markers, unlike in the Qt API of Charts.
                 The use case of modifying markers can be implemented for example by creating your own custom legend. For an example
                 on how to do this, see \l {demos/qmlcustomlegend}{Qml Custom Demo} application.
             */
             /*!
                 \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 (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) 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.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty Font Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \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 void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
                 \fn void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
-            /*!
-             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*)));
                 QObject::connect(chart->d_ptr->m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), d_ptr.data(), SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 setLayout(d_ptr->m_layout);
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             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()));
             }
             /*!
              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();
                     emit colorChanged(brush.color());
                 }
             }
             /*!
              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.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             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();
                     emit borderColorChanged(pen.color());
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font)
                     d_ptr->m_font = font;
                 foreach (QLegendMarker *marker, d_ptr->markers()) {
                     marker->setFont(d_ptr->m_font);
                 }
                 layout()->invalidate();
                 emit fontChanged(font);
             }
             QFont QLegend::font() const
             {
                 return d_ptr->m_font;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     foreach (QLegendMarker *marker, d_ptr->markers()) {
                         marker->setLabelBrush(d_ptr->m_labelBrush);
                         // Note: The pen of the marker rectangle could be exposed in the public QLegend API
                         // instead of mapping it from label brush color
                         marker->setPen(brush.color());
                     }
                     emit labelColorChanged(brush.color());
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             QBrush QLegend::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegend::setLabelColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelBrush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             QColor QLegend::labelColor() const
             {
                 return d_ptr->m_labelBrush.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if (d_ptr->m_alignment != alignment) {
                     d_ptr->m_alignment = alignment;
                     layout()->invalidate();
                 }
             }
             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;
                 layout()->invalidate();
                 setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
                 layout()->invalidate();
                 setParent(d_ptr->m_chart);
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              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;
             }
             /*!
               Returns the list of markers in legend. The list can be filtered with \a series parameter.
               If \a series is given, only markers related to that series are returned.
             */
             QList<QLegendMarker*> QLegend::markers(QAbstractSeries *series) const
             {
                 return d_ptr->markers(series);
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 if (isAttachedToChart())
                     d_ptr->m_presenter->layout()->invalidate();
                 QGraphicsWidget::hideEvent(event);
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 if (isAttachedToChart()) {
                     d_ptr->items()->setVisible(false);
                     layout()->invalidate();
                 }
                 QGraphicsWidget::showEvent(event);
                 //layout activation will show the items
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q)
                 : q_ptr(q),
                   m_presenter(presenter),
                   m_layout(new LegendLayout(q)),
                   m_chart(chart),
                   m_items(new QGraphicsItemGroup(q)),
                   m_alignment(Qt::AlignTop),
                   m_brush(QBrush()),
                   m_pen(QPen()),
                   m_labelBrush(QBrush()),
                   m_diameter(5),
                   m_attachedToChart(true),
                   m_backgroundVisible(false)
             {
                 m_items->setHandlesChildEvents(false);
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(const QPointF &offset)
             {
                 m_layout->setOffset(offset.x(), offset.y());
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100 * m_diameter / int(size);
             }
             QList<QLegendMarker*> QLegendPrivate::markers(QAbstractSeries *series)
             {
                 // Return all markers
                 if (!series) {
                     return m_markers;
                 }
                 // Create filtered list
                 QList<QLegendMarker *> markers;
                 foreach (QLegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         markers.append(marker);
                     }
                 }
                 return markers;
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series)
             {
                 if (m_series.contains(series)) {
                     return;
                 }
                 QList<QLegendMarker*> newMarkers = series->d_ptr->createLegendMarkers(q_ptr);
                 decorateMarkers(newMarkers);
                 addMarkers(newMarkers);
                 QObject::connect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 m_series.append(series);
                 m_items->setVisible(false);
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 if (m_series.contains(series)) {
                     m_series.removeOne(series);
                 }
                 // Find out, which markers to remove
                 QList<QLegendMarker *> removed;
                 foreach (QLegendMarker *m, m_markers) {
                     if (m->series() == series) {
                         removed << m;
                     }
                 }
                 removeMarkers(removed);
                 QObject::disconnect(series->d_ptr.data(), SIGNAL(countChanged()), this, SLOT(handleCountChanged()));
                 QObject::disconnect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries *series = qobject_cast<QAbstractSeries *> (sender());
                 Q_ASSERT(series);
                 foreach (QLegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(series->isVisible());
                     }
                 }
                 m_layout->invalidate();
             }
             void QLegendPrivate::handleCountChanged()
             {
                 // Here we handle the changes in marker count.
                 // Can happen for example when pieslice(s) have been added to or removed from pieseries.
                 QAbstractSeriesPrivate *series = qobject_cast<QAbstractSeriesPrivate *> (sender());
                 QList<QLegendMarker *> createdMarkers = series->createLegendMarkers(q_ptr);
                 // Find out removed markers and created markers
                 QList<QLegendMarker *> removedMarkers;
                 foreach (QLegendMarker *oldMarker, m_markers) {
                     // we have marker, which is related to sender.
                     if (oldMarker->series() == series->q_ptr) {
                         bool found = false;
                         foreach(QLegendMarker *newMarker, createdMarkers) {
                             // New marker considered existing if:
                             // - d_ptr->relatedObject() is same for both markers.
                             if (newMarker->d_ptr->relatedObject() == oldMarker->d_ptr->relatedObject()) {
                                 // Delete the new marker, since we already have existing marker, that might be connected on user side.
                                 found = true;
                                 createdMarkers.removeOne(newMarker);
                                 delete newMarker;
                             }
                         }
                         if (!found) {
                             // No related object found for marker, add to removedMarkers list
                             removedMarkers << oldMarker;
                         }
                     }
                 }
                 removeMarkers(removedMarkers);
                 decorateMarkers(createdMarkers);
                 addMarkers(createdMarkers);
                 q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::addMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     m_items->addToGroup(marker->d_ptr.data()->item());
                     m_markers << marker;
                     m_markerHash.insert(marker->d_ptr->item(), marker);
                 }
             }
             void QLegendPrivate::removeMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     marker->d_ptr->item()->setVisible(false);
                     m_items->removeFromGroup(marker->d_ptr->item());
                     m_markers.removeOne(marker);
                     m_markerHash.remove(marker->d_ptr->item());
                     delete marker;
                 }
             }
             void QLegendPrivate::decorateMarkers(QList<QLegendMarker *> markers)
             {
                 foreach (QLegendMarker *marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                 }
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegendmarker.cpp +31 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "legendlayout_p.h"
             #include <QFontMetrics>
             #include <QGraphicsSceneEvent>
             #include <QAbstractSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegendMarker
                 \brief LegendMarker object
                 \mainclass
                 QLegendMarker is abstract object that can be used to access markers inside QLegend. Legend marker consists of two
                 items: The colored box, which reflects the color of series and label, which is the name of series (or label of slice/barset
                 in case of pie or bar series)
                 The QLegendMarker is always related to one series.
                 \image examples_percentbarchart_legend.png
                 \sa QLegend
             */
             /*!
                 \enum QLegendMarker::LegendMarkerType
                 The type of the legendmarker object.
                 \value LegendMarkerTypeArea
                 \value LegendMarkerTypeBar
                 \value LegendMarkerTypePie
                 \value LegendMarkerTypeXY
             */
             /*!
                 \fn virtual LegendMarkerType QLegendMarker::type() = 0;
                 Returns the type of legendmarker. Type depends of the related series. LegendMarkerTypeXY is used for all QXYSeries derived
                 classes.
             */
             /*!
                 \fn virtual QAbstractSeries* QLegendMarker::series() = 0;
                 Returns pointer to series, which is related to this marker. Marker is always related to some series.
             */
             /*!
               \fn void QLegendMarker::clicked();
               This signal is emitted, when marker is clicked with mouse.
             */
             /*!
               \fn void QLegendMarker::hovered(bool status);
               This signal is emitted, when mouse is hovered over marker. \a status is true, when mouse enters the marker
               and false when it leaves the marker.
             */
             /*!
+                \fn void QLegendMarker::labelChanged()
+                This signal is emitted when the label of the legend marker has changed.
+            */
+            /*!
+                \fn void QLegendMarker::labelBrushChanged()
+                This signal is emitted when the label brush of the legend marker has changed.
+            */
+            /*!
+                \fn void QLegendMarker::fontChanged()
+                This signal is emitted when the (label) font of the legend marker has changed.
+            */
+            /*!
+                \fn void QLegendMarker::penChanged()
+                This signal is emitted when the pen of the legend marker has changed.
+            */
+            /*!
+                \fn void QLegendMarker::brushChanged()
+                This signal is emitted when the brush of the legend marker has changed.
+            */
+            /*!
+                \fn void QLegendMarker::visibleChanged()
+                This signal is emitted when the visibility of the legend marker has changed.
+            */
+            /*!
                 \property QLegendMarker::label
                 Label of the marker. This is the text that is shown in legend.
             */
             /*!
                 \property QLegendMarker::labelBrush
                 Brush of the label
             */
             /*!
                 \property QLegendMarker::font
                 Font of the label
             */
             /*!
                 \property QLegendMarker::pen
                 Pen of the marker. This is the outline of the colored square.
             */
             /*!
                 \property QLegendMarker::brush
                 Brush of the marker. This is the inside of the colored square.
             */
             /*!
                 \property QLegendMarker::visible
                 Visibility of the legend marker. Affects label and the colored square.
             */
             /*!
-             Constructor of marker
+                \internal
              */
             QLegendMarker::QLegendMarker(QLegendMarkerPrivate &d, QObject *parent) :
                 QObject(parent),
                 d_ptr(&d)
             {
                 d_ptr->m_item->setVisible(d_ptr->series()->isVisible());
             }
             /*!
               Destructor of marker
             */
             QLegendMarker::~QLegendMarker()
             {
             }
             /*!
               Returns the label of the marker.
             */
             QString QLegendMarker::label() const
             {
                 return d_ptr->m_item->label();
             }
             /*!
               Sets the \a label of marker. Note that changing name of series will also change label of its marker.
             */
             void QLegendMarker::setLabel(const QString &label)
             {
                 d_ptr->m_item->setLabel(label);
             }
             /*!
               Returns the brush which is used to draw label.
             */
             QBrush QLegendMarker::labelBrush() const
             {
                 return d_ptr->m_item->labelBrush();
             }
             /*!
               Sets the \a brush of label
             */
             void QLegendMarker::setLabelBrush(const QBrush &brush)
             {
                 d_ptr->m_item->setLabelBrush(brush);
             }
             /*!
               Retuns the font of label
             */
             QFont QLegendMarker::font() const
             {
                 return d_ptr->m_item->font();
             }
             /*!
               Sets the \a font of label
             */
             void QLegendMarker::setFont(const QFont &font)
             {
                 d_ptr->m_item->setFont(font);
             }
             /*!
               Returns the pen of marker item
             */
             QPen QLegendMarker::pen() const
             {
                 return d_ptr->m_item->pen();
             }
             /*!
               Sets the \a pen of marker item
             */
             void QLegendMarker::setPen(const QPen &pen)
             {
                 d_ptr->m_item->setPen(pen);
             }
             /*!
               Returns the brush of marker item
             */
             QBrush QLegendMarker::brush() const
             {
                 return d_ptr->m_item->brush();
             }
             /*!
               Sets the \a brush of marker item. Note that changing color of the series also changes this.
             */
             void QLegendMarker::setBrush(const QBrush &brush)
             {
                 d_ptr->m_item->setBrush(brush);
             }
             /*!
               Returns visibility of the marker
             */
             bool QLegendMarker::isVisible() const
             {
                 return d_ptr->m_item->isVisible();
             }
             /*!
               Sets markers visibility to \a visible
             */
             void QLegendMarker::setVisible(bool visible)
             {
                 d_ptr->m_item->setVisible(visible);
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendMarkerPrivate::QLegendMarkerPrivate(QLegendMarker *q, QLegend *legend) :
                 m_legend(legend),
                 q_ptr(q)
             {
                 m_item = new LegendMarkerItem(this);
             }
             QLegendMarkerPrivate::~QLegendMarkerPrivate()
             {
             }
             void QLegendMarkerPrivate::invalidateLegend()
             {
                 m_legend->d_ptr->m_layout->invalidate();
             }
             #include "moc_qlegendmarker.cpp"
             #include "moc_qlegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qpielegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpielegendmarker.h"
             #include "qpielegendmarker_p.h"
             #include <QPieSeries>
             #include <QPieSlice>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieLegendMarker
                 \brief LegendMarker object
                 \mainclass
                 QPieLegendMarker is related to QPieSeries. With QPieSeries, each slice of pie is related to one marker in QLegend.
                 \sa QLegend QPieSeries QPieSlice
             */
             /*!
               \fn virtual LegendMarkerType QPieLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypePie
             */
             /*!
-              Constructor
+              \internal
             */
             QPieLegendMarker::QPieLegendMarker(QPieSeries *series, QPieSlice *slice, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QPieLegendMarkerPrivate(this,series,slice,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Destructor
             */
             QPieLegendMarker::~QPieLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QPieLegendMarker::QPieLegendMarker(QPieLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns the related series of marker.
             */
             QPieSeries* QPieLegendMarker::series()
             {
                 Q_D(QPieLegendMarker);
                 return d->m_series;
             }
             /*!
               Returns the related slice of marker.
             */
             QPieSlice* QPieLegendMarker::slice()
             {
                 Q_D(QPieLegendMarker);
                 return d->m_slice;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieLegendMarkerPrivate::QPieLegendMarkerPrivate(QPieLegendMarker *q, QPieSeries *series, QPieSlice *slice, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series),
                 m_slice(slice)
             {
                 QObject::connect(m_slice, SIGNAL(labelChanged()), this, SLOT(updated()));
                 QObject::connect(m_slice, SIGNAL(brushChanged()), this, SLOT(updated()));
                 QObject::connect(m_slice, SIGNAL(penChanged()), this, SLOT(updated()));
             }
             QPieLegendMarkerPrivate::~QPieLegendMarkerPrivate()
             {
             }
             QPieSeries* QPieLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QPieLegendMarkerPrivate::relatedObject()
             {
                 return m_slice;
             }
             void QPieLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 bool penChanged = false;
                 if (m_item->pen() != m_slice->pen()) {
                     m_item->setPen(m_slice->pen());
                     penChanged = true;
                 }
                 if (m_item->brush() != m_slice->brush()) {
                     m_item->setBrush(m_slice->brush());
                     brushChanged = true;
                 }
                 if (m_item->label() != m_slice->label()) {
                     m_item->setLabel(m_slice->label());
                     labelChanged = true;
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
                 if (penChanged)
                     emit q_ptr->penChanged();
             }
             #include "moc_qpielegendmarker.cpp"
             #include "moc_qpielegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qxylegendmarker.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qxylegendmarker.h"
             #include "qxylegendmarker_p.h"
             #include "qxyseries_p.h"
             #include <QXYSeries>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYLegendMarker
                 \brief QXYLegendMarker object
                 \mainclass
                 QXYLegendMarker is related to QXYSeries derived classes. Each marker is related to one series.
                 \sa QLegend QXYSeries QSplineSeries QScatterSeries QLineSeries
             */
             /*!
               \fn virtual LegendMarkerType QXYLegendMarker::type()
               Returns QLegendMarker::LegendMarkerTypeXY
             */
             /*!
-              Constructor
+              \internal
             */
             QXYLegendMarker::QXYLegendMarker(QXYSeries *series, QLegend *legend, QObject *parent) :
                 QLegendMarker(*new QXYLegendMarkerPrivate(this,series,legend), parent)
             {
                 d_ptr->updated();
             }
             /*!
               Destructor
             */
             QXYLegendMarker::~QXYLegendMarker()
             {
             }
             /*!
                 \internal
             */
             QXYLegendMarker::QXYLegendMarker(QXYLegendMarkerPrivate &d, QObject *parent) :
                 QLegendMarker(d, parent)
             {
             }
             /*!
               Returns the related series
             */
             QXYSeries* QXYLegendMarker::series()
             {
                 Q_D(QXYLegendMarker);
                 return d->m_series;
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QXYLegendMarkerPrivate::QXYLegendMarkerPrivate(QXYLegendMarker *q, QXYSeries *series, QLegend *legend) :
                 QLegendMarkerPrivate(q,legend),
                 q_ptr(q),
                 m_series(series)
             {
                 QObject::connect(m_series, SIGNAL(nameChanged()), this, SLOT(updated()));
                 QObject::connect(m_series->d_func(), SIGNAL(updated()), this, SLOT(updated()));
             }
             QXYLegendMarkerPrivate::~QXYLegendMarkerPrivate()
             {
             }
             QAbstractSeries* QXYLegendMarkerPrivate::series()
             {
                 return m_series;
             }
             QObject* QXYLegendMarkerPrivate::relatedObject()
             {
                 return m_series;
             }
             void QXYLegendMarkerPrivate::updated()
             {
                 bool labelChanged = false;
                 bool brushChanged = false;
                 if (m_item->label() != m_series->name()) {
                     m_item->setLabel(m_series->name());
                     labelChanged = true;
                 }
                 if (m_series->type()== QAbstractSeries::SeriesTypeScatter)  {
                     if (m_item->brush() != m_series->brush()) {
                         m_item->setBrush(m_series->brush());
                         brushChanged = true;
                     }
                 } else {
                     if (m_item->brush().color() != m_series->pen().color()) {
                         m_item->setBrush(QBrush(m_series->pen().color()));
                         brushChanged = true;
                     }
                 }
                 invalidateLegend();
                 if (labelChanged)
                     emit q_ptr->labelChanged();
                 if (brushChanged)
                     emit q_ptr->brushChanged();
             }
             #include "moc_qxylegendmarker.cpp"
             #include "moc_qxylegendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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