src/components/colorpalette/private/gradientviewer.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Jorge Cuadrado                                  *
   3  *   kuadrosx@toonka.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 class GradientViewer::ControlPoint
  30 {
  31         public:
  32                 ControlPoint()
  33                 {
  34                         currentIndex = 0;
  35                         points << QPointF(10,50) << QPointF(60,50);
  36                 }
  37                 ~ControlPoint() {}
  38                 QVector<QPointF> points;
  39                 int currentIndex;
  40
  41                 void selectPoint(const QPointF &point)
  42                 {
  43                         int rate = 5;
  44                         QRectF rect(point - QPointF(rate/2,rate/2) , QSizeF(rate, rate ));
  45
  46                         QVector<QPointF>::const_iterator it;
  47                         for (it = points.begin(); it != points.end(); ++it)
  48                         {
  49                                 if( rect.contains(*it) )
  50                                 {
  51                                         currentIndex = points.indexOf(*it);
  52                                         break;
  53                                 }
  54                         }
  55                 }
  56                 void drawPoints(QPainter *p)
  57                 {
  58                         foreach(QPointF point, points)
  59                         {
  60                                 if(point == points[currentIndex])
  61                                 {
  62                                         p->save();
  63                                         p->setPen(QPen(Qt::red, 5, Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin ));
  64                                 }
  65                                 else
  66                                 {
  67                                         p->save();
  68                                         p->setPen(QPen(Qt::blue, 5, Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin ));
  69                                 }
  70                                 p->drawPoint(point);
  71                                 p->restore();
  72                         }
  73                 }
  74 };
  75
  76 GradientViewer::GradientViewer(QWidget *parent)
  77         : QFrame(parent), m_radius(50)
  78 {
  79
  80         m_controlPoint = new ControlPoint();
  81 //      setMaximumSize(100,100);
  82 //      setMinimumSize(100,100);
  83         m_type = QGradient::LinearGradient;
  84         m_spread =  QGradient::PadSpread;
  85         setMidLineWidth(2);
  86         setLineWidth(2);
  87         setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
  88 //      m_gradientStops.append(qMakePair(0.5, QColor("#000000")));
  89         createGradient();
  90         repaint();
  91 }
  92
  93
  94 GradientViewer::~GradientViewer()
  95 {
  96         D_END;
  97         delete m_controlPoint;
  98 }
  99
 100 void GradientViewer::paintEvent( QPaintEvent* e)
 101 {
 102         createGradient();
 103         QPainter p;
 104         p.begin(this);
 105
 106         QBrush brush(m_gradient);
 107         QMatrix m;
 108         m.scale(100/rect().width(), 100/rect().height());
 109         brush.setMatrix(m);
 110
 111         p.setBrush(brush);
 112
 113         p.drawRect(rect());
 114         p.setPen(QPen(Qt::blue, 5, Qt::SolidLine,Qt::RoundCap,Qt::RoundJoin ));
 115         m_controlPoint->drawPoints(&p);
 116
 117         p.end();
 118
 119         QFrame::paintEvent(e);
 120 }
 121
 122 QSize GradientViewer::sizeHint() const
 123 {
 124         return QSize(100,100);
 125 }
 126
 127 void GradientViewer::resizeEvent ( QResizeEvent * event )
 128 {
 129         int s = qMin(event->size().width(), event->size().height());
 130         resize(QSize(s,s));
 131 }
 132
 133 void GradientViewer::createGradient()
 134 {
 135         switch(m_type)
 136         {
 137                 case  QGradient::LinearGradient:
 138                 {
 139                         m_gradient = QLinearGradient(m_controlPoint->points[0], m_controlPoint->points[1]);
 140                         break;
 141                 }
 142                 case QGradient::RadialGradient:
 143                 {
 144                         m_gradient = QRadialGradient(m_controlPoint->points[0], m_radius, m_controlPoint->points[1] );
 145                         break;
 146                 }
 147                 case QGradient::ConicalGradient:
 148                 {
 149                         m_gradient = QConicalGradient(m_controlPoint->points[0], DGraphics::Algorithm::angleForPos( m_controlPoint->points[1], m_controlPoint->points[0 ])*180/M_PI);
 150                         break;
 151                 }
 152                 default:
 153                 {
 154                         dFatal() << "Fatal error, the gradient type doesn't exists!";
 155                 }
 156         }
 157         m_gradient.setStops( m_gradientStops);
 158         m_gradient.setSpread(m_spread);
 159
 160 }
 161 void GradientViewer::changeGradientStops( const QGradientStops& stops)
 162 {
 163         m_gradientStops = stops;
 164
 165         repaint();
 166 }
 167
 168 void GradientViewer::changeType(int type)
 169 {
 170         m_type = QGradient::Type(type);
 171         repaint();
 172 }
 173
 174
 175 void GradientViewer::setSpread(int spread)
 176 {
 177         m_spread = QGradient::Spread(spread);
 178         repaint();
 179 }
 180
 181
 182
 183 QGradient GradientViewer::gradient()
 184 {
 185         QGradient gradientNormalized;
 186         switch(m_gradient.type())
 187         {
 188                 case  QGradient::LinearGradient:
 189                 {
 190                         gradientNormalized = QLinearGradient(
 191                                         normalizePoint(m_controlPoint->points[0]), normalizePoint(m_controlPoint->points[1]));
 192                         break;
 193                 }
 194                 case QGradient::RadialGradient:
 195                 {
 196                         gradientNormalized = QRadialGradient(normalizePoint(m_controlPoint->points[0]), m_radius, normalizePoint(m_controlPoint->points[1]) );
 197                         break;
 198                 }
 199                 case QGradient::ConicalGradient:
 200                 {
 201                         gradientNormalized = QConicalGradient(normalizePoint(m_controlPoint->points[0]), DGraphics::Algorithm::angleForPos(normalizePoint(m_controlPoint->points[1]), normalizePoint(m_controlPoint->points[0]))*180/M_PI);
 202                         break;
 203                 }
 204                 default:
 205                 {
 206                         dFatal() << "Fatal error, the gradient type doesn't exists!";
 207                 }
 208         }
 209         gradientNormalized.setStops( m_gradientStops);
 210         gradientNormalized.setSpread(m_spread);
 211         return gradientNormalized;
 212 }
 213
 214 void GradientViewer::mousePressEvent(QMouseEvent *e)
 215 {
 216         m_controlPoint->selectPoint(e->pos());
 217
 218         update();
 219 }
 220
 221 void GradientViewer::mouseMoveEvent( QMouseEvent * e )
 222 {
 223         m_controlPoint->points[m_controlPoint->currentIndex] = e->pos();
 224         update();
 225         emit gradientChanged();
 226 }
 227
 228 void GradientViewer::changeRadius(int radius)
 229 {
 230         m_radius = radius;
 231         update();
 232         emit gradientChanged();
 233 }
 234
 235 void GradientViewer::setGradient(const QGradient* gradient)
 236 {
 237         m_gradientStops = gradient->stops();
 238         m_spread = gradient->spread();
 239         m_type = gradient->type();
 240         switch(m_type)
 241         {
 242                 case  QGradient::LinearGradient:
 243                 {
 244                         m_controlPoint->points[0] = static_cast<const QLinearGradient*>(gradient)->start();
 245                         m_controlPoint->points[1] = static_cast<const QLinearGradient*>(gradient)->finalStop();
 246                         break;
 247                 }
 248                 case QGradient::RadialGradient:
 249                 {
 250                         m_controlPoint->points[0] = static_cast<const QRadialGradient*>(gradient)->center();
 251                         m_controlPoint->points[1] = static_cast<const QRadialGradient*>(gradient)->focalPoint();
 252                         m_radius = static_cast<const QRadialGradient*>(gradient)->radius();
 253                         break;
 254                 }
 255                 case QGradient::ConicalGradient:
 256                 {
 257                         m_controlPoint->points[0] = static_cast<const QConicalGradient*>(gradient)->center();
 258
 259                         double angle = static_cast<const QConicalGradient*>(gradient)->angle();
 260
 261                         QMatrix m;
 262                         m.rotate(-angle);
 263                         QPointF point = m.map(QPointF(10, 0));
 264
 265                         m_controlPoint->points[1] = point + m_controlPoint->points[0];
 266
 267
 268                         break;
 269                 }
 270                 default:
 271                 {
 272                         dFatal() << "Fatal error, the gradient type doesn't exists!";
 273                 }
 274         }
 275         repaint();
 276 }
 277
 278 QPointF GradientViewer::normalizePoint(const QPointF & point)
 279 {
 280         return QPointF(point.x()*(100/width()), point.y()*(100/height()));
 281 }
 282