HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2081:b2efc1272dac

legend private implemantation modified.

sauimone -

r2081:b2efc1272dac

parent child

Context file:

r2081:b2efc1272dac

Collapse all files

src/barchart/qabstractbarseries.cpp +13 -16

              /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
              #include "qabstractbarseries.h"
              #include "qabstractbarseries_p.h"
              #include "qbarset.h"
              #include "qbarset_p.h"
              #include "domain_p.h"
              #include "legendmarker_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
              #include "qvalueaxis.h"
              #include "qbarcategoryaxis.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QAbstractBarSeries
                  \brief Series for creating a bar chart
                  \mainclass
                  QAbstractBarSeries represents a series of data shown as bars. The purpose of this class is to draw bars to
                  the position defined by data. Single bar is defined by QPointF, where x value is the x-coordinate of the bar
                  and y-value is the height of the bar. The category names are ignored with this series and x-axis
                  shows the x-values.
                  See the \l {BarChart Example} {bar chart example} to learn how to create a simple bar chart.
                  \image examples_barchart.png
                  \sa QBarSet, QStackedBarSeries, QPercentBarSeries
              */
              /*!
                  \qmlclass AbstractBarSeries QAbstractBarSeries
                  \inherits QAbstractSeries
                  The following QML shows how to create a simple bar chart:
                  \snippet ../demos/qmlchart/qml/qmlchart/View6.qml 1
                  \beginfloatleft
                  \image demos_qmlchart6.png
                  \endfloat
                  \clearfloat
              */
              /*!
                  \property QAbstractBarSeries::barWidth
                  The width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                  is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                  is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                  Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
                  \sa QBarSeries
              */
              /*!
                  \qmlproperty real AbstractBarSeries::barWidth
                  The width of the bars of the series. The unit of width is the unit of x-axis. The minimum width for bars
                  is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                  is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                  Note that with QBarSeries this value means the width of one group of bars instead of just one bar.
              */
              /*!
                  \property QAbstractBarSeries::count
                  Holds the number of sets in series.
              */
              /*!
                  \qmlproperty int AbstractBarSeries::count
                  Holds the number of sets in series.
              */
              /*!
                  \property QAbstractBarSeries::labelsVisible
                  Defines the visibility of the labels in series
              */
              /*!
                  \qmlproperty bool AbstractBarSeries::labelsVisible
                  Defines the visibility of the labels in series
              */
              /*!
                  \fn void QAbstractBarSeries::clicked(int index, QBarSet *barset)
                  The signal is emitted if the user clicks with a mouse on top of QBarSet \a barset.
                  Clicked bar inside set is indexed by \a index
              */
              /*!
                  \qmlsignal AbstractBarSeries::onClicked(int index, BarSet barset)
                  The signal is emitted if the user clicks with a mouse on top of BarSet.
                  Clicked bar inside set is indexed by \a index
              */
              /*!
                  \fn void QAbstractBarSeries::hovered(bool status, QBarSet* barset)
                  The signal is emitted if mouse is hovered on top of series.
                  Parameter \a barset is the pointer of barset, where hover happened.
                  Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
              */
              /*!
                  \qmlsignal AbstractBarSeries::onHovered(bool status, BarSet barset)
                  The signal is emitted if mouse is hovered on top of series.
                  Parameter \a barset is the pointer of barset, where hover happened.
                  Parameter \a status is true, if mouse entered on top of series, false if mouse left from top of series.
              */
              /*!
                  \fn void QAbstractBarSeries::countChanged()
                  This signal is emitted when barset count has been changed, for example by append or remove.
              */
              /*!
                  \qmlsignal AbstractBarSeries::onCountChanged()
                  This signal is emitted when barset count has been changed, for example by append or remove.
              */
              /*!
                  \fn void QAbstractBarSeries::labelsVisibleChanged()
                  This signal is emitted when labels visibility have changed.
                  \sa isLabelsVisible(), setLabelsVisible()
              */
              /*!
                  \fn void QAbstractBarSeries::barsetsAdded(QList<QBarSet*> sets)
                  This signal is emitted when \a sets have been added to the series.
                  \sa append(), insert()
              */
              /*!
                  \qmlsignal AbstractBarSeries::onAdded(BarSet barset)
                  Emitted when \a barset has been added to the series.
              */
              /*!
                  \fn void QAbstractBarSeries::barsetsRemoved(QList<QBarSet*> sets)
                  This signal is emitted when \a sets have been removed from the series.
                  \sa remove()
              */
              /*!
                  \qmlsignal AbstractBarSeries::onRemoved(BarSet barset)
                  Emitted when \a barset has been removed from the series.
              */
              /*!
                  \qmlmethod BarSet AbstractBarSeries::at(int index)
                  Returns bar set at \a index. Returns null if the index is not valid.
              */
              /*!
                  \qmlmethod BarSet AbstractBarSeries::append(string label, VariantList values)
                  Adds a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                  For example:
                  \code
                      myBarSeries.append("set 1", [0, 0.2, 0.2, 0.5, 0.4, 1.5, 0.9]);
                      myBarSeries.append("set 2", [Qt.point(0, 1), Qt.point(2, 2.5), Qt.point(3.5, 2.2)]);
                  \endcode
              */
              /*!
                  \qmlmethod BarSet AbstractBarSeries::insert(int index, string label, VariantList values)
                  Inserts a new bar set with \a label and \a values to \a index. Values can be a list of reals or a list of XYPoints.
                  If index is zero or smaller, the new barset is prepended. If the index is count or bigger, the new barset is
                  appended.
                  \sa AbstractBarSeries::append()
              */
              /*!
                  \qmlmethod bool AbstractBarSeries::remove(BarSet barset)
                  Removes the barset from the series. Returns true if successful, false otherwise.
              */
              /*!
                  \qmlmethod AbstractBarSeries::clear()
                  Removes all barsets from the series.
              */
              /*!
                  Destructs abstractbarseries and owned barsets.
              */
              QAbstractBarSeries::~QAbstractBarSeries()
              {
              }
              /*!
                  \internal
              */
              QAbstractBarSeries::QAbstractBarSeries(QAbstractBarSeriesPrivate &d, QObject *parent) :
                  QAbstractSeries(d,parent)
              {
              }
              /*!
                  Sets the width of the bars of the series. The unit of \a width is the unit of x-axis. The minimum width for bars
                  is zero and negative values are treated as zero. Setting the width to zero means that width of the bar on screen
                  is one pixel no matter what the scale of x-axis is. Bars wider than zero are scaled with x-axis.
                  Note that with \link QBarSeries \endlink this value means the width of one group of bars instead of just one bar.
              */
              void QAbstractBarSeries::setBarWidth(qreal width)
              {
                  Q_D(QAbstractBarSeries);
                  d->setBarWidth(width);
              }
              /*!
                  Returns the width of the bars of the series.
                  \sa setBarWidth()
              */
              qreal QAbstractBarSeries::barWidth() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->barWidth();
              }
              /*!
                  Adds a set of bars to series. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                  Returns true, if appending succeeded.
              */
              bool QAbstractBarSeries::append(QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->append(set);
                  if (success) {
                      QList<QBarSet*> sets;
                      sets.append(set);
                      set->setParent(this);
                      emit barsetsAdded(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Removes barset from series. Releases ownership of \a set. Deletes the set, if remove
                  was successful.
                  Returns true, if set was removed.
              */
              bool QAbstractBarSeries::remove(QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->remove(set);
                  if (success) {
                      QList<QBarSet*> sets;
                      sets.append(set);
                      set->setParent(0);
                      emit barsetsRemoved(sets);
                      emit countChanged();
                      delete set;
                      set = 0;
                  }
                  return success;
              }
              /*!
                  Takes a single \a set from the series. Does not delete the barset object.
                  NOTE: The series remains as the barset's parent object. You must set the
                  parent object to take full ownership.
                  Returns true if take was successful.
              */
              bool QAbstractBarSeries::take(QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->remove(set);
                  if (success) {
                      QList<QBarSet*> sets;
                      sets.append(set);
                      emit barsetsRemoved(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Adds a list of barsets to series. Takes ownership of \a sets.
                  Returns true, if all sets were appended successfully. If any of the sets is null or is already appended to series,
                  nothing is appended and function returns false. If any of the sets is in list more than once, nothing is appended
                  and function returns false.
              */
              bool QAbstractBarSeries::append(QList<QBarSet* > sets)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->append(sets);
                  if (success) {
                      emit barsetsAdded(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Insert a set of bars to series at \a index postion. Takes ownership of \a set. If the set is null or is already in series, it won't be appended.
                  Returns true, if inserting succeeded.
              */
              bool QAbstractBarSeries::insert(int index, QBarSet *set)
              {
                  Q_D(QAbstractBarSeries);
                  bool success = d->insert(index, set);
                  if (success) {
                      QList<QBarSet*> sets;
                      sets.append(set);
                      emit barsetsAdded(sets);
                      emit countChanged();
                  }
                  return success;
              }
              /*!
                  Removes all barsets from the series. Deletes removed sets.
              */
              void QAbstractBarSeries::clear()
              {
                  Q_D(QAbstractBarSeries);
                  QList<QBarSet *> sets = barSets();
                  bool success = d->remove(sets);
                  if (success) {
                      emit barsetsRemoved(sets);
                      emit countChanged();
                      foreach (QBarSet* set, sets) {
                          delete set;
                      }
                  }
              }
              /*!
                  Returns number of sets in series.
              */
              int QAbstractBarSeries::count() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->m_barSets.count();
              }
              /*!
                  Returns a list of sets in series. Keeps ownership of sets.
               */
              QList<QBarSet*> QAbstractBarSeries::barSets() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->m_barSets;
              }
              /*!
                  Sets the visibility of labels in series to \a visible
              */
              void QAbstractBarSeries::setLabelsVisible(bool visible)
              {
                  Q_D(QAbstractBarSeries);
                  if (d->m_labelsVisible != visible) {
                      d->setLabelsVisible(visible);
                      emit labelsVisibleChanged();
                  }
              }
              /*!
                  Returns the visibility of labels
              */
              bool QAbstractBarSeries::isLabelsVisible() const
              {
                  Q_D(const QAbstractBarSeries);
                  return d->m_labelsVisible;
              }
              ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QAbstractBarSeriesPrivate::QAbstractBarSeriesPrivate(QAbstractBarSeries *q) :
                  QAbstractSeriesPrivate(q),
                  m_barWidth(0.5),  // Default value is 50% of category width
                  m_labelsVisible(false),
                  m_visible(true)
              {
              }
              int QAbstractBarSeriesPrivate::categoryCount() const
              {
                  // No categories defined. return count of longest set.
                  int count = 0;
                  for (int i=0; i<m_barSets.count(); i++) {
                      if (m_barSets.at(i)->count() > count) {
                          count = m_barSets.at(i)->count();
                      }
                  }
                  return count;
              }
              void QAbstractBarSeriesPrivate::setBarWidth(qreal width)
              {
                  if (width < 0.0) {
                      width = 0.0;
                  }
                  m_barWidth = width;
                  emit updatedLayout();
              }
              qreal QAbstractBarSeriesPrivate::barWidth() const
              {
                  return m_barWidth;
              }
              QBarSet* QAbstractBarSeriesPrivate::barsetAt(int index)
              {
                  return m_barSets.at(index);
              }
              void QAbstractBarSeriesPrivate::setVisible(bool visible)
              {
                  m_visible = visible;
                  emit visibleChanged();
              }
              void QAbstractBarSeriesPrivate::setLabelsVisible(bool visible)
              {
                  m_labelsVisible = visible;
                  emit labelsVisibleChanged(visible);
              }
              qreal QAbstractBarSeriesPrivate::min()
              {
                  if (m_barSets.count() <= 0) {
                      return 0;
                  }
                  qreal min = INT_MAX;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->at(j);
                          if (temp < min)
                              min = temp;
                      }
                  }
                  return min;
              }
              qreal QAbstractBarSeriesPrivate::max()
              {
                  if (m_barSets.count() <= 0) {
                      return 0;
                  }
                  qreal max = INT_MIN;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->at(j);
                          if (temp > max)
                              max = temp;
                      }
                  }
                  return max;
              }
              qreal QAbstractBarSeriesPrivate::valueAt(int set, int category)
              {
                  if ((set < 0) || (set >= m_barSets.count())) {
                      // No set, no value.
                      return 0;
                  } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                      // No category, no value.
                      return 0;
                  }
                  return m_barSets.at(set)->at(category);
              }
              qreal QAbstractBarSeriesPrivate::percentageAt(int set, int category)
              {
                  if ((set < 0) || (set >= m_barSets.count())) {
                      // No set, no value.
                      return 0;
                  } else if ((category < 0) || (category >= m_barSets.at(set)->count())) {
                      // No category, no value.
                      return 0;
                  }
                  qreal value = m_barSets.at(set)->at(category);
                  qreal sum = categorySum(category);
                  if ( qFuzzyIsNull(sum) ) {
                      return 0;
                  }
                  return value / sum;
              }
              qreal QAbstractBarSeriesPrivate::categorySum(int category)
              {
                  qreal sum(0);
                  int count = m_barSets.count(); // Count sets
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count())
                          sum += m_barSets.at(set)->at(category);
                  }
                  return sum;
              }
              qreal QAbstractBarSeriesPrivate::absoluteCategorySum(int category)
              {
                  qreal sum(0);
                  int count = m_barSets.count(); // Count sets
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count())
                          sum += qAbs(m_barSets.at(set)->at(category));
                  }
                  return sum;
              }
              qreal QAbstractBarSeriesPrivate::maxCategorySum()
              {
                  qreal max = INT_MIN;
                  int count = categoryCount();
                  for (int i = 0; i < count; i++) {
                      qreal sum = categorySum(i);
                      if (sum > max)
                          max = sum;
                  }
                  return max;
              }
              qreal QAbstractBarSeriesPrivate::minX()
              {
                  if (m_barSets.count() <= 0) {
                      return 0;
                  }
                  qreal min = INT_MAX;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                          if (temp < min)
                              min = temp;
                      }
                  }
                  return min;
              }
              qreal QAbstractBarSeriesPrivate::maxX()
              {
                  if (m_barSets.count() <= 0) {
                      return 0;
                  }
                  qreal max = INT_MIN;
                  for (int i = 0; i < m_barSets.count(); i++) {
                      int categoryCount = m_barSets.at(i)->count();
                      for (int j = 0; j < categoryCount; j++) {
                          qreal temp = m_barSets.at(i)->d_ptr.data()->m_values.at(j).x();
                          if (temp > max)
                              max = temp;
                      }
                  }
                  return max;
              }
              qreal QAbstractBarSeriesPrivate::categoryTop(int category)
              {
                  // Returns top (sum of all positive values) of category.
                  // Returns 0, if all values are negative
                  qreal top(0);
                  int count = m_barSets.count();
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count()) {
                          qreal temp = m_barSets.at(set)->at(category);
                          if (temp > 0) {
                              top += temp;
                          }
                      }
                  }
                  return top;
              }
              qreal QAbstractBarSeriesPrivate::categoryBottom(int category)
              {
                  // Returns bottom (sum of all negative values) of category
                  // Returns 0, if all values are positive
                  qreal bottom(0);
                  int count = m_barSets.count();
                  for (int set = 0; set < count; set++) {
                      if (category < m_barSets.at(set)->count()) {
                          qreal temp = m_barSets.at(set)->at(category);
                          if (temp < 0) {
                              bottom += temp;
                          }
                      }
                  }
                  return bottom;
              }
              qreal QAbstractBarSeriesPrivate::top()
              {
                  // Returns top of all categories
                  qreal top(0);
                  int count = categoryCount();
                  for (int i=0; i<count; i++) {
                      qreal temp = categoryTop(i);
                      if (temp > top) {
                          top = temp;
                      }
                  }
                  return top;
              }
              qreal QAbstractBarSeriesPrivate::bottom()
              {
                  // Returns bottom of all categories
                  qreal bottom(0);
                  int count = categoryCount();
                  for (int i=0; i<count; i++) {
                      qreal temp = categoryBottom(i);
                      if (temp < bottom) {
                          bottom = temp;
                      }
                  }
                  return bottom;
              }
              void QAbstractBarSeriesPrivate::scaleDomain(Domain& domain)
              {
                  qreal minX(domain.minX());
                  qreal minY(domain.minY());
                  qreal maxX(domain.maxX());
                  qreal maxY(domain.maxY());
                  qreal seriesMinX = this->minX();
                  qreal seriesMaxX = this->maxX();
                  qreal y = max();
                  minX = qMin(minX, seriesMinX - (qreal)0.5);
                  minY = qMin(minY, y);
                  maxX = qMax(maxX, seriesMaxX + (qreal)0.5);
                  maxY = qMax(maxY, y);
                  domain.setRange(minX,maxX,minY,maxY);
              }
              ChartElement* QAbstractBarSeriesPrivate::createGraphics(ChartPresenter* presenter)
              {
                  Q_UNUSED(presenter);
                  qWarning() << "QAbstractBarSeriesPrivate::createGraphics called";
                  return 0;
              }
              QList<LegendMarker*> QAbstractBarSeriesPrivate::createLegendMarker(QLegend* legend)
              {
                  Q_Q(QAbstractBarSeries);
                  QList<LegendMarker*> markers;
                  foreach(QBarSet* set, q->barSets()) {
                      BarLegendMarker* marker = new BarLegendMarker(q,set,legend);
                      markers << marker;
                  }
                  return markers;
              }
              bool QAbstractBarSeriesPrivate::append(QBarSet *set)
              {
                  Q_Q(QAbstractBarSeries);
                  if ((m_barSets.contains(set)) || (set == 0)) {
                      // Fail if set is already in list or set is null.
                      return false;
                  }
                  m_barSets.append(set);
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
-                 emit restructuredBars();      // this notifies barchartitem
-                 if (m_dataset) {
-                     m_dataset->updateSeries(q);   // this notifies legend
+                 }
+                 emit restructuredBars();        // this notifies barchartitem
+                 emit legendPropertiesUpdated(q); // this notifies legend
                  return true;
              }
              bool QAbstractBarSeriesPrivate::remove(QBarSet *set)
              {
                  Q_Q(QAbstractBarSeries);
                  if (!m_barSets.contains(set)) {
                      // Fail if set is not in list
                      return false;
                  }
                  m_barSets.removeOne(set);
                  QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                  QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                  QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  emit restructuredBars();        // this notifies barchartitem
-                 if (m_dataset) {
-                     m_dataset->updateSeries(q);   // this notifies legend
+                 }
+                 emit legendPropertiesUpdated(q);
                  return true;
              }
              bool QAbstractBarSeriesPrivate::append(QList<QBarSet* > sets)
              {
                  Q_Q(QAbstractBarSeries);
                  foreach (QBarSet* set, sets) {
                      if ((set == 0) || (m_barSets.contains(set))) {
                          // Fail if any of the sets is null or is already appended.
                          return false;
                      }
                      if (sets.count(set) != 1) {
                          // Also fail if same set is more than once in given list.
                          return false;
                      }
                  }
                  foreach (QBarSet* set, sets) {
                      m_barSets.append(set);
                      QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                      QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                      QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  }
                  emit restructuredBars();        // this notifies barchartitem
-                 if (m_dataset) {
-                     m_dataset->updateSeries(q);   // this notifies legend
+                 }
+                 emit legendPropertiesUpdated(q); // this notifies legend
                  return true;
              }
              bool QAbstractBarSeriesPrivate::remove(QList<QBarSet* > sets)
              {
                  Q_Q(QAbstractBarSeries);
                  if (sets.count() == 0) {
                      return false;
                  }
                  foreach (QBarSet* set, sets) {
                      if ((set == 0) || (!m_barSets.contains(set))) {
                          // Fail if any of the sets is null or is not in series
                          return false;
                      }
                      if (sets.count(set) != 1) {
                          // Also fail if same set is more than once in given list.
                          return false;
                      }
                  }
                  foreach (QBarSet* set, sets) {
                      m_barSets.removeOne(set);
                      QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                      QObject::disconnect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                      QObject::disconnect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  }
                  emit restructuredBars();        // this notifies barchartitem
-                 if (m_dataset) {
-                     m_dataset->updateSeries(q);   // this notifies legend
+                 }
+                 emit legendPropertiesUpdated(q);
                  return true;
              }
              bool QAbstractBarSeriesPrivate::insert(int index, QBarSet *set)
              {
                  Q_Q(QAbstractBarSeries);
                  if ((m_barSets.contains(set)) || (set == 0)) {
                      // Fail if set is already in list or set is null.
                      return false;
                  }
                  m_barSets.insert(index, set);
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedLayout()), this, SIGNAL(updatedLayout()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(updatedBars()), this, SIGNAL(updatedBars()));
                  QObject::connect(set->d_ptr.data(), SIGNAL(restructuredBars()), this, SIGNAL(restructuredBars()));
                  emit restructuredBars();      // this notifies barchartitem
-                 if (m_dataset) {
-                     m_dataset->updateSeries(q);   // this notifies legend
+                 }
+                 emit legendPropertiesUpdated(q);
                  return true;
              }
              void QAbstractBarSeriesPrivate::initializeAxis(QAbstractAxis* axis)
              {
                  Q_Q(QAbstractBarSeries);
                  if(axis->type()==QAbstractAxis::AxisTypeBarCategory) {
                      switch(q->type()) {
                          case QAbstractSeries::SeriesTypeHorizontalBar:
                          case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                          case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
                              if(axis->orientation()==Qt::Vertical)
                              {
                                  populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
                              }
                              break;
                          }
                          case QAbstractSeries::SeriesTypeBar:
                          case QAbstractSeries::SeriesTypePercentBar:
                          case QAbstractSeries::SeriesTypeStackedBar: {
                              if(axis->orientation()==Qt::Horizontal)
                              {
                                  populateCategories(qobject_cast<QBarCategoryAxis*>(axis));
                              }
                              break;
                          }
                          default:
                          qWarning()<<"Unexpected series type";
                          break;
                      }
                  }
              }
              QAbstractAxis::AxisType QAbstractBarSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
              {
                  Q_Q(const QAbstractBarSeries);
                  switch(q->type()) {
                      case QAbstractSeries::SeriesTypeHorizontalBar:
                      case QAbstractSeries::SeriesTypeHorizontalPercentBar:
                      case QAbstractSeries::SeriesTypeHorizontalStackedBar: {
                          if(orientation==Qt::Vertical)
                          {
                              return QAbstractAxis::AxisTypeBarCategory;
                          }
                          break;
                      }
                      case QAbstractSeries::SeriesTypeBar:
                      case QAbstractSeries::SeriesTypePercentBar:
                      case QAbstractSeries::SeriesTypeStackedBar: {
                          if(orientation==Qt::Horizontal)
                          {
                              return QAbstractAxis::AxisTypeBarCategory;
                          }
                          break;
                      }
                      default:
                      qWarning()<<"Unexpected series type";
                      break;
                  }
                  return QAbstractAxis::AxisTypeValue;
              }
              void QAbstractBarSeriesPrivate::populateCategories(QBarCategoryAxis* axis)
              {
                  QStringList categories;
                  if(axis->categories().isEmpty()) {
                      for (int i(1); i < categoryCount()+1; i++)
                      categories << QString::number(i);
                      axis->append(categories);
                  }
              }
              #include "moc_qabstractbarseries.cpp"
              #include "moc_qabstractbarseries_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.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 "chartdataset_p.h"
              #include "qchart.h"
              #include "qvalueaxis.h"
              #include "qbarcategoryaxis.h"
              #include "qvalueaxis_p.h"
              #include "qcategoryaxis.h"
              #include "qabstractseries_p.h"
              #include "qabstractbarseries.h"
              #include "qstackedbarseries.h"
              #include "qpercentbarseries.h"
              #include "qpieseries.h"
              #ifndef QT_ON_ARM
                  #include "qdatetimeaxis.h"
              #endif
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              ChartDataSet::ChartDataSet(QChart *parent):QObject(parent)
              {
              }
              ChartDataSet::~ChartDataSet()
              {
                  removeAllSeries();
              }
              void ChartDataSet::addSeries(QAbstractSeries* series)
              {
                  Domain* domain = m_seriesDomainMap.value(series);
                  if(domain) {
                      qWarning() << "Can not add series. Series already on the chart";
                      return;
                  }
                  domain = new Domain(series);
                  m_seriesDomainMap.insert(series,domain);
                  series->d_ptr->scaleDomain(*domain);
                  createSeriesIndex(series);
                  series->setParent(this); // take ownership
                  series->d_ptr->m_chart = qobject_cast<QChart*>(parent());
                  series->d_ptr->m_dataset = this;
                  emit seriesAdded(series,domain);
              }
              void ChartDataSet::removeSeries(QAbstractSeries* series)
              {
                  if(!m_seriesDomainMap.contains(series)) {
                      qWarning()<<"Can not remove series. Series not found on the chart.";
                      return;
                  }
                  emit seriesRemoved(series);
                  Domain* domain = m_seriesDomainMap.take(series);
                  delete domain;
                  domain = 0;
                  removeSeriesIndex(series);
                  series->setParent(0);
                  series->d_ptr->m_chart = 0;
                  series->d_ptr->m_dataset = 0;
                  removeAxes(series);
              }
              void ChartDataSet::createSeriesIndex(QAbstractSeries* series)
              {
                  QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                  int key=0;
                  while (i.hasNext()) {
                      i.next();
                      if(i.key()!=key) {
                          break;
                      }
                      key++;
                  }
                  m_indexSeriesMap.insert(key,series);
              }
              void ChartDataSet::removeSeriesIndex(QAbstractSeries* series)
              {
                  int key = seriesIndex(series);
                  Q_ASSERT(key!=-1);
                  m_indexSeriesMap.remove(key);
              }
              void ChartDataSet::createDefaultAxes()
              {
                  if (m_seriesDomainMap.isEmpty())
                      return;
                  QAbstractAxis::AxisTypes typeX(0);
                  QAbstractAxis::AxisTypes typeY(0);
                  // Remove possibly existing axes
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  while (i.hasNext()) {
                      i.next();
                      removeAxes(i.key());
                  }
                  i.toFront();
                  // Select the required axis x and axis y types based on the types of the current series
                  while (i.hasNext()) {
                      i.next();
                      QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                      QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                      if(axisX) typeX&=axisX->type();
                      else typeX|=i.key()->d_ptr->defaultAxisType(Qt::Horizontal);
                      if(axisY) typeY&=axisY->type();
                      else typeY|=i.key()->d_ptr->defaultAxisType(Qt::Vertical);
                  }
                  // Create the axes of the types selected
                  createAxes(typeX, Qt::Horizontal);
                  createAxes(typeY, Qt::Vertical);
              }
              void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
              {
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  // TODO: Add a descriptive comment of what happens here
                  if (type.testFlag(QAbstractAxis::AxisTypeValue) && type.testFlag(QAbstractAxis::AxisTypeBarCategory)) {
                      while (i.hasNext()) {
                          i.next();
                          QAbstractAxis* axis = createAxis(i.key()->d_ptr->defaultAxisType(orientation), orientation);
                          if (axis) {
                              initializeAxis(axis, i.key());
                              emit axisAdded(axis, i.value());
                          }
                      }
                  } else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
                      QAbstractAxis* axis = createAxis(QAbstractAxis::AxisType(int(type)), orientation);
                      i.toFront();
                      while (i.hasNext()) {
                          i.next();
                          initializeAxis(axis,i.key());
                      }
                      emit axisAdded(axis,i.value());
                  }
              }
              QAbstractAxis* ChartDataSet::createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation)
              {
                  QAbstractAxis* axis = 0;
                  switch(type) {
                  case QAbstractAxis::AxisTypeValue:
                      axis = new QValueAxis(this);
                      break;
                  case QAbstractAxis::AxisTypeBarCategory:
                      axis = new QBarCategoryAxis(this);
                      break;
                  case QAbstractAxis::AxisTypeCategory:
                      axis = new QCategoryAxis(this);
                      break;
              #ifndef Q_WS_QWS
                  case QAbstractAxis::AxisTypeDateTime:
                      axis = new QDateTimeAxis(this);
                      break;
              #endif
                  default:
                      axis = 0;
                      break;
                  }
                  if(axis)
                      axis->d_ptr->setOrientation(orientation);
                  return axis;
              }
              void ChartDataSet::initializeAxis(QAbstractAxis* axis,QAbstractSeries* series)
              {
                  Domain* domain = m_seriesDomainMap.value(series);
                  axis->d_ptr->m_dataset = this;
                  series->d_ptr->initializeAxis(axis);
                  axis->d_ptr->intializeDomain(domain);
                  if(axis->orientation()==Qt::Horizontal) {
                      QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                      QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                      m_seriesAxisXMap.insert(series,axis);
                  }
                  else {
                      QObject::connect(axis->d_ptr.data(),SIGNAL(updated()),domain,SLOT(handleAxisUpdated()));
                      QObject::connect(domain,SIGNAL(updated()),axis->d_ptr.data(),SLOT(handleDomainUpdated()));
                      m_seriesAxisYMap.insert(series,axis);
                  }
                  axis->d_ptr->emitUpdated();
              }
              void ChartDataSet::removeAxes(QAbstractSeries* series)
              {
                  QAbstractAxis* axisX = m_seriesAxisXMap.take(series);
                  if(axisX) {
                      QList<QAbstractAxis*> axesX = m_seriesAxisXMap.values();
                      int x = axesX.indexOf(axisX);
                      if(x==-1) {
                          emit axisRemoved(axisX);
                          axisX->d_ptr->m_dataset=0;
                          axisX->deleteLater();
                      }
                  }
                  QAbstractAxis* axisY = m_seriesAxisYMap.take(series);
                  if(axisY) {
                      QList<QAbstractAxis*> axesY = m_seriesAxisYMap.values();
                      int y = axesY.indexOf(axisY);
                      if(y==-1) {
                          emit axisRemoved(axisY);
                          axisY->d_ptr->m_dataset=0;
                          axisY->deleteLater();
                      }
                  }
              }
              void ChartDataSet::removeAxis(QAbstractAxis* axis)
              {
                  if(!axis->d_ptr->m_dataset) {
                      qWarning()<<"UnBound axis found !";
                      return;
                  }
                  QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                  if(axis->orientation()==Qt::Vertical) {
                      seriesAxisMap= &m_seriesAxisYMap;
                  }
                  else {
                      seriesAxisMap= &m_seriesAxisXMap;
                  }
                  QMapIterator<QAbstractSeries*, QAbstractAxis*> i(*seriesAxisMap);
                  while (i.hasNext()) {
                      i.next();
                      if(i.value()==axis) {
                          removeSeries(i.key());
                      }
                  }
              }
              void ChartDataSet::removeAllSeries()
              {
                  QList<QAbstractSeries*> series =   m_seriesDomainMap.keys();
                  foreach(QAbstractSeries *s , series) {
                      removeSeries(s);
                  }
                  Q_ASSERT(m_seriesAxisXMap.count()==0);
                  Q_ASSERT(m_seriesAxisXMap.count()==0);
                  Q_ASSERT(m_seriesDomainMap.count()==0);
                  qDeleteAll(series);
              }
              void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
              {
                  //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                  blockAxisSignals(true);
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  while (i.hasNext()) {
                      i.next();
                      i.value()->zoomIn(rect,size);
                  }
                  blockAxisSignals(false);
              }
              void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
              {
                  //for performance reasons block, signals and scale "full" domain one by one. Gives twice less screen updates
                  blockAxisSignals(true);
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  while (i.hasNext()) {
                      i.next();
                      i.value()->zoomOut(rect,size);
                  }
                  blockAxisSignals(false);
              }
              void ChartDataSet::blockAxisSignals(bool enabled)
              {
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  while (i.hasNext()) {
                      i.next();
                      QAbstractAxis* axisX = m_seriesAxisXMap.value(i.key());
                      QAbstractAxis* axisY = m_seriesAxisYMap.value(i.key());
                      if(axisX) {
                          axisX->d_ptr->blockSignals(enabled);
                          if(!enabled) {
                              axisX->d_ptr->setDirty(false);
                              axisX->d_ptr->emitUpdated();
                          }
                      }
                      if(axisY) {
                          axisY->d_ptr->blockSignals(enabled);
                          if(!enabled) {
                              axisY->d_ptr->setDirty(false);
                              axisY->d_ptr->emitUpdated();
                          }
                      }
                  }
              }
              int ChartDataSet::seriesCount(QAbstractSeries::SeriesType type)
              {
                  int count=0;
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  while (i.hasNext()) {
                      i.next();
                      if(i.key()->type()==type) count++;
                  }
                  return count;
              }
              int ChartDataSet::seriesIndex(QAbstractSeries *series)
              {
                  QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                  while (i.hasNext()) {
                      i.next();
                      if (i.value() == series)
                          return i.key();
                  }
                  return -1;
              }
              QAbstractAxis* ChartDataSet::axisX(QAbstractSeries *series) const
              {
                  if(series == 0) {
                      QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisXMap);
                      while (i.hasNext()) {
                          i.next();
                          if(i.value()->isVisible()) return i.value();
                      }
                      return 0;
                  }
                  return m_seriesAxisXMap.value(series);
              }
              QAbstractAxis* ChartDataSet::axisY(QAbstractSeries *series) const
              {
                  if(series == 0) {
                      QMapIterator<QAbstractSeries*, QAbstractAxis *> i(m_seriesAxisYMap);
                      while (i.hasNext()) {
                          i.next();
                          if(i.value()->isVisible()) return i.value();
                      }
                      return 0;
                  }
                  return m_seriesAxisYMap.value(series);
              }
              void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation)
              {
                  Q_ASSERT(axis);
                  if(!series) {
                      qWarning() << "Series not found on the chart.";
                      return;
                  }
                  Domain* domain = m_seriesDomainMap.value(series);
                  if(!domain) {
                      qWarning() << "Series not found on the chart.";
                      return;
                  }
                  if(orientation==Qt::Horizontal && axis->orientation()==Qt::Vertical) {
                      qWarning()<<"Axis already defined as axis Y";
                      return;
                  }
                  if(orientation==Qt::Vertical && axis->orientation()==Qt::Horizontal) {
                      qWarning()<<"Axis already defined as axis X";
                      return;
                  }
                  axis->d_ptr->setOrientation(orientation);
                  QMap<QAbstractSeries*, QAbstractAxis*> *seriesAxisMap;
                  if(orientation==Qt::Vertical) {
                      seriesAxisMap= &m_seriesAxisYMap;
                  }else{
                      seriesAxisMap= &m_seriesAxisXMap;
                  }
                  if (seriesAxisMap->value(series) == axis) {
                      qWarning() << "The axis already set for the series";
                      return;
                  }
                  QAbstractAxis *oldAxis = seriesAxisMap->take(series);
                  QList<QAbstractAxis*> axes = seriesAxisMap->values();
                  if(oldAxis) {
                      if(axes.indexOf(oldAxis)==-1) {
                          emit axisRemoved(oldAxis);
                          oldAxis->disconnect();
                          QObject::disconnect(domain,0,oldAxis,0);
                          oldAxis->d_ptr->m_dataset=0;
                          oldAxis->deleteLater();
                      }
                  }
                  if(axes.indexOf(axis)==-1) {
                      initializeAxis(axis,series);
                      emit axisAdded(axis,domain);
                  }else{
                      initializeAxis(axis,series);
                  }
              }
              Domain* ChartDataSet::domain(QAbstractSeries *series) const
              {
                  return m_seriesDomainMap.value(series);
              }
              void ChartDataSet::scrollDomain(qreal dx,qreal dy,const QSizeF& size)
              {
                  blockAxisSignals(true);
                  QMapIterator<QAbstractSeries*, Domain*> i(m_seriesDomainMap);
                  while (i.hasNext()) {
                      i.next();
                      i.value()->move(dx,dy,size);
                  }
                  blockAxisSignals(false);
              }
              QList<QAbstractSeries*> ChartDataSet::series() const
              {
                  return m_seriesDomainMap.keys();
              }
+             /*
              void ChartDataSet::updateSeries(QAbstractSeries *series)
-             {
                  emit seriesUpdated(series);
-             }
+             */
              #include "moc_chartdataset_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +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$
              **
              ****************************************************************************/
              //  W A R N I N G
              //  -------------
              //
              // This file is not part of the QtCommercial Chart API.  It exists purely as an
              // implementation detail.  This header file may change from version to
              // version without notice, or even be removed.
              //
              // We mean it.
              #ifndef CHARTDATASET_P_H
              #define CHARTDATASET_P_H
              #include "qabstractseries.h"
              #include "domain_p.h"
              #include "qabstractaxis_p.h"
              #include <QVector>
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class QAbstractAxis;
              class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
              {
                  Q_OBJECT
              public:
                  ChartDataSet(QChart* parent=0);
                  virtual ~ChartDataSet();
                  void addSeries(QAbstractSeries* series);
                  void removeSeries(QAbstractSeries* series);
                  void removeAllSeries();
-                 void updateSeries(QAbstractSeries* series);
+             //    void updateSeries(QAbstractSeries* series);
                  void zoomInDomain(const QRectF& rect, const QSizeF& size);
                  void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                  void scrollDomain(qreal dx,qreal dy,const QSizeF& size);
                  int seriesCount(QAbstractSeries::SeriesType type);
                  int seriesIndex(QAbstractSeries *series);
                  QAbstractAxis* axisX(QAbstractSeries *series) const;
                  QAbstractAxis* axisY(QAbstractSeries *series) const;
                  void setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Orientation orientation);
                  QList<QAbstractSeries*> series() const;
                  Domain* domain(QAbstractSeries *series) const;
                  void removeAxis(QAbstractAxis* axis);
                  void createDefaultAxes();
              Q_SIGNALS:
                  void seriesAdded(QAbstractSeries* series, Domain* domain);
                  void seriesRemoved(QAbstractSeries* series);
-                 void seriesUpdated(QAbstractSeries* series);
+             //    void seriesUpdated(QAbstractSeries* series);
                  void axisAdded(QAbstractAxis* axis,Domain* domain);
                  void axisRemoved(QAbstractAxis* axis);
              private:
                  void calculateDomain(QAbstractSeries* series,Domain* domain);
                  void createAxes(QAbstractAxis::AxisTypes type,Qt::Orientation orientation);
                  QAbstractAxis* createAxis(QAbstractAxis::AxisType type,Qt::Orientation orientation);
                  void initializeAxis(QAbstractAxis* axis,QAbstractSeries* series);
                  void removeAxes(QAbstractSeries* series);
                  void blockAxisSignals(bool enabled);
                  void createSeriesIndex(QAbstractSeries* series);
                  void removeSeriesIndex(QAbstractSeries* series);
              private:
                  QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisXMap;
                  QMap<QAbstractSeries*, QAbstractAxis*> m_seriesAxisYMap;
                  QMap<QAbstractSeries*, Domain*> m_seriesDomainMap;
                  QMap<int, QAbstractSeries*> m_indexSeriesMap;
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif /* CHARTENGINE_P_H */

src/legend/qlegend.cpp +14 -32

              /****************************************************************************
               **
               ** 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 "legendmarker_p.h"
              #include "qxyseries.h"
              #include "qlineseries.h"
              #include "qareaseries.h"
              #include "qscatterseries.h"
              #include "qsplineseries.h"
              #include "qabstractbarseries.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 <QGraphicsLayout>
              #include <QGraphicsSceneEvent>
              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
              */
              /*!
                  \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 color 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*,Domain*)));
                  QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
-                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
+             //    QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(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 (LegendMarker *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 (LegendMarker *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;
                      updateGeometry();
                      if(isAttachedToChart()){
                          d_ptr->m_presenter->layout()->invalidate();
                      }else{
                          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;
                  d_ptr->m_layout->invalidate();
                  setParent(0);
              }
              /*!
               Attaches the legend to chart. Chart may change layout of the legend.
               */
              void QLegend::attachToChart()
              {
                  d_ptr->m_attachedToChart = true;
                  d_ptr->m_presenter->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;
              }
              /*!
               \internal \a event see QGraphicsWidget for details
               */
              void QLegend::hideEvent(QHideEvent *event)
              {
                 d_ptr->m_presenter->layout()->invalidate();
                 QGraphicsWidget::hideEvent(event);
              }
              /*!
               \internal \a event see QGraphicsWidget for details
               */
              void QLegend::showEvent(QShowEvent *event)
              {
                 QGraphicsWidget::showEvent(event);
                 d_ptr->m_presenter->layout()->invalidate();
                 d_ptr->items()->setVisible(false);
                 //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)
              {
              }
              QLegendPrivate::~QLegendPrivate()
              {
              }
              void QLegendPrivate::setOffset(qreal x, qreal y)
              {
                 m_layout->setOffset(x,y);
              }
              QPointF QLegendPrivate::offset() const
              {
                  return m_layout->offset();
              }
              int QLegendPrivate::roundness(qreal size)
              {
                  return 100*m_diameter/int(size);
              }
              void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
              {
                  Q_UNUSED(domain)
                  QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
-                 foreach(LegendMarker* marker, markers) {
+                 foreach (LegendMarker* marker, markers) {
                      marker->setFont(m_font);
                      marker->setLabelBrush(m_labelBrush);
                      marker->setVisible(series->isVisible());
                      m_items->addToGroup(marker);
                      m_markers<<marker;
                  }
                  QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
-                 if(series->type() == QAbstractSeries::SeriesTypePie) {
-                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
-                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
+                 }
+                 QObject::connect(series->d_ptr.data(), SIGNAL(legendPropertiesUpdated(QAbstractSeries*)), this, SLOT(handleLegendPropertiesUpdated(QAbstractSeries*)));
                  q_ptr->layout()->invalidate();
                  q_ptr->layout()->activate();
              }
              void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
              {
                  foreach (LegendMarker *marker, m_markers) {
                      if (marker->series() == series) {
                          delete marker;
                          m_markers.removeAll(marker);
                      }
                  }
-                 if(series->type() == QAbstractSeries::SeriesTypePie)
+                 {
-                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
-                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
-                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
+                 }
+                 QObject::disconnect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
+                 QObject::disconnect(series->d_ptr.data(), SIGNAL(legendPropertiesUpdated(QAbstractSeries*)), this, SLOT(handleLegendPropertiesUpdated(QAbstractSeries*)));
                  q_ptr->layout()->invalidate();
              }
-             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
+             {
-                 // TODO: find out which markers are are added or removed. Update them
-                 // TODO: better implementation
-                 handleSeriesRemoved(series);
-                 Domain domain;
-                 handleSeriesAdded(series, &domain);
+             }
-             void QLegendPrivate::handleUpdatePieSeries()
+             {
-                 //TODO: reimplement to be optimal
-                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
-                 Q_ASSERT(series);
-                 handleSeriesRemoved(series);
-                 handleSeriesAdded(series, 0);
+             }
              void QLegendPrivate::handleSeriesVisibleChanged()
              {
                  QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                  foreach (LegendMarker* marker, m_markers) {
                      if (marker->series() == series) {
                          marker->setVisible(series->isVisible());
                      }
                  }
                  q_ptr->layout()->invalidate();
              }
+             void QLegendPrivate::handleLegendPropertiesUpdated(QAbstractSeries *series)
+             {
+                 // Handle new or removed markers
+                 // Handle changes of marker pen/brush/label. every property that legend is interested
+                 handleSeriesRemoved(series);
+                 Domain domain;
+                 handleSeriesAdded(series, &domain);
+             }
              #include "moc_qlegend.cpp"
              #include "moc_qlegend_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/legend/qlegend_p.h +1 -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$
              **
              ****************************************************************************/
              //  W A R N I N G
              //  -------------
              //
              // This file is not part of the QtCommercial Chart API.  It exists purely as an
              // implementation detail.  This header file may change from version to
              // version without notice, or even be removed.
              //
              // We mean it.
              #ifndef QLEGEND_P_H
              #define QLEGEND_P_H
              #include "qlegend.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class QChart;
              class ChartPresenter;
              class QAbstractSeries;
              class LegendLayout;
              class LegendMarker;
              class Domain;
              class QLegendPrivate : public QObject
              {
                  Q_OBJECT
              public:
                  QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q);
                  ~QLegendPrivate();
                  void setOffset(qreal x, qreal y);
                  QPointF offset() const;
                  int roundness(qreal size);
                  QList<LegendMarker*> markers() { return m_markers; }
                  QGraphicsItemGroup* items() { return m_items; }
              public Q_SLOTS:
                  void handleSeriesAdded(QAbstractSeries *series, Domain *domain);
                  void handleSeriesRemoved(QAbstractSeries *series);
-                 void handleSeriesUpdated(QAbstractSeries *series);
-                 void handleUpdatePieSeries(); //TODO remove this function
                  void handleSeriesVisibleChanged();
+                 void handleLegendPropertiesUpdated(QAbstractSeries *series);
              private:
                  QLegend *q_ptr;
                  ChartPresenter *m_presenter;
                  LegendLayout *m_layout;
                  QChart* m_chart;
                  QGraphicsItemGroup* m_items;
                  QList<LegendMarker*> m_markers;
                  Qt::Alignment m_alignment;
                  QBrush m_brush;
                  QPen m_pen;
                  QFont m_font;
                  QBrush m_labelBrush;
                  qreal m_diameter;
                  bool m_attachedToChart;
                  bool m_backgroundVisible;
              friend class QLegend;
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif

src/piechart/qpieseries.cpp +21 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 "qpieseries.h"
              #include "qpieseries_p.h"
              #include "qpieslice.h"
              #include "qpieslice_p.h"
              #include "pieslicedata_p.h"
              #include "chartdataset_p.h"
              #include "charttheme_p.h"
              #include "legendmarker_p.h"
              #include "qabstractaxis.h"
              #include "pieanimation_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              /*!
                  \class QPieSeries
                  \brief Pie series API for QtCommercial Charts
                  The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                  The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                  The actual slice size is determined by that relative value.
                  Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                  These relate to the actual chart rectangle.
                  By default the pie is defined as a full pie but it can also be a partial pie.
                  This can be done by setting a starting angle and angle span to the series.
                  Full pie is 360 degrees where 0 is at 12 a'clock.
                  See the \l {PieChart Example} {pie chart example} or \l {DonutChart Example} {donut chart example} to learn how to use QPieSeries.
                  \table 100%
                  \row
                  \o \image examples_piechart.png
                  \o \image examples_donut.png
                  \endtable
              */
              /*!
                  \qmlclass PieSeries QPieSeries
                  \inherits AbstractSeries
                  The following QML shows how to create a simple pie chart.
                  \snippet ../demos/qmlchart/qml/qmlchart/View1.qml 1
                  \beginfloatleft
                  \image demos_qmlchart1.png
                  \endfloat
                  \clearfloat
              */
              /*!
                  \property QPieSeries::horizontalPosition
                  \brief Defines the horizontal position of the pie.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the absolute left.
                  \o 1.0 is the absolute right.
                  \endlist
                  Default value is 0.5 (center).
                  \sa verticalPosition
              */
              /*!
                  \qmlproperty real PieSeries::horizontalPosition
                  Defines the horizontal position of the pie.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the absolute left.
                  \o 1.0 is the absolute right.
                  \endlist
                  Default value is 0.5 (center).
                  \sa verticalPosition
              */
              /*!
                  \property QPieSeries::verticalPosition
                  \brief Defines the vertical position of the pie.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the absolute top.
                  \o 1.0 is the absolute bottom.
                  \endlist
                  Default value is 0.5 (center).
                  \sa horizontalPosition
              */
              /*!
                  \qmlproperty real PieSeries::verticalPosition
                  Defines the vertical position of the pie.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the absolute top.
                  \o 1.0 is the absolute bottom.
                  \endlist
                  Default value is 0.5 (center).
                  \sa horizontalPosition
              */
              /*!
                  \property QPieSeries::size
                  \brief Defines the pie size.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the minimum size (pie not drawn).
                  \o 1.0 is the maximum size that can fit the chart.
                  \endlist
                  When setting this property the holeSize property is adjusted if necessary, to ensure that the hole size is not greater than the outer size.
                  Default value is 0.7.
              */
              /*!
                  \qmlproperty real PieSeries::size
                  Defines the pie size.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the minimum size (pie not drawn).
                  \o 1.0 is the maximum size that can fit the chart.
                  \endlist
                  Default value is 0.7.
              */
              /*!
                  \property QPieSeries::holeSize
                  \brief Defines the donut hole size.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the minimum size (full pie drawn, without any hole inside).
                  \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                  \endlist
                  The value is never greater then size property.
                  Default value is 0.0.
              */
              /*!
                  \qmlproperty real PieSeries::holeSize
                  Defines the donut hole size.
                  The value is a relative value to the chart rectangle where:
                  \list
                  \o 0.0 is the minimum size (full pie drawn, without any hole inside).
                  \o 1.0 is the maximum size that can fit the chart. (donut has no width)
                  \endlist
                  When setting this property the size property is adjusted if necessary, to ensure that the inner size is not greater than the outer size.
                  Default value is 0.0.
              */
              /*!
                  \property QPieSeries::startAngle
                  \brief Defines the starting angle of the pie.
                  Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                  Default is value is 0.
              */
              /*!
                  \qmlproperty real PieSeries::startAngle
                  Defines the starting angle of the pie.
                  Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                  Default is value is 0.
              */
              /*!
                  \property QPieSeries::endAngle
                  \brief Defines the ending angle of the pie.
                  Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                  Default is value is 360.
              */
              /*!
                  \qmlproperty real PieSeries::endAngle
                  Defines the ending angle of the pie.
                  Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                  Default is value is 360.
              */
              /*!
                  \property QPieSeries::count
                  Number of slices in the series.
              */
              /*!
                  \qmlproperty int PieSeries::count
                  Number of slices in the series.
              */
              /*!
                  \fn void QPieSeries::countChanged()
                  Emitted when the slice count has changed.
                  \sa count
              */
              /*!
                  \qmlsignal PieSeries::onCountChanged()
                  Emitted when the slice count has changed.
              */
              /*!
                  \property QPieSeries::sum
                  Sum of all slices.
                  The series keeps track of the sum of all slices it holds.
              */
              /*!
                  \qmlproperty real PieSeries::sum
                  Sum of all slices.
                  The series keeps track of the sum of all slices it holds.
              */
              /*!
                  \fn void QPieSeries::sumChanged()
                  Emitted when the sum of all slices has changed.
                  \sa sum
              */
              /*!
                  \qmlsignal PieSeries::onSumChanged()
                  Emitted when the sum of all slices has changed. This may happen for example if you add or remove slices, or if you
                  change value of a slice.
              */
              /*!
                  \fn void QPieSeries::added(QList<QPieSlice*> slices)
                  This signal is emitted when \a slices have been added to the series.
                  \sa append(), insert()
              */
              /*!
                  \qmlsignal PieSeries::onAdded(PieSlice slice)
                  Emitted when \a slice has been added to the series.
              */
              /*!
                  \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                  This signal is emitted when \a slices have been removed from the series.
                  \sa remove()
              */
              /*!
                  \qmlsignal PieSeries::onRemoved(PieSlice slice)
                  Emitted when \a slice has been removed from the series.
              */
              /*!
                  \fn void QPieSeries::clicked(QPieSlice* slice)
                  This signal is emitted when a \a slice has been clicked.
                  \sa QPieSlice::clicked()
              */
              /*!
                \qmlsignal PieSeries::onClicked(PieSlice slice)
                This signal is emitted when a \a slice has been clicked.
              */
              /*!
                  \fn void QPieSeries::hovered(QPieSlice* slice, bool state)
                  This signal is emitted when user has hovered over or away from the \a slice.
                  \a state is true when user has hovered over the slice and false when hover has moved away from the slice.
                  \sa QPieSlice::hovered()
              */
              /*!
                  \qmlsignal PieSeries::onHovered(PieSlice slice, bool state)
                  This signal is emitted when user has hovered over or away from the \a slice. \a state is true when user has hovered
                  over the slice and false when hover has moved away from the slice.
              */
              /*!
                  \qmlmethod PieSlice PieSeries::at(int index)
                  Returns slice at \a index. Returns null if the index is not valid.
              */
              /*!
                  \qmlmethod PieSlice PieSeries::find(string label)
                  Returns the first slice with \a label. Returns null if the index is not valid.
              */
              /*!
                  \qmlmethod PieSlice PieSeries::append(string label, real value)
                  Adds a new slice with \a label and \a value to the pie.
              */
              /*!
                  \qmlmethod bool PieSeries::remove(PieSlice slice)
                  Removes the \a slice from the pie. Returns true if the removal was successful, false otherwise.
              */
              /*!
                  \qmlmethod PieSeries::clear()
                  Removes all slices from the pie.
              */
              /*!
                  Constructs a series object which is a child of \a parent.
              */
              QPieSeries::QPieSeries(QObject *parent) :
                  QAbstractSeries(*new QPieSeriesPrivate(this),parent)
              {
              }
              /*!
                  Destroys the series and its slices.
              */
              QPieSeries::~QPieSeries()
              {
                  // NOTE: d_prt destroyed by QObject
              }
              /*!
                  Returns QChartSeries::SeriesTypePie.
              */
              QAbstractSeries::SeriesType QPieSeries::type() const
              {
                  return QAbstractSeries::SeriesTypePie;
              }
              /*!
                  Appends a single \a slice to the series.
                  Slice ownership is passed to the series.
                  Returns true if append was succesfull.
              */
              bool QPieSeries::append(QPieSlice* slice)
              {
                  return append(QList<QPieSlice*>() << slice);
              }
              /*!
                  Appends an array of \a slices to the series.
                  Slice ownership is passed to the series.
                  Returns true if append was successful.
              */
              bool QPieSeries::append(QList<QPieSlice*> slices)
              {
                  Q_D(QPieSeries);
                  if (slices.count() == 0)
                      return false;
                  foreach (QPieSlice* s, slices) {
                      if (!s || d->m_slices.contains(s))
                          return false;
                      if (s->series()) // already added to some series
                          return false;
                  }
                  foreach (QPieSlice* s, slices) {
                      s->setParent(this);
                      QPieSlicePrivate::fromSlice(s)->m_series = this;
                      d->m_slices << s;
                  }
                  d->updateDerivativeData();
                  foreach (QPieSlice* s, slices) {
                      connect(s, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                      connect(s, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                      connect(s, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
+                     connect(s, SIGNAL(labelChanged()), d, SLOT(updateLegendProperties()));
+                     connect(s, SIGNAL(penChanged()), d, SLOT(updateLegendProperties()));
+                     connect(s, SIGNAL(brushChanged()), d, SLOT(updateLegendProperties()));
+                     connect(s, SIGNAL(labelBrushChanged()), d, SLOT(updateLegendProperties()));
+                     connect(s, SIGNAL(labelFontChanged()), d, SLOT(updateLegendProperties()));
+                     connect(s, SIGNAL(labelFontChanged()), d, SLOT(updateLegendProperties()));
                  }
                  emit added(slices);
                  emit countChanged();
                  return true;
              }
              /*!
                  Appends a single \a slice to the series and returns a reference to the series.
                  Slice ownership is passed to the series.
              */
              QPieSeries& QPieSeries::operator << (QPieSlice* slice)
              {
                  append(slice);
                  return *this;
              }
              /*!
                  Appends a single slice to the series with give \a value and \a label.
                  Slice ownership is passed to the series.
              */
              QPieSlice* QPieSeries::append(QString label, qreal value)
              {
                  QPieSlice* slice = new QPieSlice(label, value);
                  append(slice);
                  return slice;
              }
              /*!
                  Inserts a single \a slice to the series before the slice at \a index position.
                  Slice ownership is passed to the series.
                  Returns true if insert was successful.
              */
              bool QPieSeries::insert(int index, QPieSlice* slice)
              {
                  Q_D(QPieSeries);
                  if (index < 0 || index > d->m_slices.count())
                      return false;
                  if (!slice || d->m_slices.contains(slice))
                      return false;
                  if (slice->series()) // already added to some series
                      return false;
                  slice->setParent(this);
                  QPieSlicePrivate::fromSlice(slice)->m_series = this;
                  d->m_slices.insert(index, slice);
                  d->updateDerivativeData();
                  connect(slice, SIGNAL(valueChanged()), d, SLOT(sliceValueChanged()));
                  connect(slice, SIGNAL(clicked()), d, SLOT(sliceClicked()));
                  connect(slice, SIGNAL(hovered(bool)), d, SLOT(sliceHovered(bool)));
+                 connect(slice, SIGNAL(labelChanged()), d, SLOT(updateLegendProperties()));
+                 connect(slice, SIGNAL(penChanged()), d, SLOT(updateLegendProperties()));
+                 connect(slice, SIGNAL(brushChanged()), d, SLOT(updateLegendProperties()));
+                 connect(slice, SIGNAL(labelBrushChanged()), d, SLOT(updateLegendProperties()));
+                 connect(slice, SIGNAL(labelFontChanged()), d, SLOT(updateLegendProperties()));
+                 connect(slice, SIGNAL(labelFontChanged()), d, SLOT(updateLegendProperties()));
                  emit added(QList<QPieSlice*>() << slice);
                  emit countChanged();
                  return true;
              }
              /*!
                  Removes a single \a slice from the series and deletes the slice.
                  Do not reference the pointer after this call.
                  Returns true if remove was successful.
              */
              bool QPieSeries::remove(QPieSlice* slice)
              {
                  Q_D(QPieSeries);
                  if (!d->m_slices.removeOne(slice))
                      return false;
                  d->updateDerivativeData();
                  emit removed(QList<QPieSlice*>() << slice);
                  emit countChanged();
                  delete slice;
                  slice = 0;
                  return true;
              }
              /*!
                  Takes a single \a slice from the series. Does not destroy the slice object.
                  NOTE: The series remains as the slice's parent object. You must set the
                  parent object to take full ownership.
                  Returns true if take was successful.
              */
              bool QPieSeries::take(QPieSlice* slice)
              {
                  Q_D(QPieSeries);
                  if (!d->m_slices.removeOne(slice))
                      return false;
                  QPieSlicePrivate::fromSlice(slice)->m_series = 0;
                  d->updateDerivativeData();
                  emit removed(QList<QPieSlice*>() << slice);
                  emit countChanged();
                  return true;
              }
              /*!
                  Clears all slices from the series.
              */
              void QPieSeries::clear()
              {
                  Q_D(QPieSeries);
                  if (d->m_slices.count() == 0)
                      return;
                  QList<QPieSlice*> slices = d->m_slices;
                  foreach (QPieSlice* s, d->m_slices) {
                      d->m_slices.removeOne(s);
                      delete s;
                  }
                  d->updateDerivativeData();
                  emit removed(slices);
                  emit countChanged();
              }
              /*!
                  Returns a list of slices that belong to this series.
              */
              QList<QPieSlice*> QPieSeries::slices() const
              {
                  Q_D(const QPieSeries);
                  return d->m_slices;
              }
              /*!
                  returns the number of the slices in this series.
              */
              int QPieSeries::count() const
              {
                  Q_D(const QPieSeries);
                  return d->m_slices.count();
              }
              /*!
                  Returns true is the series is empty.
              */
              bool QPieSeries::isEmpty() const
              {
                  Q_D(const QPieSeries);
                  return d->m_slices.isEmpty();
              }
              /*!
                  Returns the sum of all slice values in this series.
                  \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
              */
              qreal QPieSeries::sum() const
              {
                  Q_D(const QPieSeries);
                  return d->m_sum;
              }
              void QPieSeries::setHoleSize(qreal holeSize)
              {
                  Q_D(QPieSeries);
                  holeSize = qBound((qreal)0.0, holeSize, (qreal)1.0);
                  d->setSizes(holeSize, qMax(d->m_pieRelativeSize, holeSize));
              }
              qreal QPieSeries::holeSize() const
              {
                  Q_D(const QPieSeries);
                  return d->m_holeRelativeSize;
              }
              void QPieSeries::setHorizontalPosition(qreal relativePosition)
              {
                  Q_D(QPieSeries);
                  if (relativePosition < 0.0)
                      relativePosition = 0.0;
                  if (relativePosition > 1.0)
                      relativePosition = 1.0;
                  if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
                      d->m_pieRelativeHorPos = relativePosition;
                      emit d->horizontalPositionChanged();
                  }
              }
              qreal QPieSeries::horizontalPosition() const
              {
                  Q_D(const QPieSeries);
                  return d->m_pieRelativeHorPos;
              }
              void QPieSeries::setVerticalPosition(qreal relativePosition)
              {
                  Q_D(QPieSeries);
                  if (relativePosition < 0.0)
                      relativePosition = 0.0;
                  if (relativePosition > 1.0)
                      relativePosition = 1.0;
                  if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
                      d->m_pieRelativeVerPos = relativePosition;
                      emit d->verticalPositionChanged();
                  }
              }
              qreal QPieSeries::verticalPosition() const
              {
                  Q_D(const QPieSeries);
                  return d->m_pieRelativeVerPos;
              }
              void QPieSeries::setPieSize(qreal relativeSize)
              {
                  Q_D(QPieSeries);
                  relativeSize = qBound((qreal)0.0, relativeSize, (qreal)1.0);
                  d->setSizes(qMin(d->m_holeRelativeSize, relativeSize), relativeSize);
              }
              qreal QPieSeries::pieSize() const
              {
                  Q_D(const QPieSeries);
                  return d->m_pieRelativeSize;
              }
              void QPieSeries::setPieStartAngle(qreal angle)
              {
                  Q_D(QPieSeries);
                  if (qFuzzyIsNull(d->m_pieStartAngle - angle))
                      return;
                  d->m_pieStartAngle = angle;
                  d->updateDerivativeData();
                  emit d->pieStartAngleChanged();
              }
              qreal QPieSeries::pieStartAngle() const
              {
                  Q_D(const QPieSeries);
                  return d->m_pieStartAngle;
              }
              /*!
                  Sets the end angle of the pie.
                  Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                  \a angle must be greater than start angle.
                  \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
              */
              void QPieSeries::setPieEndAngle(qreal angle)
              {
                  Q_D(QPieSeries);
                  if (qFuzzyIsNull(d->m_pieEndAngle - angle))
                      return;
                  d->m_pieEndAngle = angle;
                  d->updateDerivativeData();
                  emit d->pieEndAngleChanged();
              }
              /*!
                  Returns the end angle of the pie.
                  Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                  \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
              */
              qreal QPieSeries::pieEndAngle() const
              {
                  Q_D(const QPieSeries);
                  return d->m_pieEndAngle;
              }
              /*!
                  Sets the all the slice labels \a visible or invisible.
                  Note that this affects only the current slices in the series.
                  If user adds a new slice the default label visibility is false.
                  \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
              */
              void QPieSeries::setLabelsVisible(bool visible)
              {
                  Q_D(QPieSeries);
                  foreach (QPieSlice* s, d->m_slices)
                      s->setLabelVisible(visible);
              }
              /*!
                  Sets the all the slice labels \a position
                  Note that this affects only the current slices in the series.
                  If user adds a new slice the default label position is LabelOutside
                  \sa QPieSlice::labelPosition(), QPieSlice::setLabelPosition()
              */
              void QPieSeries::setLabelsPosition(QPieSlice::LabelPosition position)
              {
                  Q_D(QPieSeries);
                  foreach (QPieSlice* s, d->m_slices)
                      s->setLabelPosition(position);
              }
              ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
              QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                  QAbstractSeriesPrivate(parent),
                  m_pieRelativeHorPos(0.5),
                  m_pieRelativeVerPos(0.5),
                  m_pieRelativeSize(0.7),
                  m_pieStartAngle(0),
                  m_pieEndAngle(360),
                  m_sum(0),
                  m_holeRelativeSize(0.0)
              {
              }
              QPieSeriesPrivate::~QPieSeriesPrivate()
              {
              }
              void QPieSeriesPrivate::updateDerivativeData()
              {
                  // calculate sum of all slices
                  qreal sum = 0;
                  foreach (QPieSlice* s, m_slices)
                      sum += s->value();
                  if (!qFuzzyIsNull(m_sum - sum)) {
                      m_sum = sum;
                      emit q_func()->sumChanged();
                  }
                  // nothing to show..
                  if (qFuzzyIsNull(m_sum))
                      return;
                  // update slice attributes
                  qreal sliceAngle = m_pieStartAngle;
                  qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                  QVector<QPieSlice*> changed;
                  foreach (QPieSlice* s, m_slices) {
                      QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                      d->setPercentage(s->value() / m_sum);
                      d->setStartAngle(sliceAngle);
                      d->setAngleSpan(pieSpan * s->percentage());
                      sliceAngle += s->angleSpan();
                  }
                  emit calculatedDataChanged();
              }
              void QPieSeriesPrivate::setSizes(qreal innerSize, qreal outerSize)
              {
                  bool changed = false;
                  if (!qFuzzyIsNull(m_holeRelativeSize - innerSize)) {
                      m_holeRelativeSize = innerSize;
                      changed = true;
                  }
                  if (!qFuzzyIsNull(m_pieRelativeSize - outerSize)) {
                      m_pieRelativeSize = outerSize;
                      changed = true;
                  }
                  if (changed)
                      emit pieSizeChanged();
              }
              QPieSeriesPrivate* QPieSeriesPrivate::fromSeries(QPieSeries *series)
              {
                  return series->d_func();
              }
              void QPieSeriesPrivate::sliceValueChanged()
              {
                  Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                  updateDerivativeData();
              }
              void QPieSeriesPrivate::sliceClicked()
              {
                  QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                  Q_ASSERT(m_slices.contains(slice));
                  Q_Q(QPieSeries);
                  emit q->clicked(slice);
              }
              void QPieSeriesPrivate::sliceHovered(bool state)
              {
                  QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                  Q_ASSERT(m_slices.contains(slice));
                  Q_Q(QPieSeries);
                  emit q->hovered(slice, state);
              }
+             void QPieSeriesPrivate::updateLegendProperties()
+             {
+                 // This slot listens to all properties of slices, which may interest legend and signals it.
+                 Q_Q(QPieSeries);
+                 emit legendPropertiesUpdated(q);
+             }
              void QPieSeriesPrivate::scaleDomain(Domain& domain)
              {
                  Q_UNUSED(domain);
                  // does not apply to pie
              }
              ChartElement* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
              {
                  Q_Q(QPieSeries);
                  PieChartItem* pie = new PieChartItem(q,presenter);
                  if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                      pie->setAnimation(new PieAnimation(pie));
                  }
                  presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                  return pie;
              }
              QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
              {
                  Q_Q(QPieSeries);
                  QList<LegendMarker*> markers;
                  foreach(QPieSlice* slice, q->slices()) {
                      PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                      markers << marker;
                  }
                  return markers;
              }
              void QPieSeriesPrivate::initializeAxis(QAbstractAxis* axis)
              {
                  Q_UNUSED(axis);
              }
              QAbstractAxis::AxisType QPieSeriesPrivate::defaultAxisType(Qt::Orientation orientation) const
              {
                  Q_UNUSED(orientation);
                  return QAbstractAxis::AxisTypeNoAxis;
              }
              #include "moc_qpieseries.cpp"
              #include "moc_qpieseries_p.cpp"
              QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries_p.h +1 0

              /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
              //  W A R N I N G
              //  -------------
              //
              // This file is not part of the QtCommercial Chart API.  It exists purely as an
              // implementation detail.  This header file may change from version to
              // version without notice, or even be removed.
              //
              // We mean it.
              #ifndef QPIESERIES_P_H
              #define QPIESERIES_P_H
              #include "qpieseries.h"
              #include "qabstractseries_p.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class QLegendPrivate;
              class QPieSeriesPrivate : public QAbstractSeriesPrivate
              {
                  Q_OBJECT
              public:
                  QPieSeriesPrivate(QPieSeries *parent);
                  ~QPieSeriesPrivate();
                  void scaleDomain(Domain& domain);
                  ChartElement* createGraphics(ChartPresenter *presenter);
                  QList<LegendMarker*> createLegendMarker(QLegend *legend);
                  void initializeAxis(QAbstractAxis* axis);
                  QAbstractAxis::AxisType defaultAxisType(Qt::Orientation orientation) const;
                  void updateDerivativeData();
                  void setSizes(qreal innerSize, qreal outerSize);
                  static QPieSeriesPrivate* fromSeries(QPieSeries *series);
              signals:
                  void calculatedDataChanged();
                  void pieSizeChanged();
                  void pieStartAngleChanged();
                  void pieEndAngleChanged();
                  void horizontalPositionChanged();
                  void verticalPositionChanged();
              public Q_SLOTS:
                  void sliceValueChanged();
                  void sliceClicked();
                  void sliceHovered(bool state);
+                 void updateLegendProperties();
              private:
                  QList<QPieSlice*> m_slices;
                  qreal m_pieRelativeHorPos;
                  qreal m_pieRelativeVerPos;
                  qreal m_pieRelativeSize;
                  qreal m_pieStartAngle;
                  qreal m_pieEndAngle;
                  qreal m_sum;
                  qreal m_holeRelativeSize;
              private:
                  friend class QLegendPrivate;
                  Q_DECLARE_PUBLIC(QPieSeries)
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif // QPIESERIES_P_H

src/qabstractseries_p.h +3 0

              /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE$
              ** Licensees holding valid Qt Commercial licenses may use this file in
              ** accordance with the Qt Commercial License Agreement provided with the
              ** Software or, alternatively, in accordance with the terms contained in
              ** a written agreement between you and Digia.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.digia.com
              ** $QT_END_LICENSE$
              **
              ****************************************************************************/
              //  W A R N I N G
              //  -------------
              //
              // This file is not part of the QtCommercial Chart API.  It exists purely as an
              // implementation detail.  This header file may change from version to
              // version without notice, or even be removed.
              //
              // We mean it.
              #ifndef QABSTRACTSERIES_P_H
              #define QABSTRACTSERIES_P_H
              #include "qabstractseries.h"
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class Domain;
              class ChartPresenter;
              class ChartElement;
              class LegendMarker;
              class QLegend;
              class ChartDataSet;
              class QAbstractAxis;
              class QAbstractSeriesPrivate : public QObject
              {
                  Q_OBJECT
              public:
                  QAbstractSeriesPrivate(QAbstractSeries *q);
                  ~QAbstractSeriesPrivate();
                  virtual void scaleDomain(Domain& domain) = 0;
                  virtual ChartElement* createGraphics(ChartPresenter* presenter) = 0;
                  virtual QList<LegendMarker*> createLegendMarker(QLegend* legend) = 0;
                  virtual void initializeAxis(QAbstractAxis* axis) = 0;
                  virtual QAbstractAxis::AxisType defaultAxisType(Qt::Orientation) const = 0;
+             Q_SIGNALS:
+                 void legendPropertiesUpdated(QAbstractSeries* series);
              protected:
                  QAbstractSeries *q_ptr;
                  QChart *m_chart;
                  ChartDataSet *m_dataset;
                  QString m_name;
                  bool m_visible;
                  qreal m_opacity;
                  friend class QAbstractSeries;
                  friend class ChartDataSet;
              };
              QTCOMMERCIALCHART_END_NAMESPACE
              #endif

General Comments 0

Write
Preview

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

No TODOs yet

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

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