yamf/item/builder.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 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 "builder.h"
  22
  23 #include <QGraphicsItem>
  24
  25 #include <dcore/debug.h>
  26
  27 #include "path.h"
  28 #include "pixmap.h"
  29 #include "text.h"
  30 #include "button.h"
  31 #include "rect.h"
  32 #include "ellipse.h"
  33 #include "line.h"
  34 #include "group.h"
  35 #include "polygon.h"
  36
  37 #include <dgraphics/algorithm.h>
  38 #include <dgraphics/pathhelper.h>
  39
  40 #include "serializer.h"
  41
  42 namespace YAMF {
  43 namespace Item {
  44
  45 struct Builder::Private
  46 {
  47         QGraphicsItem *item;
  48         QGradient *gradient;
  49         QString loading;//brush or pen
  50
  51         QStack<Group *> groups;
  52         QStack<QGraphicsItem *> objects;
  53
  54         bool addToGroup, isLoading;
  55
  56         QString textReaded;
  57 };
  58
  59
  60 /**
  61  * @~spanish
  62  * Constructor
  63  * @return
  64  */
  65 Builder::Builder() : DCore::XmlParserBase(), d(new Private)
  66 {
  67         d->item = 0;
  68         d->addToGroup = false;
  69         d->isLoading = false;
  70 }
  71
  72
  73 /**
  74  * @~spanish
  75  * Destructor
  76  * @return
  77  */
  78 Builder::~Builder()
  79 {
  80         delete d;
  81 }
  82
  83 /**
  84  * @~spanish
  85  * Retorna verdad si se esta cargando un ï¿½tem compuesto(grupo) o falso de lo contrario.
  86  * @return
  87  */
  88 bool Builder::addingToGroup() const
  89 {
  90         return d->addToGroup;
  91 }
  92
  93 /**
  94  * @~spanish
  95  * Si se esta cargando un ï¿½tem compuesto, esta funciï¿½n agrupara el ultimo item cargado al grupo que se esta cargando.
  96  */
  97 void Builder::addCurrentToGroup()
  98 {
  99         d->groups.last()->addToGroup(d->objects.last());
 100 }
 101
 102 /**
 103  * @~spanish
 104  * Si se esta cargando un ï¿½tem compuesto, Esta funciï¿½n coloca el ï¿½tem @p item en la pila de items para agrupar en el ï¿½tem que se esta cargando.
 105  */
 106 void Builder::push(QGraphicsItem *item)
 107 {
 108         d->objects << item;
 109 }
 110
 111 /**
 112  * @~spanish
 113  * Si se esta cargando un ï¿½tem compuesto, Esta funciï¿½n retira de la pila el ï¿½tem que ya fue agrupado al ï¿½tem que se esta cargando.
 114  */
 115 void Builder::pop()
 116 {
 117         d->objects.pop();
 118 }
 119
 120 /**
 121  * @~spanish
 122  * Crea el ï¿½tem a construir a partir de la raï¿½z del documento.
 123  */
 124 QGraphicsItem* Builder::createItem(const QString &root)
 125 {
 126         QGraphicsItem* item = 0;
 127         if ( root == "path" )
 128         {
 129                 item = new Path;
 130         }
 131         else if ( root == "rect" )
 132         {
 133                 item = new Rect;
 134         }
 135         else if ( root == "ellipse" )
 136         {
 137                 item = new Ellipse;
 138         }
 139         else if ( root == "button" )
 140         {
 141                 item = new Button;
 142         }
 143         else if ( root == "text" )
 144         {
 145                 item = new Text;
 146         }
 147         else if ( root == "line" )
 148         {
 149                 item = new Line;
 150         }
 151         else if ( root == "polygon" )
 152         {
 153                 item = new Polygon;
 154         }
 155         else if ( root == "group" )
 156         {
 157                 item = new Group;
 158         }
 159
 160         return item;
 161 }
 162
 163 /**
 164  * @~spanish
 165  * Analiza etiquetas de apertura del documento XML, para extraer las propiedades del ï¿½tem.
 166 */
 167 bool Builder::startTag( const QString& qname, const QXmlAttributes& atts)
 168 {
 169         D_FUNCINFOX("items") << qname;
 170         if ( qname == "path" )
 171         {
 172                 QString data = atts.value("data");
 173                 if( data.isNull() )
 174                 {
 175                         data = atts.value("d");
 176                 }
 177
 178                 QPainterPath path = DGraphics::PathHelper::fromString( data );
 179
 180                 if ( d->addToGroup )
 181                 {
 182                         QGraphicsItem *item = createItem(qname);
 183                         qgraphicsitem_cast<Path *>(item)->setPath(path);
 184
 185                         d->objects.push(item);
 186                 }
 187                 else
 188                 {
 189                         if ( !d->item )
 190                                 d->item = createItem( qname );
 191
 192                         qgraphicsitem_cast<Path *>(d->item)->setPath(path);
 193
 194                         d->objects.push(d->item);
 195                 }
 196         }
 197         else if ( qname == "rect" )
 198         {
 199                 QRectF rect(atts.value("x").toDouble(), atts.value("y").toDouble(), atts.value("width").toDouble(), atts.value("height").toDouble() );
 200
 201                 if( d->addToGroup )
 202                 {
 203                         Rect *item = qgraphicsitem_cast<Rect *>(createItem(qname));
 204                         item->setRect(rect);
 205
 206
 207                         d->objects.push(item);
 208                 }
 209                 else
 210                 {
 211                         if ( !d->item )
 212                                 d->item = createItem( qname );
 213                         qgraphicsitem_cast<Rect *>(d->item)->setRect(rect);
 214
 215                         d->objects.push(d->item);
 216                 }
 217         }
 218         else if ( qname == "ellipse" )
 219         {
 220                 double rx = atts.value("rx").toDouble();
 221                 double ry = atts.value("ry").toDouble();
 222                 double cx = atts.value("cx").toDouble();
 223                 double cy = atts.value("cy").toDouble();
 224
 225                 QRectF rect(QPointF(cx-rx, cy-ry), QSizeF(2 * rx, 2 * ry ));
 226
 227                 if( d->addToGroup )
 228                 {
 229                         Ellipse *item = qgraphicsitem_cast<Ellipse *>(createItem(qname));
 230                         item->setRect(rect);
 231
 232                         d->objects.push(item);
 233                 }
 234                 else
 235                 {
 236                         if ( !d->item )
 237                                 d->item = createItem( qname );
 238
 239                         qgraphicsitem_cast<Ellipse *>(d->item)->setRect(rect);
 240
 241                         d->objects.push(d->item);
 242                 }
 243
 244         }
 245         else if ( qname == "button" )
 246         {
 247                 if ( !d->item )
 248                 {
 249                         d->item = createItem( qname );
 250                         d->objects.push(d->item);
 251                 }
 252
 253                 if( d->addToGroup )
 254                 {
 255 //                      d->groups.last()->addToGroup( createItem( qname ) );
 256                 }
 257         }
 258         else if ( qname == "text" )
 259         {
 260                 double width = atts.value("width").toDouble();
 261                 QColor textColor(atts.value("text-color"));
 262                 QString text = atts.value("data");
 263
 264                 if( d->addToGroup )
 265                 {
 266                         Text *item = qgraphicsitem_cast<Text *>(createItem( qname ));
 267
 268                         item->setTextWidth(width);
 269                         item->setDefaultTextColor(textColor);
 270                         item->setPlainText(text);
 271
 272                         d->objects.push(item);
 273                 }
 274                 else
 275                 {
 276                         if ( !d->item )
 277                                 d->item = createItem( qname );
 278
 279                         Text *item = qgraphicsitem_cast<Text *>(d->item);
 280
 281                         item->setTextWidth(width);
 282                         item->setDefaultTextColor(textColor);
 283                         item->setPlainText(text);
 284
 285                         d->objects.push(d->item);
 286                 }
 287
 288 //              setReadText(true);
 289 //              d->textReaded = "";
 290         }
 291         else if ( qname == "line" )
 292         {
 293                 QLineF line(atts.value("x1").toDouble(), atts.value("y1").toDouble(), atts.value("x2").toDouble(), atts.value("y2").toDouble());
 294
 295                 if( d->addToGroup )
 296                 {
 297                         Line *item = qgraphicsitem_cast<Line *>(createItem(qname));
 298                         item->setLine(line);
 299
 300                         d->objects.push(item);
 301                 }
 302                 else
 303                 {
 304                         if ( !d->item )
 305                                 d->item = createItem( qname );
 306
 307                         qgraphicsitem_cast<Line *>(d->item)->setLine(line);
 308                         d->objects.push(d->item);
 309                 }
 310         }
 311         else if( qname == "polygon")
 312         {
 313                 QRectF rect(atts.value("x").toDouble(), atts.value("y").toDouble(), atts.value("width").toDouble(), atts.value("height").toDouble() );
 314
 315                 int corners = atts.value("corners").toInt();
 316                 double start = atts.value("start").toDouble();
 317
 318                 if( d->addToGroup )
 319                 {
 320                         Polygon *item = qgraphicsitem_cast<Polygon *>(createItem(qname));
 321
 322                         item->setCorners(corners);
 323                         item->setStart(start);
 324                         item->setRect(rect);
 325
 326                         d->objects.push(item);
 327                 }
 328                 else
 329                 {
 330                         if ( !d->item )
 331                                 d->item = createItem( qname );
 332
 333                         qgraphicsitem_cast<Polygon *>(d->item)->setCorners(corners);
 334                         qgraphicsitem_cast<Polygon *>(d->item)->setStart(start);
 335                         qgraphicsitem_cast<Polygon *>(d->item)->setRect(rect);
 336
 337                         d->objects.push(d->item);
 338                 }
 339         }
 340         else if ( qname == "group" )
 341         {
 342                 if( d->addToGroup )
 343                 {
 344                         Group *group = qgraphicsitem_cast<Group *>( createItem(qname) );
 345
 346                         d->groups.push(group);
 347                         d->objects.push(group);
 348                 }
 349                 else
 350                 {
 351                         if ( !d->item )
 352                                 d->item = createItem( qname );
 353                         d->groups.push(qgraphicsitem_cast<Group *>(d->item));
 354                         d->objects.push(d->item);
 355                 }
 356
 357                 d->addToGroup = true;
 358         }
 359
 360         //////////
 361
 362         if ( qname == "properties" && !d->objects.isEmpty() )
 363         {
 364                 Serializer::loadProperties( d->objects.last(), atts);
 365         }
 366         else if ( qname == "brush" )
 367         {
 368                 QBrush brush;
 369                 Serializer::loadBrush( brush, atts);
 370
 371                 if ( currentTag() == "pen" )
 372                 {
 373                         d->loading = "pen";
 374                         QPen pen = itemPen();
 375                         pen.setBrush(brush);
 376                         setItemPen( pen );
 377                 }
 378                 else
 379                 {
 380                         d->loading = qname;
 381                         setItemBrush( brush );
 382                 }
 383         }
 384         else if ( qname == "pen" )
 385         {
 386                 QPen pen;
 387                 d->loading = qname;
 388                 Serializer::loadPen( pen, atts);
 389                 setItemPen( pen );
 390         }
 391         else if ( qname == "font" )
 392         {
 393                 QFont font;
 394
 395                 Serializer::loadFont( font, atts);
 396
 397                 if ( Text *text = qgraphicsitem_cast<Text *>(d->objects.last()) )
 398                 {
 399                         text->setFont(font);
 400                         text->setPlainText(text->toPlainText());
 401                 }
 402         }
 403         else if(qname == "stop")
 404         {
 405                 if(d->gradient)
 406                 {
 407                         QColor c(atts.value("color"));
 408                         c.setAlpha(atts.value("alpha").toInt());
 409                         d->gradient->setColorAt ( atts.value("value").toDouble(), c);
 410                 }
 411         }
 412         else if(qname == "gradient")
 413         {
 414                 d->gradient = Serializer::createGradient( atts);
 415         }
 416
 417         return true;
 418 }
 419
 420 /**
 421  * @~spanish
 422  * Analiza el texto del documento XML, para extraer las propiedades del ï¿½tem.
 423 */
 424
 425 void Builder::text ( const QString & ch )
 426 {
 427         d->textReaded += ch;
 428 }
 429
 430 /**
 431  * @~spanish
 432  * Analiza etiquetas de cierre del documento XML, para extraer las propiedades del ï¿½tem.
 433 */
 434 bool Builder::endTag(const QString& qname)
 435 {
 436         D_FUNCINFOX("items") << qname;
 437         if ( qname == "path" )
 438         {
 439                 if(d->addToGroup)
 440                 {
 441                         d->groups.last()->addToGroup(d->objects.last());
 442                 }
 443                 d->objects.pop();
 444         }
 445         else if ( qname == "rect" )
 446         {
 447                 if(d->addToGroup)
 448                 {
 449                         d->groups.last()->addToGroup(d->objects.last());
 450                 }
 451                 d->objects.pop();
 452         }
 453         else if ( qname == "ellipse" )
 454         {
 455                 if(d->addToGroup)
 456                 {
 457                         d->groups.last()->addToGroup(d->objects.last());
 458                 }
 459                 d->objects.pop();
 460         }
 461         else if( qname == "line" )
 462         {
 463                 if(d->addToGroup)
 464                 {
 465                         d->groups.last()->addToGroup(d->objects.last());
 466                 }
 467                 d->objects.pop();
 468         }
 469         else if ( qname == "button" )
 470         {
 471                 if(d->addToGroup)
 472                 {
 473                         d->groups.last()->addToGroup(d->objects.last());
 474                 }
 475                 d->objects.pop();
 476         }
 477         else if ( qname == "text" )
 478         {
 479                 if(d->addToGroup)
 480                 {
 481                         d->groups.last()->addToGroup(d->objects.last());
 482                 }
 483                 d->objects.pop();
 484         }
 485         else if ( qname == "group" )
 486         {
 487                 d->groups.pop();
 488                 d->addToGroup = !d->groups.isEmpty();
 489
 490                 if(d->addToGroup)
 491                 {
 492                         d->groups.last()->addToGroup(d->objects.last());
 493                 }
 494
 495                 d->objects.pop();
 496         }
 497         else if( qname == "gradient")
 498         {
 499                 if(d->loading == "brush")
 500                 {
 501                         setItemGradient(*d->gradient, true);
 502                 }
 503                 else
 504                 {
 505                         setItemGradient(*d->gradient, false);
 506                 }
 507         }
 508         else
 509         {
 510                 dWarning("items") << "Unhandled: " << qname;
 511         }
 512
 513         return true;
 514 }
 515
 516
 517
 518 /**
 519  * @internal
 520  * @~spanish
 521  * Pone el estilo de linea al ï¿½tem que se esta construyendo actualmente.
 522  */
 523 void Builder::setItemPen(const QPen &pen)
 524 {
 525         if(d->objects.isEmpty() ) return;
 526
 527         if(QGraphicsLineItem *line = qgraphicsitem_cast<QGraphicsLineItem *>(d->objects.last()) )
 528         {
 529                 line->setPen(pen);
 530         }
 531         else if ( QAbstractGraphicsShapeItem *shape = qgraphicsitem_cast<QAbstractGraphicsShapeItem *>(d->objects.last() ) )
 532         {
 533                 shape->setPen(pen);
 534         }
 535 }
 536
 537 /**
 538  * @internal
 539  * @~spanish
 540  * Pone la brocha al ï¿½tem que se esta construyendo actualmente.
 541  */
 542 void Builder::setItemBrush(const QBrush &brush)
 543 {
 544         if(d->objects.isEmpty() ) return;
 545
 546         if ( QAbstractGraphicsShapeItem *shape = qgraphicsitem_cast<QAbstractGraphicsShapeItem *>(d->objects.last() ) )
 547         {
 548                 shape->setBrush(brush);
 549         }
 550
 551 }
 552
 553 /**
 554  * @internal
 555  * @~spanish
 556  * Pone un degradado al relleno o al estilo de linea dependiendo del valor de @p brush, al ï¿½tem que se esta construyendo actualmente.
 557  */
 558 void  Builder::setItemGradient(const QGradient& gradient, bool brush)
 559 {
 560         if(d->objects.isEmpty() ) return;
 561
 562         QBrush gBrush(gradient);
 563         if ( QAbstractGraphicsShapeItem *shape = qgraphicsitem_cast<QAbstractGraphicsShapeItem *>(d->objects.last() ) )
 564         {
 565                 if(brush)
 566                 {
 567                         gBrush.setMatrix(shape->brush().matrix());
 568                         shape->setBrush( gBrush );
 569                 }
 570                 else
 571                 {
 572                         gBrush.setMatrix(shape->pen().brush().matrix());
 573                         QPen pen = shape->pen();
 574                         pen.setBrush(gBrush);
 575                         shape->setPen(pen);
 576                 }
 577         }
 578         else if(QGraphicsLineItem *line = qgraphicsitem_cast<QGraphicsLineItem *>(d->objects.last()) )
 579         {
 580                 gBrush.setMatrix(line->pen().brush().matrix());
 581                 QPen pen = line->pen();
 582                 pen.setBrush(gBrush);
 583                 line->setPen(pen);
 584         }
 585 }
 586
 587 /**
 588  * @internal
 589  * @~spanish
 590  * Obtiene el estilo de linea del ï¿½tem que se esta construyendo actualmente.
 591  */
 592 QPen Builder::itemPen() const
 593 {
 594         if( ! d->objects.isEmpty() )
 595         {
 596                 if(QGraphicsLineItem *line = qgraphicsitem_cast<QGraphicsLineItem *>(d->objects.last()) )
 597                 {
 598                         return line->pen();
 599                 }
 600                 else if ( QAbstractGraphicsShapeItem *shape = qgraphicsitem_cast<QAbstractGraphicsShapeItem *>(d->objects.last() ) )
 601                 {
 602                         return shape->pen();
 603                 }
 604         }
 605         return QPen(Qt::transparent, 1);
 606 }
 607
 608 /**
 609  * @internal
 610  * @~spanish
 611  * Obtiene el relleno del ï¿½tem que se esta construyendo actualmente.
 612  */
 613
 614 QBrush Builder::itemBrush() const
 615 {
 616         if( ! d->objects.isEmpty() )
 617         {
 618                 if ( QAbstractGraphicsShapeItem *shape = qgraphicsitem_cast<QAbstractGraphicsShapeItem *>(d->objects.last() ) )
 619                 {
 620                         return shape->brush();
 621                 }
 622         }
 623         return Qt::transparent;
 624 }
 625
 626 /**
 627  * @~spanish
 628  * Retorna verdad si se le asigna exitosamente los datos que contiene el documento @p xml al @p item. o falso de lo contrario.
 629  */
 630 bool Builder::loadItem(QGraphicsItem *item, const QString &xml)
 631 {
 632         d->item = item;
 633
 634         d->isLoading = true;
 635
 636         bool ok = parse(xml);
 637
 638         d->isLoading = false;
 639         return ok;
 640 }
 641
 642 /**
 643  * @~spanish
 644  * Pone el ï¿½tem en el cual se van a cargar los datos del documento xml.
 645  */
 646 void Builder::setItem(QGraphicsItem *item)
 647 {
 648         d->item = item;
 649 }
 650
 651 /**
 652  * @~spanish
 653  * Retorna el ï¿½tem que se esta construyendo actualmente.
 654  */
 655 QGraphicsItem *Builder::item() const
 656 {
 657         return d->item;
 658 }
 659
 660
 661 /**
 662  * @~spanish
 663  * Retorna un ï¿½tem construido a partir de documento @p xml.
 664 */
 665 QGraphicsItem *Builder::create(const QString &xml)
 666 {
 667         if( loadItem(0, xml) )
 668         {
 669                 return d->item;
 670         }
 671
 672         return 0;
 673 }
 674
 675
 676 }
 677 }
 678