yamf/tools/brush/brush.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by David Cuadrado                                  *
   3  *   krawek@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 "brush.h"
  22
  23 #include <QPointF>
  24 #include <QKeySequence>
  25 #include <QGraphicsPathItem>
  26 #include <QPainterPath>
  27 #include <QMatrix>
  28 #include <QGraphicsLineItem>
  29 #include <QGraphicsView>
  30
  31 #include <QGraphicsSceneMouseEvent>
  32 #include <QToolBar>
  33
  34 #include <QHBoxLayout>
  35 #include <QLabel>
  36
  37 #include <dgraphics/algorithm.h>
  38 #include <dcore/algorithm.h>
  39 #include <dcore/debug.h>
  40 #include <dgui/action.h>
  41 #include <dgui/iconloader.h>
  42
  43 #include <drawing/photogram.h>
  44 #include <drawing/brushmanager.h>
  45 #include <drawing/paintarea.h>
  46
  47
  48 #include <model/frame.h>
  49 #include <item/path.h>
  50
  51 namespace YAMF {
  52 namespace Drawing {
  53 namespace Tool {
  54
  55 struct Brush::Private
  56 {
  57         Private() : item(0), exactness(0), configWidget(0) {}
  58
  59         QPointF firstPoint;
  60         QPointF oldPos;
  61         QPainterPath path;
  62
  63         DGui::Action *action;
  64
  65         YAMF::Item::Path *item;
  66
  67         QDoubleSpinBox *exactness;
  68         QWidget *configWidget;
  69 };
  70
  71 /**
  72  * @~spanish
  73  * Construye la herramienta.
  74  */
  75 Brush::Brush(QObject *parent) : AbstractTool(parent), d(new Private)
  76 {
  77         d->action = new DGui::Action( DGui::IconLoader::self()->load("draw-freehand.svg"), tr("Pencil"), this);
  78         d->action->setShortcut( QKeySequence(tr("Ctrl+B")) );
  79
  80         d->exactness = new QDoubleSpinBox;
  81         d->exactness->setValue(3.0);
  82
  83
  84         d->configWidget = new QWidget;
  85         QHBoxLayout *layout = new QHBoxLayout(d->configWidget);
  86         layout->setMargin(0);
  87         layout->setSpacing(2);
  88         layout->addWidget(new QLabel(tr("Smoothness")));
  89         layout->addWidget(d->exactness);
  90 }
  91
  92 /**
  93  * @~spanish
  94  * Destructor
  95  */
  96 Brush::~Brush()
  97 {
  98         if( d->configWidget )
  99         {
 100                 d->configWidget->setParent(0);
 101                 delete d->configWidget;
 102         }
 103         delete d;
 104 }
 105
 106 /**
 107  * @~spanish
 108  * Inicializa la herramienta, evita que los items dentro de el fotograma se puedan mover o seleccionar
 109  */
 110 void Brush::init(Photogram *photogram)
 111 {
 112         foreach(QGraphicsView * view, photogram->views())
 113         {
 114                 view->setDragMode ( QGraphicsView::NoDrag );
 115
 116                 if ( QGraphicsScene *photogram = qobject_cast<QGraphicsScene *>(view->scene()) )
 117                 {
 118                         foreach(QGraphicsItem *item, photogram->items() )
 119                         {
 120                                 item->setFlag(QGraphicsItem::ItemIsSelectable, false);
 121                                 item->setFlag(QGraphicsItem::ItemIsMovable, false);
 122                         }
 123                 }
 124         }
 125 }
 126
 127 /**
 128  * @~spanish
 129  * Retorna el id de la herramienta
 130  */
 131 QString Brush::id() const
 132 {
 133         return tr("Pencil");
 134 }
 135
 136 /**
 137  * @~spanish
 138  * Función sobrecargada para implementar el trazo de lineas.
 139  */
 140 void Brush::press(const QGraphicsSceneMouseEvent *input)
 141 {
 142         PaintArea *paintArea = this->paintArea();
 143
 144         d->firstPoint = input->scenePos();
 145         d->path = QPainterPath();
 146         d->path.moveTo(d->firstPoint);
 147         d->oldPos = input->scenePos();
 148         d->item = new Item::Path();
 149         d->item->setPen(paintArea->brushManager()->pen());
 150         paintArea->photogram()->addItem( d->item );
 151         d->item->setZValue(1000);
 152 }
 153
 154 /**
 155  * @~spanish
 156  * Función sobrecargada para implementar el trazo de lineas.
 157  */
 158 void Brush::move(const QGraphicsSceneMouseEvent *input)
 159 {
 160         PaintArea *paintArea = this->paintArea();
 161
 162         if(input->buttons() == Qt::LeftButton)
 163         {
 164                 QPointF lastPoint = input->scenePos();
 165
 166                 foreach(QGraphicsView * view, paintArea->photogram()->views())
 167                 {
 168         //              view->setDragMode (QGraphicsView::NoDrag);
 169                 }
 170
 171         //      d->path.moveTo( d->oldPos);
 172                 d->path.lineTo( lastPoint );
 173
 174                 d->item->setPath(d->path);
 175                 paintArea->brushManager()->map(d->item);
 176
 177                 d->oldPos = lastPoint;
 178         }
 179 }
 180
 181 /**
 182  * @~spanish
 183  * Función sobrecargada para implementar el trazo de lineas.
 184  */
 185 void Brush::release(const QGraphicsSceneMouseEvent *input)
 186 {
 187         PaintArea *paintArea = this->paintArea();
 188         BrushManager *brushManager = paintArea->brushManager();
 189
 190         double smoothness = 0.1;
 191         if( d->exactness )
 192         {
 193                 smoothness = d->exactness->value();
 194         }
 195
 196         if ( d->firstPoint == input->pos() && d->path.elementCount() == 1)
 197         {
 198                 smoothness = 0;
 199                 d->path.addEllipse(input->pos().x(), input->pos().y(), brushManager->pen().width(), brushManager->pen().width());
 200         }
 201
 202         smoothPath( d->path, smoothness );
 203
 204         d->firstPoint = QPoint(0,0);
 205         d->item->setBrush( brushManager->brush() );
 206         d->item->setPath(d->path);
 207         paintArea->brushManager()->map(d->item);
 208
 209         //
 210         paintArea->currentFrame()->addItem(d->item);
 211 }
 212
 213 /**
 214  * @~spanish
 215  * @internal
 216  * Suaviza el trazo hecho por el usuario.
 217  */
 218 void Brush::smoothPath(QPainterPath &path, double smoothness, int from, int to)
 219 {
 220         if(smoothness > 0 )
 221         {
 222                 QPolygonF polygon = path.toFillPolygon();
 223                 if(!polygon.isEmpty() && polygon.isClosed())
 224                         polygon.pop_back();
 225
 226                 path = DGraphics::Algorithm::smooth(polygon, smoothness, from, to);
 227         }
 228 }
 229
 230 /**
 231  * @~spanish
 232  * Retorna la acción que representa la herramienta.
 233  */
 234 DGui::Action * Brush::action() const
 235 {
 236         return d->action;
 237 }
 238
 239 /**
 240  * @~spanish
 241  * Retorna que la herramienta es de tipo Brush.
 242  */
 243 int Brush::type() const
 244 {
 245         return AbstractTool::Brush;
 246 }
 247
 248 void Brush::aboutToChangeTool()
 249 {
 250 }
 251
 252 /**
 253  * @~spanish
 254  * Asigna la interfaz gráfica para configurar el grado de suavizado.
 255  */
 256 void Brush::setupConfigBar(QToolBar *configBar)
 257 {
 258         configBar->addWidget(d->configWidget)->setVisible(true);
 259 }
 260
 261 }
 262 }
 263 }