src/components/colorpalette/private/gradientviewer.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Jorge Cuadrado                                  *
   3  *   kuadrosx@gmail.com                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "gradientviewer.h"
  22 #include <QPainter>
  23 #include <dcore/debug.h>
  24 #include <dgraphics/algorithm.h>
  25
  26 #include <QMouseEvent>
  27 #include <QRectF>
  28
  29 struct GradientViewer::Private
  30 {
  31         class ControlPoint
  32         {
  33                 public:
  34                         ControlPoint()
  35                         {
  36                                 QRadialGradient gradient(QPoint(5, 5), 10, QPoint(5,5) );
  37
  38                                 gradient.setColorAt(0.5, Qt::gray);
  39                                 gradient.setColorAt(0, Qt::blue);
  40
  41                                 normalPoint = QBrush(gradient);
  42
  43                                 gradient.setColorAt(0, Qt::red);
  44                                 selectedPoint = QBrush(gradient);
  45
  46                                 currentIndex = 0;
  47                                 points << QPointF(10,50) << QPointF(60,50);
  48                         }
  49                         ~ControlPoint() {}
  50                         QVector<QPointF> points;
  51                         int currentIndex;
  52
  53                         void selectPoint(const QPointF &point)
  54                         {
  55                                 int rate = 10;
  56                                 QRectF rect(point - QPointF(rate/2,rate/2) , QSizeF(rate, rate ));
  57
  58                                 QVector<QPointF>::const_iterator it;
  59                                 for (it = points.begin(); it != points.end(); ++it)
  60                                 {
  61                                         if( rect.contains(*it) )
  62                                         {
  63                                                 currentIndex = points.indexOf(*it);
  64                                                 break;
  65                                         }
  66                                 }
  67                         }
  68                         void drawPoints(QPainter *p)
  69                         {
  70                                 foreach(QPointF point, points)
  71                                 {
  72                                         QRectF br( point - QPoint(5,5), QSizeF(10,10)  );
  73                                         p->save();
  74                                         p->setRenderHint(QPainter::Antialiasing);
  75                                         if(point == points[currentIndex])
  76                                         {
  77                                                 selectedPoint.setMatrix(QMatrix().translate(br.x(), br.y()));
  78                                                 p->setBrush(selectedPoint);
  79                                         }
  80                                         else
  81                                         {
  82                                                 normalPoint.setMatrix(QMatrix().translate(br.x(), br.y()));
  83                                                 p->setBrush(normalPoint);
  84                                         }
  85
  86                                         p->drawEllipse(br);
  87                                         p->restore();
  88
  89         //                              p->drawPoint(point);
  90                                 }
  91                         }
  92
  93                         QBrush normalPoint;
  94                         QBrush selectedPoint;
  95         };
  96         ControlPoint *controlPoint;
  97         QGradientStops gradientStops;
  98         QGradient gradient;
  99
 100         double radius;
 101         QGradient::Type type;
 102         QGradient::Spread spread;
 103 };
 104
 105
 106
 107 GradientViewer::GradientViewer(QWidget *parent)
 108         : QFrame(parent), d(new Private)
 109 {
 110         d->radius = 50;
 111
 112         d->controlPoint = new Private::ControlPoint();
 113         d->type = QGradient::LinearGradient;
 114         d->spread =  QGradient::PadSpread;
 115         setMidLineWidth(2);
 116         setLineWidth(2);
 117         setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
 118         createGradient();
 119         repaint();
 120
 121 //      setMinimumSize(sizeHint());
 122 }
 123
 124
 125 GradientViewer::~GradientViewer()
 126 {
 127         delete d->controlPoint;
 128         delete d;
 129 }
 130
 131 void GradientViewer::paintEvent( QPaintEvent* e)
 132 {
 133         createGradient();
 134         QPainter p(this);
 135
 136         p.setPen(Qt::NoPen);
 137         QBrush brush(d->gradient);
 138
 139         QMatrix m;
 140         m.scale(100/rect().width(), 100/rect().height());
 141         brush.setMatrix(m);
 142
 143         p.setBrush(brush);
 144
 145         p.drawRect(rect());
 146
 147         if(isEnabled () )
 148         {
 149                 d->controlPoint->drawPoints(&p);
 150         }
 151         else
 152         {
 153                 QColor disabled = palette().color(QPalette::Disabled, QPalette::WindowText);
 154                 disabled.setAlpha(120);
 155                 p.fillRect(rect(), disabled);
 156         }
 157
 158         p.end();
 159
 160         QFrame::paintEvent(e);
 161 }
 162
 163 QSize GradientViewer::sizeHint() const
 164 {
 165         return QSize(100,100);
 166 }
 167
 168 void GradientViewer::resizeEvent ( QResizeEvent * event )
 169 {
 170         int s = qMin(event->size().width(), event->size().height());
 171         resize(QSize(s,s));
 172 }
 173
 174 void GradientViewer::createGradient()
 175 {
 176         switch(d->type)
 177         {
 178                 case  QGradient::LinearGradient:
 179                 {
 180                         d->gradient = QLinearGradient(d->controlPoint->points[0], d->controlPoint->points[1]);
 181                         break;
 182                 }
 183                 case QGradient::RadialGradient:
 184                 {
 185                         d->gradient = QRadialGradient(d->controlPoint->points[0], d->radius, d->controlPoint->points[1] );
 186                         break;
 187                 }
 188                 case QGradient::ConicalGradient:
 189                 {
 190                         d->gradient = QConicalGradient(d->controlPoint->points[0], DGraphics::Algorithm::angleForPos( d->controlPoint->points[1], d->controlPoint->points[0 ])*180/M_PI);
 191                         break;
 192                 }
 193                 default:
 194                 {
 195                         dFatal() << "Fatal error, the gradient type doesn't exists!";
 196                 }
 197         }
 198         d->gradient.setStops( d->gradientStops);
 199         d->gradient.setSpread(d->spread);
 200
 201 }
 202 void GradientViewer::changeGradientStops( const QGradientStops& stops)
 203 {
 204         d->gradientStops = stops;
 205
 206         repaint();
 207 }
 208
 209 void GradientViewer::changeType(int type)
 210 {
 211         d->type = QGradient::Type(type);
 212         repaint();
 213 }
 214
 215
 216 void GradientViewer::setSpread(int spread)
 217 {
 218         d->spread = QGradient::Spread(spread);
 219         repaint();
 220 }
 221
 222
 223
 224 QGradient GradientViewer::gradient()
 225 {
 226         QGradient gradientNormalized;
 227         switch(d->gradient.type())
 228         {
 229                 case  QGradient::LinearGradient:
 230                 {
 231                         gradientNormalized = QLinearGradient(
 232                                         normalizePoint(d->controlPoint->points[0]), normalizePoint(d->controlPoint->points[1]));
 233                         break;
 234                 }
 235                 case QGradient::RadialGradient:
 236                 {
 237                         gradientNormalized = QRadialGradient(normalizePoint(d->controlPoint->points[0]), d->radius, normalizePoint(d->controlPoint->points[1]) );
 238                         break;
 239                 }
 240                 case QGradient::ConicalGradient:
 241                 {
 242                         gradientNormalized = QConicalGradient(normalizePoint(d->controlPoint->points[0]), DGraphics::Algorithm::angleForPos(normalizePoint(d->controlPoint->points[1]), normalizePoint(d->controlPoint->points[0]))*180/M_PI);
 243                         break;
 244                 }
 245                 default:
 246                 {
 247                         dFatal() << "Fatal error, the gradient type doesn't exists!";
 248                 }
 249         }
 250         gradientNormalized.setStops( d->gradientStops);
 251         gradientNormalized.setSpread(d->spread);
 252         return gradientNormalized;
 253 }
 254
 255 void GradientViewer::mousePressEvent(QMouseEvent *e)
 256 {
 257         d->controlPoint->selectPoint(e->pos());
 258
 259         update();
 260 }
 261
 262 void GradientViewer::mouseMoveEvent( QMouseEvent * e )
 263 {
 264         d->controlPoint->points[d->controlPoint->currentIndex] = e->pos();
 265         update();
 266         emit gradientChanged();
 267 }
 268
 269 void GradientViewer::changeRadius(int radius)
 270 {
 271         d->radius = radius;
 272         update();
 273         emit gradientChanged();
 274 }
 275
 276 void GradientViewer::setGradient(const QGradient* gradient)
 277 {
 278         d->gradientStops = gradient->stops();
 279         d->spread = gradient->spread();
 280         d->type = gradient->type();
 281         switch(d->type)
 282         {
 283                 case  QGradient::LinearGradient:
 284                 {
 285                         d->controlPoint->points[0] = static_cast<const QLinearGradient*>(gradient)->start();
 286                         d->controlPoint->points[1] = static_cast<const QLinearGradient*>(gradient)->finalStop();
 287                         break;
 288                 }
 289                 case QGradient::RadialGradient:
 290                 {
 291                         d->controlPoint->points[0] = static_cast<const QRadialGradient*>(gradient)->center();
 292                         d->controlPoint->points[1] = static_cast<const QRadialGradient*>(gradient)->focalPoint();
 293                         d->radius = static_cast<const QRadialGradient*>(gradient)->radius();
 294                         break;
 295                 }
 296                 case QGradient::ConicalGradient:
 297                 {
 298                         d->controlPoint->points[0] = static_cast<const QConicalGradient*>(gradient)->center();
 299
 300                         double angle = static_cast<const QConicalGradient*>(gradient)->angle();
 301
 302                         QMatrix m;
 303                         m.rotate(-angle);
 304                         QPointF point = m.map(QPointF(10, 0));
 305
 306                         d->controlPoint->points[1] = point + d->controlPoint->points[0];
 307
 308
 309                         break;
 310                 }
 311                 default:
 312                 {
 313                         dFatal() << "Fatal error, the gradient type doesn't exists!";
 314                 }
 315         }
 316         repaint();
 317 }
 318
 319 QPointF GradientViewer::normalizePoint(const QPointF & point)
 320 {
 321         return QPointF(point.x()*(100/width()), point.y()*(100/height()));
 322 }
 323