yamf/tools/polyline/polyline.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Jorge Cuadrado                                  *
   3  *   kuadrosxx@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 "polyline.h"
  22
  23 #include <drawing/photogram.h>
  24 #include <drawing/brushmanager.h>
  25 #include <drawing/paintarea.h>
  26
  27 #include <dgraphics/patheditor.h>
  28 #include <dgui/action.h>
  29 #include <dgui/iconloader.h>
  30 #include <dcore/debug.h>
  31
  32 #include <selection/private/contoureditor.h>
  33 #include <model/command/editnodesitem.h>
  34
  35 #include <model/frame.h>
  36 #include <item/path.h>
  37
  38
  39 #include <QPointF>
  40 #include <QIcon>
  41 #include <QKeySequence>
  42 #include <QGraphicsPathItem>
  43 #include <QPainterPath>
  44 #include <QMatrix>
  45 #include <QGraphicsLineItem>
  46 #include <QGraphicsView>
  47
  48 #include <QGraphicsSceneMouseEvent>
  49 #include <QKeyEvent>
  50
  51
  52 namespace YAMF {
  53 namespace Drawing {
  54 namespace Tool {
  55
  56 struct PolyLine::Private
  57 {
  58         bool begin, moved;
  59         QPointF center;
  60         QPointF right;
  61         Drawing::Tool::Private::ContourEditor *editor;
  62         QPainterPath path;
  63         QPainterPath lastPart;
  64
  65         YAMF::Item::Path *item;
  66         PaintArea * paintArea;
  67         DGui::Action *action;
  68
  69         QGraphicsLineItem *line1, *line2;
  70
  71         QGraphicsPathItem *line3;
  72 };
  73
  74 /**
  75  * @~spanish
  76  * Construye la herramienta para dibujar trazos rectos y curvilíneos.
  77  */
  78 PolyLine::PolyLine(QObject *parent): AbstractTool(parent), d(new Private)
  79 {
  80         d->begin = false;
  81
  82         d->editor = 0;
  83         d->item = 0;
  84         d->paintArea = 0;
  85         d->line1 = new QGraphicsLineItem(0,0,0,0);
  86         d->line1->setPen ( QPen(Qt::red) );
  87         d->line2 = new QGraphicsLineItem(0,0,0,0);
  88         d->line2->setPen ( QPen(Qt::green) );
  89
  90         d->line3 = new QGraphicsPathItem();
  91
  92         d->action = new DGui::Action( DGui::IconLoader::self()->load("draw-path.svg"), tr("Poly line"), this);
  93         d->action->setShortcut( QKeySequence(tr("")) );
  94 }
  95
  96
  97 /**
  98  * Destructor
  99  */
 100 PolyLine::~PolyLine()
 101 {
 102         delete d;
 103 }
 104
 105 /**
 106  * @~spanish
 107  * Inicializa la herramienta, evita que los items dentro de el fotograma se puedan mover o seleccionar.
 108  */
 109 void PolyLine::init(Photogram *photogram)
 110 {
 111         endItem();
 112         //FIXME
 113         foreach(QGraphicsView *view,  photogram->views() )
 114         {
 115                 view->setDragMode ( QGraphicsView::NoDrag );
 116
 117                 Q_CHECK_PTR(view->scene());
 118                 if ( QGraphicsScene *sscene = qobject_cast<QGraphicsScene *>(view->scene()) )
 119                 {
 120                         foreach(QGraphicsItem *item, sscene->items() )
 121                         {
 122                                 item->setFlag(QGraphicsItem::ItemIsSelectable, false);
 123                                 item->setFlag(QGraphicsItem::ItemIsMovable, false);
 124                         }
 125                         sscene->addItem( d->line1 );
 126                         sscene->addItem( d->line2 );
 127                 }
 128         }
 129 }
 130
 131 /**
 132  * @~spanish
 133  * Retorna el id de la herramienta.
 134  */
 135 QString PolyLine::id() const
 136 {
 137         return tr("PolyLine");
 138 }
 139
 140 /**
 141  * @~spanish
 142  * Función sobrecargada para implementar la creación de los trazos rectos y curvilíneos.
 143  */
 144 void PolyLine::press(const QGraphicsSceneMouseEvent *input)
 145 {
 146         d->paintArea = this->paintArea(); // FIXME
 147         QGraphicsScene *scene = d->paintArea->scene();
 148         if(scene->items().contains(d->line3))
 149         {
 150                 scene->removeItem(d->line3);
 151         }
 152
 153         BrushManager *brushManager = d->paintArea->brushManager();
 154
 155         scene->clearSelection();
 156
 157         if(!d->item)
 158         {
 159                 d->path = QPainterPath();
 160                 d->path.moveTo(input->scenePos());
 161
 162                 d->item = new YAMF::Item::Path();
 163                 d->item->setZValue(1000);
 164                 d->editor = new Drawing::Tool::Private::ContourEditor(d->item, scene);
 165                 connect(d->editor, SIGNAL(nodeClicked()), this, SLOT(nodeChanged()));
 166                 scene->addItem( d->item );
 167
 168                 d->begin = true;
 169                 d->moved = false;
 170         }
 171         else
 172         {
 173                 d->begin = false;
 174
 175                 if(!d->moved)
 176                 {
 177                         d->path.cubicTo(d->center, d->center, input->scenePos());
 178                         d->editor->save();
 179                         d->item->setPath(d->path);
 180                         d->paintArea->brushManager()->map(d->item);
 181                 }
 182                 else
 183                 {
 184                         d->moved = false;
 185                         d->path.cubicTo(d->center, d->right, input->scenePos());
 186                         d->editor->save();
 187                         d->item->setPath(d->path);
 188                         d->paintArea->brushManager()->map(d->item);
 189                 }
 190
 191         }
 192         d->center = input->scenePos();
 193
 194         d->item->setPen( brushManager->pen() );
 195 }
 196
 197 /**
 198  * @~spanish
 199  * Función sobrecargada para implementar la creación de los trazos rectos y curvilíneos.
 200  */
 201 void PolyLine::move(const QGraphicsSceneMouseEvent *input)
 202 {
 203         PaintArea *paintArea = this->paintArea();
 204         QGraphicsScene *scene = paintArea->scene();
 205         if(d->item)
 206         {
 207                 if(input->buttons() == Qt::NoButton)
 208                 {
 209                         QPainterPath lastPart;
 210
 211                         lastPart.moveTo(d->center);
 212
 213                         if(!d->moved)
 214                         {
 215 //                              lastPart.lineTo(input->scenePos());
 216                                 lastPart.cubicTo(d->center, d->center, input->scenePos());
 217                         }
 218                         else
 219                         {
 220                                 lastPart.cubicTo(d->center, d->right, input->scenePos());
 221                         }
 222
 223                         d->line3->setPath(lastPart);
 224                         if(!scene->items().contains(d->line3))
 225                         {
 226                                 scene->addItem(d->line3);
 227                         }
 228
 229                         if(!scene->items().contains(d->line1))
 230                         {
 231                                 scene->addItem( d->line1 );
 232                         }
 233                         if(!scene->items().contains(d->line2))
 234                         {
 235                                 scene->addItem( d->line2 );
 236                         }
 237                 }
 238                 else if(d->editor && d->editor->isSelected())
 239                 {
 240                         d->path = d->item->path();
 241                 }
 242                 else if(input->buttons() == Qt::LeftButton)
 243                 {
 244                         paintArea->setDragMode(QGraphicsView::NoDrag);
 245
 246                         if(d->begin)
 247                         {
 248                                 d->moved = true;
 249                                 d->right = input->scenePos();
 250
 251                                 d->line2->setLine(QLineF(d->right, d->center));
 252                                 if(!scene->items().contains(d->line2))
 253                                 {
 254                                         scene->addItem( d->line2 );
 255                                 }
 256                         }
 257                         else
 258                         {
 259                                 int index = d->path.elementCount()-3;
 260
 261                                 if( d->path.elementAt(index).type == QPainterPath::CurveToElement )
 262                                 {
 263                                         if(!d->moved)
 264                                         {
 265                                                 QPointF point = d->path.elementAt(index+1);
 266                                                 d->path.setElementPositionAt(index, point.x(), point.y() );
 267                                         }
 268
 269                                         QPointF mirror = d->center - ( input->scenePos() - d->center);
 270
 271                                         d->path.setElementPositionAt(index+1, mirror.x(), mirror.y());
 272
 273                                         d->line1->setLine(QLineF(mirror, d->center));
 274                                         d->line2->setLine(QLineF(d->right, d->center));
 275
 276                                         if(!scene->items().contains(d->line1))
 277                                         {
 278                                                 scene->addItem( d->line1 );
 279                                         }
 280                                         if(!scene->items().contains(d->line2))
 281                                         {
 282                                                 scene->addItem( d->line2 );
 283                                         }
 284                                 }
 285
 286                                 d->moved = true;
 287                                 d->right = input->scenePos();
 288                                 d->item->setPath(d->path);
 289                                 paintArea->brushManager()->map(d->item);
 290                         }
 291
 292                 }
 293         }
 294 }
 295
 296 /**
 297  * @~spanish
 298  * Función sobrecargada para implementar la creación de los trazos rectos y curvilíneos.
 299  */
 300 void PolyLine::release(const QGraphicsSceneMouseEvent *input)
 301 {
 302         Q_UNUSED(input);
 303         PaintArea *paintArea = this->paintArea();
 304
 305         d->editor->expandAllNodes ();
 306
 307
 308         if(d->begin)
 309         {
 310                 paintArea->currentFrame()->addItem(d->item);
 311         }
 312         else if(!d->editor->isSelected())
 313         {
 314                 int position  = paintArea->currentFrame()->visualIndexOf(d->item);
 315
 316                 if(position > -1)
 317                 {
 318                         paintArea->addCommand(new Command::EditNodesItem(d->item, d->editor->oldPath(), paintArea->currentFrame()));
 319                         d->editor->save();
 320                 }
 321         }
 322 }
 323
 324 /**
 325  * @~spanish
 326  * Función sobrecargada para implementar la creación de los trazos rectos y curvilíneos.
 327  * termina de hacer el trazo.
 328  */
 329 void PolyLine::doubleClick(const QGraphicsSceneMouseEvent *input)
 330 {
 331         Q_UNUSED(input);
 332
 333         endItem();
 334
 335 }
 336
 337 void PolyLine::keyPressEvent(QKeyEvent *event)
 338 {
 339         if(event->key() == Qt::Key_Escape)
 340         {
 341                 endItem();
 342                 event->accept();
 343         }
 344 }
 345
 346 /**
 347  * @~spanish
 348  * Retorna la acción que representa la herramienta.
 349  */
 350 DGui::Action *PolyLine::action() const
 351 {
 352         return d->action;
 353 }
 354
 355 /**
 356  * @~spanish
 357  * Retorna que la herramienta es de tipo Brush.
 358  */
 359 int PolyLine::type() const
 360 {
 361         return AbstractTool::Brush;
 362 }
 363
 364 /**
 365  * @~spanish
 366  * Función sobrecargada para terminar de crear el ítem, cuando se cambia la herramienta.
 367  */
 368 void PolyLine::aboutToChangeTool()
 369 {
 370         endItem();
 371 }
 372
 373 /**
 374  * Función sobrecargada para actualizar valores cuando hay un cambio en el fotograma.
 375  */
 376 void PolyLine::photogramChanged(Photogram *const photogram)
 377 {
 378         Q_UNUSED(photogram);
 379         if(d->item)
 380         {
 381 //              d->path = d->item->path();
 382 //              d->editor->setItem(d->item);
 383                 if(!d->item->path().isEmpty())
 384                 {
 385                         d->editor->show();
 386                 }
 387 //              d->editor->expandAllNodes();
 388                 int size = d->item->path().elementCount();
 389                 if(size > 0)
 390                 {
 391                         d->center = d->item->path().elementAt(size -1);
 392                 }
 393         }
 394 }
 395
 396 /**
 397  * @internal
 398  * Termina de crear el trazo.
 399  */
 400 void PolyLine::endItem()
 401 {
 402         if(d->item)
 403         {
 404                 d->path = QPainterPath();
 405                 d->item = 0;
 406                 delete d->editor;
 407                 d->editor = 0;
 408         }
 409 }
 410
 411 /**
 412  * @internal
 413  * Actualiza los valores cuando se modifican los nodos de trazo.
 414  */
 415 void PolyLine::nodeChanged()
 416 {
 417         if(d->paintArea)
 418         {
 419                 int position  = d->paintArea->currentFrame()->visualIndexOf(d->item);
 420
 421                 if(position != -1)
 422                 {
 423                         int size = d->item->path().elementCount();
 424                         if(size > 0)
 425                         {
 426                                 d->center = d->item->path().elementAt(size -1);
 427                         }
 428                         d->path = d->item->path();
 429                         d->paintArea->addCommand(new Command::EditNodesItem(d->item, d->editor->oldPath(), d->paintArea->currentFrame()));
 430                         d->editor->save();
 431                 }
 432         }
 433 }
 434
 435 }
 436 }
 437 }