Fixed bogus gitignore file

.gitignore

@@ -8,7 +8,6 @@ Info.plist
 obj
 *.log
 *~
-*qtc*
 bin/*.exe
 bin/*.txt
 bin/mac

src/Waypoint.cc

@@ -49,7 +49,8 @@ Waypoint::Waypoint(quint16 _id, double _x, double _y, double _z, double _param1,
       param1(_param1),
       param2(_param2),
       name(QString("WP%1").arg(id, 2, 10, QChar('0'))),
-      description(_description)
+      description(_description),
+      reachedTime(0)
 {
 }
 
@@ -79,7 +80,7 @@ void Waypoint::save(QTextStream &saveStream)
 bool Waypoint::load(QTextStream &loadStream)
 {
     const QStringList &wpParams = loadStream.readLine().split("\t");
-    if (wpParams.size() == 13) {
+    if (wpParams.size() == 12) {
         this->id = wpParams[0].toInt();
         this->current = (wpParams[1].toInt() == 1 ? true : false);
         this->frame = (MAV_FRAME) wpParams[2].toInt();

src/Waypoint.h

@@ -37,6 +37,7 @@ This file is part of the PIXHAWK project
 #include <QString>
 #include <QTextStream>
 #include "QGCMAVLink.h"
+#include "QGC.h"
 
 class Waypoint : public QObject
 {
@@ -145,6 +146,7 @@ protected:
     int turns;
     QString name;
     QString description;
+    quint64 reachedTime;
 
 public slots:
     void setId(quint16 id);
@@ -177,6 +179,12 @@ public slots:
     void setHoldTime(double holdTime);
     /** @brief Number of turns for loiter waypoints */
     void setTurns(int turns);
+    /** @brief Set waypoint as reached */
+    void setReached() { reachedTime = QGC::groundTimeMilliseconds(); }
+    /** @brief Wether this waypoint has been reached yet */
+    bool isReached() { return (reachedTime > 0); }
+    /** @brief Get the time this waypoint was reached */
+    quint64 getReachedTime() { return reachedTime; }
 
 signals:
     /** @brief Announces a change to the waypoint data */

src/libs/opmapcontrol/src/core/opmaps.h

@@ -78,7 +78,7 @@ namespace core {
         //  PureImageCache ImageCacheLocal;//TODO Criar acesso Get Set
         TileCacheQueue TileDBcacheQueue;
         OPMaps();
-        OPMaps(OPMaps const&){}
+        //OPMaps(OPMaps const&){}
         OPMaps& operator=(OPMaps const&){ return *this; }
         static OPMaps* m_pInstance;
         diagnostics diag;

src/libs/opmapcontrol/src/internals/core.cpp

@@ -33,8 +33,21 @@ qlonglong internals::Core::debugcounter=0;
 using namespace projections;
 
 namespace internals {
-    Core::Core():MouseWheelZooming(false),currentPosition(0,0),currentPositionPixel(0,0),LastLocationInBounds(-1,-1),sizeOfMapArea(0,0)
-            ,minOfTiles(0,0),maxOfTiles(0,0),zoom(0),isDragging(false),TooltipTextPadding(10,10),loaderLimit(5),maxzoom(21),started(false),runningThreads(0)
+    Core::Core() :
+    MouseWheelZooming(false),
+    currentPosition(0,0),
+    currentPositionPixel(0,0),
+    LastLocationInBounds(-1,-1),
+    sizeOfMapArea(0,0),
+    minOfTiles(0,0),
+    maxOfTiles(0,0),
+    zoom(0),
+    isDragging(false),
+    TooltipTextPadding(10,10),
+    loaderLimit(5),
+    maxzoom(21),
+    runningThreads(0),
+    started(false)
     {
         mousewheelzoomtype=MouseWheelZoomType::MousePositionAndCenter;
         SetProjection(new MercatorProjection());

src/libs/opmapcontrol/src/mapwidget/mapgraphicitem.h

@@ -169,6 +169,7 @@ namespace mapcontrol
         internals::PointLatLng selectionStart;
         internals::PointLatLng selectionEnd;
         double zoomReal;
+        qreal rotation;
         double zoomDigi;
         QRectF maprect;
         bool isSelected;
@@ -176,7 +177,7 @@ namespace mapcontrol
         QPixmap dragons;
         void SetIsMouseOverMarker(bool const& value){isMouseOverMarker = value;}
 
-        qreal rotation;
+
         /**
         * @brief Creates a rectangle that represents the "view" of the cuurent map, to compensate
         *       rotation

src/libs/opmapcontrol/src/mapwidget/opmapwidget.h

@@ -391,8 +391,9 @@ namespace mapcontrol
         bool showuav;
         bool showhome;
         QTimer * diagTimer;
-        QGraphicsTextItem * diagGraphItem;
         bool showDiag;
+        QGraphicsTextItem * diagGraphItem;
+
     private slots:
         void diagRefresh();
         //   WayPointItem* item;//apagar

src/libs/opmapcontrol/src/mapwidget/waypointitem.cpp

@@ -27,7 +27,7 @@
 #include "waypointitem.h"
 namespace mapcontrol
 {
-    WayPointItem::WayPointItem(const internals::PointLatLng &coord,double const& altitude, MapGraphicItem *map):coord(coord),reached(false),description(""),shownumber(true),isDragging(false),altitude(altitude),heading(0),map(map)
+    WayPointItem::WayPointItem(const internals::PointLatLng &coord,double const& altitude, MapGraphicItem *map):coord(coord),reached(false),description(""),shownumber(true),isDragging(false),altitude(altitude),heading(0),map(map),autoreachedEnabled(true)
     {
         text=0;
         numberI=0;
@@ -169,28 +169,53 @@ namespace mapcontrol
     }
     void WayPointItem::SetReached(const bool &value)
     {
-        reached=value;
-        emit WPValuesChanged(this);
-        if(value)
-            picture.load(QString::fromUtf8(":/markers/images/bigMarkerGreen.png"));
-        else
-            picture.load(QString::fromUtf8(":/markers/images/marker.png"));
-        this->update();
-
+        if (autoreachedEnabled)
+        {
+            reached=value;
+            emit WPValuesChanged(this);
+            if(value)
+                picture.load(QString::fromUtf8(":/markers/images/bigMarkerGreen.png"));
+            else
+                picture.load(QString::fromUtf8(":/markers/images/marker.png"));
+            this->update();
+        }
     }
     void WayPointItem::SetShowNumber(const bool &value)
     {
+//        shownumber=value;
+//        if((numberI==0) && value)
+//        {
+//            numberI=new QGraphicsSimpleTextItem(this);
+//            numberIBG=new QGraphicsRectItem(this);
+//            numberIBG->setBrush(Qt::white);
+//            numberIBG->setOpacity(0.5);
+//            numberI->setZValue(3);
+//            numberI->setPen(QPen(Qt::blue));
+//            numberI->setPos(0,-13-picture.height());
+//            numberIBG->setPos(0,-13-picture.height());
+//            numberI->setText(QString::number(number));
+//            numberIBG->setRect(numberI->boundingRect().adjusted(-2,0,1,0));
+//        }
+//        else if (!value && numberI)
+//        {
+//            delete numberI;
+//            delete numberIBG;
+//        }
+//        this->update();
+
+
+
         shownumber=value;
         if((numberI==0) && value)
         {
             numberI=new QGraphicsSimpleTextItem(this);
             numberIBG=new QGraphicsRectItem(this);
-            numberIBG->setBrush(Qt::white);
+            numberIBG->setBrush(Qt::black);
             numberIBG->setOpacity(0.5);
             numberI->setZValue(3);
-            numberI->setPen(QPen(Qt::blue));
-            numberI->setPos(0,-13-picture.height());
-            numberIBG->setPos(0,-13-picture.height());
+            numberI->setPen(QPen(Qt::white));
+            numberI->setPos(18,-picture.height()/2-2);
+            numberIBG->setPos(18,-picture.height()/2-2);
             numberI->setText(QString::number(number));
             numberIBG->setRect(numberI->boundingRect().adjusted(-2,0,1,0));
         }
@@ -200,6 +225,9 @@ namespace mapcontrol
             delete numberIBG;
         }
         this->update();
+
+
+
     }
     void WayPointItem::WPDeleted(const int &onumber)
     {

src/libs/opmapcontrol/src/mapwidget/waypointitem.h

@@ -121,7 +121,7 @@ public:
     *
     * @param value
     */
-    void SetShowNumber(bool const& value);
+    virtual void SetShowNumber(bool const& value);
     /**
     * @brief Returns the WayPoint altitude in meters
     *
@@ -162,8 +162,12 @@ protected:
     void mouseReleaseEvent ( QGraphicsSceneMouseEvent * event );
 
     MapGraphicItem* map;
-
-private:
+    bool autoreachedEnabled;    ///< If the waypoint should change appearance once it has been reached
+    QGraphicsSimpleTextItem* text;
+    QGraphicsRectItem* textBG;
+    QGraphicsSimpleTextItem* numberI;
+    QGraphicsRectItem* numberIBG;
+    QTransform transf;
     internals::PointLatLng coord;//coordinates of this WayPoint
     bool reached;
     QString description;
@@ -173,13 +177,6 @@ private:
     float heading;
     int number;
 
-
-    QGraphicsSimpleTextItem* text;
-    QGraphicsRectItem* textBG;
-    QGraphicsSimpleTextItem* numberI;
-    QGraphicsRectItem* numberIBG;
-    QTransform transf;
-
 public slots:
     /**
     * @brief Called when a WayPoint is deleted

src/libs/opmapcontrol/src/mapwidget/waypointlineitem.cpp

@@ -3,12 +3,13 @@
 namespace mapcontrol
 {
 WaypointLineItem::WaypointLineItem(WayPointItem* wp1, WayPointItem* wp2, QColor color, mapcontrol::MapGraphicItem* map) :
+        QGraphicsLineItem(map),
     wp1(wp1),
     wp2(wp2),
     map(map)
 {
     // Make sure this stick to the map
-    this->setFlag(QGraphicsItem::ItemIgnoresTransformations,true);
+    //this->setFlag(QGraphicsItem::Item,true);
     setParentItem(map);
 
     // Set up the pen for this icon with the UAV color
@@ -30,6 +31,8 @@ WaypointLineItem::WaypointLineItem(WayPointItem* wp1, WayPointItem* wp2, QColor
     // Delete line if one of the waypoints get deleted
     connect(wp1, SIGNAL(destroyed()), this, SLOT(deleteLater()));
     connect(wp2, SIGNAL(destroyed()), this, SLOT(deleteLater()));
+
+    // Map Zoom and move
 }
 
 void WaypointLineItem::updateWPValues(WayPointItem* waypoint)
@@ -50,4 +53,9 @@ void WaypointLineItem::updateWPValues(WayPointItem* waypoint)
     }
 }
 
+int WaypointLineItem::type()const
+{
+    return Type;
+}
+
 }

src/libs/opmapcontrol/src/mapwidget/waypointlineitem.h

@@ -10,7 +10,9 @@ class WaypointLineItem : public QObject,public QGraphicsLineItem
     Q_OBJECT
     Q_INTERFACES(QGraphicsItem)
 public:
+    enum { Type = UserType + 7 };
     WaypointLineItem(WayPointItem* wp1, WayPointItem* wp2, QColor color=QColor(Qt::red), MapGraphicItem* parent=0);
+    int type() const;
 
 public slots:
     /**

src/libs/qtconcurrent/QtConcurrentTools

+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** Commercial Usage
+**
+** 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 Nokia.
+**
+** GNU Lesser General Public License Usage
+**
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://qt.nokia.com/contact.
+**
+**************************************************************************/
+
+#include "qtconcurrent/multitask.h"
+#include "qtconcurrent/runextensions.h"

src/libs/qtconcurrent/multitask.h

+/**
+ ******************************************************************************
+ *
+ * @file       multitask.h
+ * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
+ *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
+ * @brief      
+ * @see        The GNU Public License (GPL) Version 3
+ * @defgroup   
+ * @{
+ * 
+ *****************************************************************************/
+/* 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU General Public License as published by 
+ * the Free Software Foundation; either version 3 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program; if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef MULTITASK_H
+#define MULTITASK_H
+
+#include "qtconcurrent_global.h"
+#include "runextensions.h"
+
+#include <QtCore/QObject>
+#include <QtCore/QList>
+#include <QtCore/QEventLoop>
+#include <QtCore/QFutureWatcher>
+#include <QtCore/QtConcurrentRun>
+#include <QtCore/QThreadPool>
+
+#include <QtDebug>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtConcurrent {
+
+class QTCONCURRENT_EXPORT MultiTaskBase : public QObject, public QRunnable
+{
+    Q_OBJECT
+protected slots:
+    virtual void cancelSelf() = 0;
+    virtual void setFinished() = 0;
+    virtual void setProgressRange(int min, int max) = 0;
+    virtual void setProgressValue(int value) = 0;
+    virtual void setProgressText(QString value) = 0;
+};
+
+template <typename Class, typename R>
+class MultiTask : public MultiTaskBase
+{
+public:
+    MultiTask(void (Class::*fn)(QFutureInterface<R> &), const QList<Class *> &objects)
+        : fn(fn),
+        objects(objects)
+    {
+        maxProgress = 100*objects.size();
+    }
+
+    QFuture<R> future()
+    {
+        futureInterface.reportStarted();
+        return futureInterface.future();
+    }
+
+    void run()
+    {
+        QThreadPool::globalInstance()->releaseThread();
+        futureInterface.setProgressRange(0, maxProgress);
+        foreach (Class *object, objects) {
+            QFutureWatcher<R> *watcher = new QFutureWatcher<R>();
+            watchers.insert(object, watcher);
+            finished.insert(watcher, false);
+            connect(watcher, SIGNAL(finished()), this, SLOT(setFinished()));
+            connect(watcher, SIGNAL(progressRangeChanged(int,int)), this, SLOT(setProgressRange(int,int)));
+            connect(watcher, SIGNAL(progressValueChanged(int)), this, SLOT(setProgressValue(int)));
+            connect(watcher, SIGNAL(progressTextChanged(QString)), this, SLOT(setProgressText(QString)));
+            watcher->setFuture(QtConcurrent::run(fn, object));
+        }
+        selfWatcher = new QFutureWatcher<R>();
+        connect(selfWatcher, SIGNAL(canceled()), this, SLOT(cancelSelf()));
+        selfWatcher->setFuture(futureInterface.future());
+        loop = new QEventLoop;
+        loop->exec();
+        futureInterface.reportFinished();
+        QThreadPool::globalInstance()->reserveThread();
+        qDeleteAll(watchers.values());
+        delete selfWatcher;
+        delete loop;
+    }
+protected:
+    void cancelSelf()
+    {
+        foreach (QFutureWatcher<R> *watcher, watchers)
+            watcher->future().cancel();
+    }
+
+    void setFinished()
+    {
+        updateProgress();
+        QFutureWatcher<R> *watcher = static_cast<QFutureWatcher<R> *>(sender());
+        if (finished.contains(watcher))
+            finished[watcher] = true;
+        bool allFinished = true;
+        const QList<bool> finishedValues = finished.values();
+        foreach (bool isFinished, finishedValues) {
+            if (!isFinished) {
+                allFinished = false;
+                break;
+            }
+        }
+        if (allFinished)
+            loop->quit();
+    }
+
+    void setProgressRange(int min, int max)
+    {
+        Q_UNUSED(min)
+        Q_UNUSED(max)
+        updateProgress();
+    }
+
+    void setProgressValue(int value)
+    {
+        Q_UNUSED(value)
+        updateProgress();
+    }
+
+    void setProgressText(QString value)
+    {
+        Q_UNUSED(value)
+        updateProgressText();
+    }
+private:
+    void updateProgress()
+    {
+        int progressSum = 0;
+        const QList<QFutureWatcher<R> *> watchersValues = watchers.values();
+        foreach (QFutureWatcher<R> *watcher, watchersValues) {
+            if (watcher->progressMinimum() == watcher->progressMaximum()) {
+                if (watcher->future().isFinished() && !watcher->future().isCanceled())
+                    progressSum += 100;
+            } else {
+                progressSum += 100*(watcher->progressValue()-watcher->progressMinimum())/(watcher->progressMaximum()-watcher->progressMinimum());
+            }
+        }
+        futureInterface.setProgressValue(progressSum);
+    }
+
+    void updateProgressText()
+    {
+        QString text;
+        const QList<QFutureWatcher<R> *> watchersValues = watchers.values();
+        foreach (QFutureWatcher<R> *watcher, watchersValues) {
+            if (!watcher->progressText().isEmpty())
+                text += watcher->progressText() + "\n";
+        }
+        text = text.trimmed();
+        futureInterface.setProgressValueAndText(futureInterface.progressValue(), text);
+    }
+
+    QFutureInterface<R> futureInterface;
+    void (Class::*fn)(QFutureInterface<R> &);
+    QList<Class *> objects;
+
+    QFutureWatcher<R> *selfWatcher;
+    QMap<Class *, QFutureWatcher<R> *> watchers;
+    QMap<QFutureWatcher<R> *, bool> finished;
+    QEventLoop *loop;
+    int maxProgress;
+};
+
+template <typename Class, typename T>
+QFuture<T> run(void (Class::*fn)(QFutureInterface<T> &), const QList<Class *> &objects, int priority = 0)
+{
+    MultiTask<Class, T> *task = new MultiTask<Class, T>(fn, objects);
+    QFuture<T> future = task->future();
+    QThreadPool::globalInstance()->start(task, priority);
+    return future;
+}
+
+} // namespace QtConcurrent
+
+QT_END_NAMESPACE
+
+#endif // MULTITASK_H

src/libs/qtconcurrent/qtconcurrent.pri

+LIBS *= -l$$qtLibraryTarget(QtConcurrent)

src/libs/qtconcurrent/qtconcurrent.pro

+TEMPLATE = lib
+TARGET = QtConcurrent
+DEFINES += BUILD_QTCONCURRENT
+
+include(../../openpilotgcslibrary.pri)
+
+HEADERS += \
+    qtconcurrent_global.h \
+    multitask.h \
+    runextensions.h

src/libs/qtconcurrent/qtconcurrent_global.h

+/**
+ ******************************************************************************
+ *
+ * @file       qtconcurrent_global.h
+ * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
+ *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
+ * @brief      
+ * @see        The GNU Public License (GPL) Version 3
+ * @defgroup   
+ * @{
+ * 
+ *****************************************************************************/
+/* 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU General Public License as published by 
+ * the Free Software Foundation; either version 3 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program; if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef QTCONCURRENT_GLOBAL_H
+#define QTCONCURRENT_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#if defined(BUILD_QTCONCURRENT)
+#  define QTCONCURRENT_EXPORT Q_DECL_EXPORT
+#else
+#  define QTCONCURRENT_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // QTCONCURRENT_GLOBAL_H

src/libs/utils/qtcassert.h

+/**
+ ******************************************************************************
+ *
+ * @file       qtcassert.h
+ * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
+ *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
+ * @brief      
+ * @see        The GNU Public License (GPL) Version 3
+ * @defgroup   
+ * @{
+ * 
+ *****************************************************************************/
+/* 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU General Public License as published by 
+ * the Free Software Foundation; either version 3 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program; if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef QTC_ASSERT_H
+#define QTC_ASSERT_H
+
+#include <QtCore/QDebug>
+
+#define QTC_ASSERT_STRINGIFY_INTERNAL(x) #x
+#define QTC_ASSERT_STRINGIFY(x) QTC_ASSERT_STRINGIFY_INTERNAL(x)
+
+// we do not use the  'do {...} while (0)' idiom here to be able to use
+// 'break' and 'continue' as 'actions'.
+
+#define QTC_ASSERT(cond, action) \
+    if(cond){}else{qDebug()<<"ASSERTION " #cond " FAILED AT " __FILE__ ":" QTC_ASSERT_STRINGIFY(__LINE__);action;}
+
+#endif // QTC_ASSERT_H
+

src/libs/utils/qtcolorbutton.cpp

+/**
+ ******************************************************************************
+ *
+ * @file       qtcolorbutton.cpp
+ * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
+ *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
+ * @brief      
+ * @see        The GNU Public License (GPL) Version 3
+ * @defgroup   
+ * @{
+ * 
+ *****************************************************************************/
+/* 
+ * This program is free software; you can redistribute it and/or modify 
+ * it under the terms of the GNU General Public License as published by 
+ * the Free Software Foundation; either version 3 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 
+ * for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along 
+ * with this program; if not, write to the Free Software Foundation, Inc., 
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include "qtcolorbutton.h"
+
+#include <QtCore/QMimeData>
+#include <QtGui/QApplication>
+#include <QtGui/QColorDialog>
+#include <QtGui/QDragEnterEvent>
+#include <QtGui/QPainter>
+
+namespace Utils {
+
+class QtColorButtonPrivate
+{
+    QtColorButton *q_ptr;
+    Q_DECLARE_PUBLIC(QtColorButton)
+public:
+    QColor m_color;
+#ifndef QT_NO_DRAGANDDROP
+    QColor m_dragColor;
+    QPoint m_dragStart;
+    bool m_dragging;
+#endif
+    bool m_backgroundCheckered;
+    bool m_alphaAllowed;
+
+    void slotEditColor();
+    QColor shownColor() const;
+    QPixmap generatePixmap() const;
+};
+
+void QtColorButtonPrivate::slotEditColor()
+{
+    QColor newColor;
+    if (m_alphaAllowed) {
+        bool ok;
+        const QRgb rgba = QColorDialog::getRgba(m_color.rgba(), &ok, q_ptr);
+        if (!ok)
+            return;
+        newColor = QColor::fromRgba(rgba);
+    } else {
+        newColor = QColorDialog::getColor(m_color, q_ptr);
+        if (!newColor.isValid())
+            return;
+    }
+    if (newColor == q_ptr->color())
+        return;
+    q_ptr->setColor(newColor);
+    emit q_ptr->colorChanged(m_color);
+}
+
+QColor QtColorButtonPrivate::shownColor() const
+{
+#ifndef QT_NO_DRAGANDDROP
+    if (m_dragging)
+        return m_dragColor;
+#endif
+    return m_color;
+}
+
+QPixmap QtColorButtonPrivate::generatePixmap() const
+{
+    QPixmap pix(24, 24);
+
+    int pixSize = 20;
+    QBrush br(shownColor());
+
+    QPixmap pm(2 * pixSize, 2 * pixSize);
+    QPainter pmp(&pm);
+    pmp.fillRect(0, 0, pixSize, pixSize, Qt::lightGray);
+    pmp.fillRect(pixSize, pixSize, pixSize, pixSize, Qt::lightGray);
+    pmp.fillRect(0, pixSize, pixSize, pixSize, Qt::darkGray);
+    pmp.fillRect(pixSize, 0, pixSize, pixSize, Qt::darkGray);
+    pmp.fillRect(0, 0, 2 * pixSize, 2 * pixSize, shownColor());
+    br = QBrush(pm);
+