HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1535:954f1e6a64d9

Adds missing license headers

Michal Klocek -

r1535:954f1e6a64d9

parent child

Context file:

r1535:954f1e6a64d9

Collapse all files

src/chartlayout.cpp +21 -1

+            /****************************************************************************
+            **
+            ** Copyright (C) 2012 Digia Plc
+            ** All rights reserved.
+            ** For any questions to Digia, please use contact form at http://qt.digia.com
+            **
+            ** This file is part of the Qt Commercial Charts Add-on.
+            **
+            ** $QT_BEGIN_LICENSE$
+            ** Licensees holding valid Qt Commercial licenses may use this file in
+            ** accordance with the Qt Commercial License Agreement provided with the
+            ** Software or, alternatively, in accordance with the terms contained in
+            ** a written agreement between you and Digia.
+            **
+            ** If you have questions regarding the use of this file, please use
+            ** contact form at http://qt.digia.com
+            ** $QT_END_LICENSE$
+            **
+            ****************************************************************************/
             #include "chartlayout_p.h"
             #include "chartpresenter_p.h"
             #include "chartaxis_p.h"
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartLayout::ChartLayout(ChartPresenter* presenter):
             m_presenter(presenter),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QPointF(m_marginBig,m_marginBig),QPointF(m_marginBig,m_marginBig))
             {
             }
             ChartLayout::~ChartLayout()
             {
             }
             void ChartLayout::setGeometry(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 QGraphicsLayout::setGeometry(rect);
                 // check title size
                 QSize titleSize = QSize(0,0);
                 if (m_presenter->titleItem()) {
                     titleSize= m_presenter->titleItem()->boundingRect().size().toSize();
                 }
                 qreal axisHeight = 0;
                 qreal axisWidth = 0;
                 // check axis size
                 foreach (ChartAxis* axis,m_presenter->axisItems()){
                     if(axis->axisType() ==  ChartAxis::X_AXIS)
                     axisHeight = qMax(axis->minimumHeight(),axisHeight);
                     else
                     axisWidth = qMax(axis->minimumWidth(),axisWidth);
                 }
                 QLegend* legend = m_presenter->legend();
                 qreal titlePadding = m_chartMargins.top()/2;
                 QRectF chartMargins = m_chartMargins;
                 // recalculate legend position
                 if (legend != 0 && legend->isVisible() && legend->isAttachedToChart()) {
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case Qt::AlignTop: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
                         int topMargin = 2*m_marginTiny + titleSize.height() + legendSize.height() + m_marginTiny;
                         chartMargins = QRect(QPoint(m_chartMargins.left(),topMargin),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(chartMargins.left(),topMargin - (legendSize.height() + m_marginTiny)),QPoint(chartMargins.right(),rect.height()-topMargin + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case Qt::AlignBottom: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
                         int bottomMargin = m_marginTiny + m_marginSmall +  legendSize.height() + m_marginTiny + axisHeight;
                         chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomMargin));
                         m_legendMargins = QRect(QPoint(chartMargins.left(),rect.height()-bottomMargin + m_marginTiny + axisHeight),QPoint(chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     case Qt::AlignLeft: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
                         int leftPadding = m_marginTiny + m_marginSmall + legendSize.width() + m_marginTiny + axisWidth;
                         chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,chartMargins.top()),QPoint(rect.width()-leftPadding + m_marginTiny + axisWidth,chartMargins.bottom()));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     case Qt::AlignRight: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
                         int rightPadding = m_marginTiny + m_marginSmall + legendSize.width() + m_marginTiny;
                         chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(rect.width()- rightPadding+ m_marginTiny ,chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,chartMargins.bottom()));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                     legend->setGeometry(rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 }
                 // recalculate title position
                 if (m_presenter->titleItem()) {
                     QPointF center = rect.center() - m_presenter->titleItem()->boundingRect().center();
                     m_presenter->titleItem()->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_presenter->backgroundItem()) {
                     m_presenter->backgroundItem()->setRect(rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = rect.adjusted(chartMargins.left(),chartMargins.top(),-chartMargins.right(),-chartMargins.bottom());
                 if(m_presenter->geometry()!=chartRect && chartRect.isValid()){
                     m_presenter->setGeometry(chartRect);
                 }else if(chartRect.size().isEmpty()){
                     m_presenter->setGeometry(QRect(rect.width()/2,rect.height()/2,1,1));
                 }
             }
             QSizeF ChartLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
             {
                 Q_UNUSED(constraint);
                 if(which == Qt::MinimumSize)
                     return QSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                 else
                     return QSize(-1,-1);
             }
             void ChartLayout::setMarginsMinimum(const QRectF& margins)
             {
                 if(m_chartMargins != margins){
                     m_chartMargins = margins;
                     updateGeometry();
                 }
             }
             QRectF ChartLayout::margins() const
             {
                 return m_chartMargins;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout_p.h +20 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$
+            **
+            ****************************************************************************/
             #ifndef CHARTLAYOUT_H_
             #define CHARTLAYOUT_H_
             #include <QGraphicsLayout>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartLayout : public QGraphicsLayout
             {
             public:
                 ChartLayout(ChartPresenter* presenter);
                 virtual ~ChartLayout();
                 void setMarginsMinimum(const QRectF& margins);
                 QRectF margins() const;
                 void setGeometry(const QRectF& rect);
             protected:
                 QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
                 int count() const { return 0; }
                 QGraphicsLayoutItem* itemAt(int) const { return 0; };
                 void removeAt(int){};
             private:
                 ChartPresenter* m_presenter;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/legend/legendlayout.cpp +21 -1

+            /****************************************************************************
+            **
+            ** Copyright (C) 2012 Digia Plc
+            ** All rights reserved.
+            ** For any questions to Digia, please use contact form at http://qt.digia.com
+            **
+            ** This file is part of the Qt Commercial Charts Add-on.
+            **
+            ** $QT_BEGIN_LICENSE$
+            ** Licensees holding valid Qt Commercial licenses may use this file in
+            ** accordance with the Qt Commercial License Agreement provided with the
+            ** Software or, alternatively, in accordance with the terms contained in
+            ** a written agreement between you and Digia.
+            **
+            ** If you have questions regarding the use of this file, please use
+            ** contact form at http://qt.digia.com
+            ** $QT_END_LICENSE$
+            **
+            ****************************************************************************/
             #include "legendlayout_p.h"
             #include "chartpresenter_p.h"
             #include "legendmarker_p.h"
             #include "qlegend_p.h"
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendLayout::LegendLayout(QLegend* legend):
             m_legend(legend)
             {
             }
             LegendLayout::~LegendLayout()
             {
             }
             void LegendLayout::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch(m_legend->alignment()) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         scrollHorizontal = true;
                         break;
                     }
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         scrollHorizontal = false;
                         break;
                     }
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_legend->isAttachedToChart()) {
                     scrollHorizontal = !scrollHorizontal;
                 }
                 QRectF boundingRect = geometry();
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if(m_width<=boundingRect.width()) return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_legend->d_ptr->items()->setPos(-m_offsetX,boundingRect.top());
                     }
                 }
                 else {
                     if(m_height<=boundingRect.height()) return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_legend->d_ptr->items()->setPos(boundingRect.left(),-m_offsetY);
                     }
                 }
             }
             QPointF LegendLayout::offset() const
             {
                 return QPointF(m_offsetX,m_offsetY);
             }
             void LegendLayout::setGeometry(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 QGraphicsLayout::setGeometry(rect);
                 if(m_legend->isAttachedToChart()) {
                     setAttachedGeometry(rect);
                 }
                 else {
                     setDettachedGeometry(rect);
                 }
             }
             void LegendLayout::setAttachedGeometry(const QRectF& rect)
             {
                 m_offsetX=0;
                 m_offsetY=0;
                 QSizeF size(0,0);
                 if( m_legend->d_ptr->markers().isEmpty()) return;
                 m_width=0;
                 m_height=0;
                 switch(m_legend->alignment()) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom: {
                         QPointF point(0,0);
                         foreach (LegendMarker* marker, m_legend->d_ptr->markers()) {
                             if (marker->isVisible()) {
                                 marker->setGeometry(QRectF(QPoint(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
                                 marker->setPos(point.x(),rect.height()/2 - marker->boundingRect().height()/2);
                                 const QRectF& rect = marker->boundingRect();
                                 size = size.expandedTo(rect.size());
                                 qreal w = rect.width();
                                 m_width+=w;
                                 point.setX(point.x() + w);
                             }
                         }
                         if(m_width<rect.width()) {
                             m_legend->d_ptr->items()->setPos(rect.width()/2-m_width/2,rect.top());
                         }
                         else {
                             m_legend->d_ptr->items()->setPos(rect.topLeft());
                         }
                         m_height=size.height();
                     }
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight: {
                         QPointF point(0,0);
                         foreach (LegendMarker* marker, m_legend->d_ptr->markers()) {
                             if (marker->isVisible()) {
                                 marker->setGeometry(QRectF(QPoint(0,0),marker->effectiveSizeHint(Qt::PreferredSize)));
                                 marker->setPos(point);
                                 const QRectF& rect = marker->boundingRect();
                                 qreal h = rect.height();
                                 size = size.expandedTo(rect.size());
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
                         if(m_height<rect.height()) {
                             m_legend->d_ptr->items()->setPos(rect.left(),rect.height()/2-m_height/2);
                         }
                         else {
                             m_legend->d_ptr->items()->setPos(rect.topLeft());
                         }
                         m_width=size.width();
                     }
                     break;
                 }
                 m_minOffsetX = 0;
                 m_minOffsetY = 0;
                 m_maxOffsetX = m_width - rect.width();
                 m_maxOffsetY = m_height - rect.height();
             }
             void LegendLayout::setDettachedGeometry(const QRectF& rect)
             {
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 m_offsetX=0;
                 m_offsetY=0;
                 QSizeF size(0,0);
                 if( m_legend->d_ptr->markers().isEmpty()) return;
                 QList<QGraphicsItem *> items = m_legend->d_ptr->items()->childItems();
                 switch (m_legend->alignment()) {
                     case Qt::AlignTop: {
                         QPointF point = rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& boundingRect = item->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_width = qMax(m_width,w);
                                 m_height = qMax(m_height,h);
                                 item->setPos(point.x(),point.y());
                                 point.setX(point.x() + w);
                                 if (point.x() + w > rect.topLeft().x() + rect.width()) {
                                     // Next item would go off rect.
                                     point.setX(rect.topLeft().x());
                                     point.setY(point.y() + h);
                                     if (i+1 < items.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - rect.width();
                         m_maxOffsetY = m_height - rect.height();
                     }
                     break;
                     case Qt::AlignBottom: {
                         QPointF point = rect.bottomLeft();
                         m_width = 0;
                         m_height = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& boundingRect = item->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_width = qMax(m_width,w);
                                 m_height = qMax(m_height,h);
                                 item->setPos(point.x(),point.y() - h);
                                 point.setX(point.x() + w);
                                 if (point.x() + w > rect.bottomLeft().x() + rect.width()) {
                                     // Next item would go off rect.
                                     point.setX(rect.bottomLeft().x());
                                     point.setY(point.y() - h);
                                     if (i+1 < items.count()) {
                                         m_height += h;
                                     }
                                 }
                             }
                         }
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = 0;
                         m_minOffsetY = qMin(rect.topLeft().y(), rect.topLeft().y() - m_height + rect.height());
                         m_maxOffsetX = m_width - rect.width();
                         m_maxOffsetY = 0;
                     }
                     break;
                     case Qt::AlignLeft: {
                         QPointF point = rect.topLeft();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& boundingRect = item->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height,h);
                                 maxWidth = qMax(maxWidth,w);
                                 item->setPos(point.x(),point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > rect.topLeft().y() + rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() + maxWidth);
                                     point.setY(rect.topLeft().y());
                                     if (i+1 < items.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = 0;
                         m_minOffsetY = 0;
                         m_maxOffsetX = m_width - rect.width();
                         m_maxOffsetY = m_height - rect.height();
                     }
                     break;
                     case Qt::AlignRight: {
                         QPointF point = rect.topRight();
                         m_width = 0;
                         m_height = 0;
                         qreal maxWidth = 0;
                         for (int i=0; i<items.count(); i++) {
                             QGraphicsItem *item = items.at(i);
                             if (item->isVisible()) {
                                 const QRectF& boundingRect = item->boundingRect();
                                 qreal w = boundingRect.width();
                                 qreal h = boundingRect.height();
                                 m_height = qMax(m_height,h);
                                 maxWidth = qMax(maxWidth,w);
                                 item->setPos(point.x() - w,point.y());
                                 point.setY(point.y() + h);
                                 if (point.y() + h > rect.topLeft().y() + rect.height()) {
                                     // Next item would go off rect.
                                     point.setX(point.x() - maxWidth);
                                     point.setY(rect.topLeft().y());
                                     if (i+1 < items.count()) {
                                         m_width += maxWidth;
                                         maxWidth = 0;
                                     }
                                 }
                             }
                         }
                         m_width += maxWidth;
                         m_legend->d_ptr->items()->setPos(rect.topLeft());
                         m_minOffsetX = qMin(rect.topLeft().x(), rect.topLeft().x() - m_width + rect.width());
                         m_minOffsetY = 0;
                         m_maxOffsetX = 0;
                         m_maxOffsetY = m_height - rect.height();
                     }
                     break;
                     default:
                     break;
                 }
             }
             QSizeF LegendLayout::sizeHint ( Qt::SizeHint which, const QSizeF & constraint) const
             {
                 QSizeF size(0, 0);
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 if(constraint.isValid()) {
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         size = size.expandedTo(marker->effectiveSizeHint(which));
                     }
                     size = size.boundedTo(constraint);
                 }
                 else if (constraint.width() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         width+=marker->effectiveSizeHint(which).width();
                         height=qMax(height,marker->effectiveSizeHint(which).height());
                     }
                     size = QSizeF(qMin(constraint.width(),width), height);
                 }
                 else if (constraint.height() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         width=qMax(width,marker->effectiveSizeHint(which).width());
                         height+=height,marker->effectiveSizeHint(which).height();
                     }
                     size = QSizeF(width,qMin(constraint.height(),height));
                 }
                 else {
                     foreach(LegendMarker* marker, m_legend->d_ptr->markers()) {
                         size = size.expandedTo(marker->effectiveSizeHint(which));
                     }
                 }
                 size += QSize(left + right, top + bottom);
                 return size;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendlayout_p.h +20 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$
+            **
+            ****************************************************************************/
             #ifndef LEGENDLAYOUT_H_
             #define LEGENDLAYOUT_H_
             #include <QGraphicsLayout>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QLegend;
             class LegendLayout : public QGraphicsLayout
             {
             public:
                 LegendLayout(QLegend* legend);
                 virtual ~LegendLayout();
                 void setGeometry(const QRectF& rect);
                 void setOffset(qreal x, qreal y);
                 QPointF offset() const;
             protected:
                 QSizeF sizeHint ( Qt::SizeHint which, const QSizeF & constraint = QSizeF() ) const;
                 int count() const { return 0; }
                 QGraphicsLayoutItem* itemAt(int) const { return 0; };
                 void removeAt(int){};
             private:
                 void setAttachedGeometry(const QRectF& rect);
                 void setDettachedGeometry(const QRectF& rect);
             private:
                 QLegend* m_legend;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 qreal m_offsetX;
                 qreal m_offsetY;
                 qreal m_minOffsetX;
                 qreal m_minOffsetY;
                 qreal m_maxOffsetX;
                 qreal m_maxOffsetY;
                 qreal m_width;
                 qreal m_height;
             };
             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