yamf/item/serializer.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 "serializer.h"
  22
  23 #include <QGraphicsItem>
  24 #include <QFont>
  25 #include <QXmlStreamReader>
  26 #include <QXmlStreamWriter>
  27
  28 #include <dcore/debug.h>
  29
  30 #include <private/svg2qt.h>
  31
  32 namespace YAMF {
  33 namespace Item {
  34
  35 Serializer::Serializer()
  36 {
  37 }
  38
  39
  40 Serializer::~Serializer()
  41 {
  42 }
  43
  44 /**
  45  * @~spanish
  46  * Convierte las propiedades del @p item a un elemento del documento xml @p doc.
  47  */
  48 QDomElement Serializer::properties(const QGraphicsItem *item, QDomDocument &doc)
  49 {
  50         QDomElement properties = doc.createElement("properties");
  51
  52         QString strMatrix = YAMF::Item::Private::Svg2Qt::matrixToString(item->matrix());
  53         properties.setAttribute( "transform", strMatrix);
  54
  55         properties.setAttribute( "pos", YAMF::Item::Private::Svg2Qt::pointToString(item->pos()) );
  56         properties.setAttribute("z", item->zValue());
  57
  58         properties.setAttribute( "enabled", item->isEnabled());
  59 //      properties.setAttribute( "flags", item->flags());
  60
  61
  62         return properties;
  63 }
  64
  65 /**
  66  * @~spanish
  67  * Grava las propiedades del @p item en un Xml.
  68  */
  69 void Serializer::properties(const QGraphicsItem *item, QXmlStreamWriter *writer)
  70 {
  71         writer->writeStartElement("properties");
  72
  73         QString strMatrix = YAMF::Item::Private::Svg2Qt::matrixToString(item->matrix());
  74         writer->writeAttribute("transform", strMatrix);
  75
  76         writer->writeAttribute( "pos", YAMF::Item::Private::Svg2Qt::pointToString(item->pos()) );
  77         writer->writeAttribute("z", QString::number(item->zValue()));
  78
  79         writer->writeAttribute( "enabled", item->isEnabled() ? "1" : "0" );
  80
  81 //      writer->writeAttribute( "flags", QString::number(item->flags()) );
  82
  83         writer->writeEndElement();
  84 }
  85
  86
  87 /**
  88  * @~spanish
  89  * Asigna las propiedades que estï¿½n el los atributos de un documento xml @p atts al ï¿½tem @p item.
  90  */
  91 void Serializer::loadProperties(QGraphicsItem *item, const QXmlAttributes &atts)
  92 {
  93         QMatrix matrix;
  94         Item::Private::Svg2Qt::svgmatrix2qtmatrix( atts.value("transform"), matrix );
  95         item->setMatrix(matrix);
  96
  97         QPointF pos;
  98         Item::Private::Svg2Qt::parsePointF(atts.value("pos"), pos );
  99         item->setPos( pos );
 100
 101         item->setEnabled(atts.value("enabled") != "0"); // default true
 102
 103 //      item->setFlags( static_cast<QGraphicsItem::GraphicsItemFlags>(atts.value("flags").toInt()) );
 104
 105         item->setZValue( atts.value("z").toDouble() );
 106 }
 107
 108
 109 /**
 110  * @~spanish
 111  * Asigna las propiedades que estï¿½n en un elemento de un documento xml @p e al ï¿½tem @p item.
 112  */
 113 void Serializer::loadProperties(QGraphicsItem *item, const QDomElement &element)
 114 {
 115         if ( element.tagName() == "properties" )
 116         {
 117                 QMatrix matrix;
 118                 Item::Private::Svg2Qt::svgmatrix2qtmatrix( element.attribute( "transform"), matrix );
 119
 120                 item->setMatrix(matrix);
 121
 122                 QPointF pos;
 123                 Item::Private::Svg2Qt::parsePointF(element.attribute("pos"), pos );
 124                 item->setPos( pos );
 125
 126                 item->setEnabled(element.attribute("enabled") != "0");
 127
 128 //              item->setFlags( QGraphicsItem::GraphicsItemFlags(element.attribute("flags").toInt()) );
 129
 130                 item->setZValue( element.attribute("z").toDouble() );
 131         }
 132 }
 133
 134 /**
 135  * @~spanish
 136  * Asigna las propiedades al item, desde un XML
 137  * @param item
 138  * @param reader
 139  */
 140 void Serializer::loadProperties(QGraphicsItem *item, const QString &properties)
 141 {
 142         QXmlStreamReader reader(properties);
 143
 144         while( !reader.atEnd() )
 145         {
 146                 if( reader.readNext() == QXmlStreamReader::StartElement )
 147                 {
 148                         if( reader.name() == "properties" )
 149                         {
 150                                 loadProperties(item, &reader);
 151                                 break;
 152                         }
 153                 }
 154         }
 155 }
 156
 157 /**
 158  * @~spanish
 159  * Asigna las propiedades al item, desde un QXmlStreamReader
 160  * @param item
 161  * @param reader
 162  */
 163 void Serializer::loadProperties(QGraphicsItem *item, QXmlStreamReader *reader)
 164 {
 165         if( reader->name().toString() == "properties" )
 166         {
 167                 foreach(QXmlStreamAttribute att, reader->attributes() )
 168                 {
 169                         QString name = att.name().toString();
 170
 171                         if( name == "transform" )
 172                         {
 173                                 QMatrix matrix;
 174                                 Item::Private::Svg2Qt::svgmatrix2qtmatrix( att.value().toString(), matrix );
 175
 176                                 item->setMatrix(matrix);
 177                         }
 178                         else if( name == "pos" )
 179                         {
 180                                 QPointF pos;
 181                                 Item::Private::Svg2Qt::parsePointF(att.value().toString(), pos );
 182
 183                                 item->setPos( pos );
 184                         }
 185                         else if( name == "enabled" )
 186                         {
 187                                 item->setEnabled(att.value().toString() != "0");
 188                         }
 189 //                      else if( name == "flags" )
 190 //                      {
 191 //                              item->setFlags( QGraphicsItem::GraphicsItemFlags(att.value().toString().toInt()) );
 192 //                      }
 193                         else if( name == "z" )
 194                         {
 195                                 item->setZValue( att.value().toString().toDouble() );
 196                         }
 197                 }
 198         }
 199 }
 200
 201
 202 /**
 203  * @~spanish
 204  * Convierte un gradiente @p grandient a un elemento del documento xml @p doc.
 205  */
 206 QDomElement Serializer::gradient(const QGradient *gradient, QDomDocument &doc)
 207 {
 208         QDomElement element = doc.createElement("gradient");
 209         element.setAttribute("type", gradient->type() );
 210         element.setAttribute("spread", gradient->spread() );
 211
 212         switch(gradient->type() )
 213         {
 214                 case QGradient::LinearGradient:
 215                 {
 216                         element.setAttribute("start", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QLinearGradient *>(gradient)->start()) );
 217                         element.setAttribute("final", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QLinearGradient *>(gradient)->finalStop() ));
 218                 }
 219                 break;
 220                 case QGradient::RadialGradient:
 221                 {
 222                         element.setAttribute("center", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QRadialGradient *>(gradient)->center()) );
 223
 224                         element.setAttribute("focal", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QRadialGradient *>(gradient)->focalPoint()) );
 225
 226                         element.setAttribute("radius", static_cast<const QRadialGradient *>(gradient)->radius() );
 227                 }
 228                 break;
 229                 case QGradient::ConicalGradient:
 230                 {
 231                         element.setAttribute("center", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QConicalGradient *>(gradient)->center()) );
 232                         element.setAttribute("angle", static_cast<const QConicalGradient *>(gradient)->angle() );
 233                 }
 234                 break;
 235                 case QGradient::NoGradient:
 236                 {
 237
 238                 }
 239                 break;
 240         }
 241
 242         QGradientStops stops = gradient->stops();
 243
 244         foreach(QGradientStop stop, stops)
 245         {
 246                 QDomElement stopElement = doc.createElement("stop");
 247                 stopElement.setAttribute("value", stop.first );
 248                 stopElement.setAttribute("color", stop.second.name());
 249                 stopElement.setAttribute("alpha", stop.second.alpha());
 250                 element.appendChild(stopElement);
 251         }
 252
 253         return element;
 254 }
 255
 256 /**
 257  * @~spanish
 258  * Escribe el gradiente utilizando @p writer
 259  * @param gradient
 260  * @param writer
 261  */
 262 void Serializer::gradient(const QGradient *gradient, QXmlStreamWriter *writer)
 263 {
 264         writer->writeStartElement("gradient");
 265         writer->writeAttribute("type", QString::number(gradient->type()) );
 266         writer->writeAttribute("spread", QString::number(gradient->spread()) );
 267
 268         switch(gradient->type() )
 269         {
 270                 case QGradient::LinearGradient:
 271                 {
 272                         writer->writeAttribute("start", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QLinearGradient *>(gradient)->start()));
 273
 274                         writer->writeAttribute("final", YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QLinearGradient *>(gradient)->finalStop() ));
 275                 }
 276                 break;
 277                 case QGradient::RadialGradient:
 278                 {
 279                         writer->writeAttribute("center",  YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QRadialGradient *>(gradient)->center()) );
 280
 281                         writer->writeAttribute("focal",  YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QRadialGradient *>(gradient)->focalPoint()) );
 282
 283                         writer->writeAttribute("radius", QString::number(static_cast<const QRadialGradient *>(gradient)->radius()) );
 284                 }
 285                 break;
 286                 case QGradient::ConicalGradient:
 287                 {
 288                         writer->writeAttribute("center",  YAMF::Item::Private::Svg2Qt::pointToString(static_cast<const QConicalGradient *>(gradient)->center()) );
 289
 290                         writer->writeAttribute("angle", QString::number(static_cast<const QConicalGradient *>(gradient)->angle()) );
 291                 }
 292                 break;
 293                 case QGradient::NoGradient:
 294                 {
 295
 296                 }
 297                 break;
 298         }
 299
 300         QGradientStops stops = gradient->stops();
 301
 302         foreach(QGradientStop stop, stops)
 303         {
 304                 writer->writeStartElement("stop");
 305                 writer->writeAttribute("value", QString::number(stop.first) );
 306                 writer->writeAttribute("color", stop.second.name());
 307                 writer->writeAttribute("alpha", QString::number(stop.second.alpha()));
 308                 writer->writeEndElement();
 309         }
 310
 311         writer->writeEndElement();
 312 }
 313
 314
 315 /**
 316  * @~spanish
 317  * Crea un degradado con los atributos de un elemento del documento xml @p atts.
 318  * @return
 319  */
 320 QGradient *Serializer::createGradient(const QXmlAttributes &atts)
 321 {
 322         QGradient *result = 0;
 323         switch(atts.value("type").toInt() )
 324         {
 325                 case QGradient::LinearGradient:
 326                 {
 327                         QPointF start, final;
 328                         YAMF::Item::Private::Svg2Qt::parsePointF(atts.value("start"), start);
 329                         YAMF::Item::Private::Svg2Qt::parsePointF(atts.value("final"), final);
 330
 331                         result = new QLinearGradient( start, final );
 332                 }
 333                 break;
 334                 case QGradient::RadialGradient:
 335                 {
 336                         QPointF center, focal;
 337                         YAMF::Item::Private::Svg2Qt::parsePointF(atts.value("center"), center);
 338                         YAMF::Item::Private::Svg2Qt::parsePointF(atts.value("focal"), focal);
 339
 340
 341                         result = new QRadialGradient(center, atts.value("radius").toDouble(), focal);
 342                 }
 343                 break;
 344                 case QGradient::ConicalGradient:
 345                 {
 346                         QPointF center;
 347                         YAMF::Item::Private::Svg2Qt::parsePointF(atts.value("center"), center);
 348
 349                         result = new QConicalGradient(center, atts.value("angle").toDouble());
 350                 }
 351                 break;
 352                 case QGradient::NoGradient:
 353                 {
 354                         result = 0;
 355                 }
 356                 break;
 357         }
 358
 359         if(!result)
 360         {
 361                 return 0;
 362         }
 363         result->setSpread(QGradient::Spread( atts.value("spread").toInt() ) );
 364         return result;
 365 }
 366
 367 QGradient *Serializer::loadGradient(QXmlStreamReader *reader)
 368 {
 369         QGradient *result = 0;
 370
 371         Q_ASSERT(QXmlStreamReader::NoToken != reader->tokenType());
 372         Q_ASSERT(reader->tokenType() != QXmlStreamReader::StartDocument);
 373
 374         if(reader->name().toString() == "gradient")
 375         {
 376                 switch(reader->attributes().value("type").toString().toInt() )
 377                 {
 378                         case QGradient::LinearGradient:
 379                         {
 380                                 QPointF start, final;
 381                                 YAMF::Item::Private::Svg2Qt::parsePointF(reader->attributes().value("start").toString(), start);
 382                                 YAMF::Item::Private::Svg2Qt::parsePointF(reader->attributes().value("final").toString(), final);
 383
 384                                 result = new QLinearGradient(start,     final);
 385                         }
 386                         break;
 387                         case QGradient::RadialGradient:
 388                         {
 389                                 QPointF center, focal;
 390                                 YAMF::Item::Private::Svg2Qt::parsePointF(reader->attributes().value("center").toString(), center);
 391                                 YAMF::Item::Private::Svg2Qt::parsePointF(reader->attributes().value("focal").toString(), focal);
 392                                 qreal radius = reader->attributes().value("radius").toString().toDouble();
 393
 394                                 result = new QRadialGradient(center, radius, focal);
 395                         }
 396                         break;
 397                         case QGradient::ConicalGradient:
 398                         {
 399                                 QPointF center;
 400                                 YAMF::Item::Private::Svg2Qt::parsePointF(reader->attributes().value("center").toString(), center);
 401                                 qreal angle = reader->attributes().value("angle").toString().toDouble();
 402                                 result = new QConicalGradient(center, angle);
 403                         }
 404                         break;
 405                         default: break;
 406                 }
 407         }
 408
 409         if(!result)
 410         {
 411                 return 0;
 412         }
 413
 414         result->setSpread(QGradient::Spread( reader->attributes().value("spread").toString().toInt() ) );
 415
 416         while(!reader->atEnd())
 417         {
 418                 if( reader->readNext() == QXmlStreamReader::StartElement )
 419                 {
 420                         if( reader->name() == "stop" )
 421                         {
 422                                 double value = 0.0;
 423                                 QString colorName;
 424                                 int alpha = 0;
 425                                 foreach(QXmlStreamAttribute att, reader->attributes())
 426                                 {
 427                                         if( att.name() == "value" )
 428                                         {
 429                                                 value = att.value().toString().toDouble();
 430                                         }
 431                                         else if( att.name() == "color" )
 432                                         {
 433                                                 colorName = att.value().toString();
 434                                         }
 435                                         else if( att.name() == "alpha" )
 436                                         {
 437                                                 alpha = att.value().toString().toInt();
 438                                         }
 439                                 }
 440
 441                                 QColor color(colorName);
 442                                 color.setAlpha(alpha);
 443                                 result->setColorAt(value, color);
 444                         }
 445                 }
 446                 else if(reader->tokenType() == QXmlStreamReader::EndElement )
 447                 {
 448                         if( reader->name() == "gradient" )
 449                         {
 450                                 break;
 451                         }
 452                 }
 453         }
 454
 455         return result;
 456 }
 457
 458 /**
 459  * @~spanish
 460  * Crea un gradient con un documento xml @p doc.
 461  */
 462 QGradient *Serializer::loadGradient(const QString &doc)
 463 {
 464         QXmlStreamReader reader(doc);
 465
 466         while(!reader.atEnd() )
 467         {
 468                 if( reader.readNext() == QXmlStreamReader::StartElement )
 469                 {
 470                         if( reader.name() == "gradient" )
 471                         {
 472                                 return loadGradient(&reader);
 473                         }
 474                 }
 475         }
 476
 477         return 0;
 478 }
 479
 480 /**
 481  * @~spanish
 482  * Crea una brocha con un documento xml @p doc.
 483  */
 484 QDomElement Serializer::brush(const QBrush *brush, QDomDocument &doc)
 485 {
 486         QDomElement brushElement = doc.createElement("brush");
 487
 488         brushElement.setAttribute( "style", brush->style());
 489
 490
 491         if ( brush->gradient() )
 492         {
 493                 brushElement.appendChild( gradient( brush->gradient() , doc));
 494         }
 495         else if(brush->color().isValid())
 496         {
 497                 brushElement.setAttribute( "color", brush->color().name() );
 498                 brushElement.setAttribute( "alpha", brush->color().alpha());
 499         }
 500
 501         QString strMatrix = YAMF::Item::Private::Svg2Qt::matrixToString(brush->matrix());
 502
 503         brushElement.setAttribute( "transform", strMatrix);
 504         return brushElement;
 505 }
 506
 507
 508 /**
 509  * @~spanish
 510  * Guarda los valores de una brocha usando @p writer
 511  */
 512 void Serializer::brush(const QBrush *brush, QXmlStreamWriter *writer)
 513 {
 514
 515         writer->writeStartElement("brush");
 516         writer->writeAttribute( "style", QString::number(brush->style()));
 517
 518         QString strMatrix = YAMF::Item::Private::Svg2Qt::matrixToString(brush->matrix());
 519         writer->writeAttribute( "transform", strMatrix);
 520
 521         if ( brush->gradient() )
 522         {
 523                 Serializer::gradient( brush->gradient() , writer);
 524         }
 525         else if(brush->color().isValid())
 526         {
 527                 writer->writeAttribute( "color", brush->color().name() );
 528                 writer->writeAttribute( "alpha", QString::number(brush->color().alpha()) );
 529         }
 530
 531         writer->writeEndElement();
 532 }
 533
 534 /**
 535  * Carga la brocha utilizando @p reader
 536  * @param brush
 537  * @param reader
 538  */
 539 void Serializer::loadBrush(QBrush &brush, QXmlStreamReader *reader)
 540 {
 541         if( reader->name().toString() == "brush" )
 542         {
 543                 Qt::BrushStyle style = static_cast<Qt::BrushStyle>(reader->attributes().value("style").toString().toInt());
 544
 545                 QMatrix matrix;
 546                 Item::Private::Svg2Qt::svgmatrix2qtmatrix( reader->attributes().value("transform").toString(), matrix );
 547                 brush.setMatrix(matrix);
 548
 549                 QString color = reader->attributes().value("color").toString();
 550
 551                 if(!color.isEmpty())
 552                 {
 553                         QColor c(color);
 554                         c.setAlpha(reader->attributes().value("alpha").toString().toInt());
 555                         brush.setColor(c);
 556
 557                         brush.setStyle(style);
 558                 }
 559                 else
 560                 {
 561                         if( reader->readNext() == QXmlStreamReader::StartElement )
 562                         {
 563                                 if( reader->name() == "gradient" )
 564                                 {
 565                                         QGradient *gradient = loadGradient(reader);
 566
 567                                         QBrush nbrush(*gradient);
 568
 569                                         nbrush.setMatrix(brush.matrix());
 570
 571                                         brush = nbrush;
 572
 573                                         delete gradient;
 574                                 }
 575                         }
 576                 }
 577         }
 578 }
 579
 580 /**
 581  * Carga una brush utilizando el documento xml @p doc
 582  * @param brush
 583  * @param doc
 584  */
 585 void Serializer::loadBrush(QBrush &brush, const QString &doc)
 586 {
 587         QXmlStreamReader reader(doc);
 588
 589         while( !reader.atEnd() )
 590         {
 591                 if( reader.readNext() == QXmlStreamReader::StartElement )
 592                 {
 593                         if( reader.name() == "brush" )
 594                         {
 595                                 Serializer::loadBrush(brush, &reader);
 596                                 break;
 597                         }
 598                 }
 599         }
 600 }
 601
 602
 603 /**
 604  * @~spanish
 605  * Asigna los valores de los atributos @p atts a la brocha @p brush.
 606  */
 607 void Serializer::loadBrush(QBrush &brush, const QXmlAttributes &atts)
 608 {
 609         brush.setStyle(Qt::BrushStyle(atts.value("style").toInt()) );
 610
 611
 612         if(!atts.value("color").isEmpty())
 613         {
 614                 QColor color(atts.value("color"));
 615                 color.setAlpha(atts.value("alpha").toInt());
 616                 brush.setColor(color);
 617         }
 618
 619         QMatrix matrix;
 620         Item::Private::Svg2Qt::svgmatrix2qtmatrix( atts.value("transform"), matrix );
 621         brush.setMatrix(matrix);
 622 }
 623
 624 /**
 625  * @~spanish
 626  * Asigna los valores de un elemento de un documento xml @p e a la brocha @p brush.
 627  */
 628 void Serializer::loadBrush(QBrush &brush, const QDomElement &e)
 629 {
 630         Q_ASSERT(e.tagName() == "brush");
 631         Qt::BrushStyle style = static_cast<Qt::BrushStyle>(e.attribute("style").toInt());
 632
 633         QMatrix matrix;
 634         Item::Private::Svg2Qt::svgmatrix2qtmatrix( e.attribute("transform"), matrix );
 635         brush.setMatrix(matrix);
 636
 637         if(!e.attribute("color").isEmpty())
 638         {
 639                 brush.setColor(QColor(e.attribute("color")));
 640                 brush.setStyle(style);
 641         }
 642         else
 643         {
 644                 QDomElement brushElement = e.firstChild().toElement();
 645                 if( brushElement.tagName() == "gradient" )
 646                 {
 647                         QString str;
 648                         {
 649                                 QTextStream ts(&str);
 650                                 ts << brushElement;
 651                         }
 652
 653                         QGradient *gradient = loadGradient(str);
 654                         if( gradient )
 655                         {
 656                                 QBrush newBrush(*gradient);
 657                                 delete gradient;
 658
 659                                 newBrush.setMatrix(brush.matrix());
 660                                 brush = newBrush;
 661                         }
 662                 }
 663         }
 664 }
 665
 666
 667 /**
 668  * @~spanish
 669  * Crea una estilo de linea con un documento xml @p doc.
 670  */
 671 QDomElement Serializer::pen(const QPen *pen, QDomDocument &doc)
 672 {
 673         QDomElement penElement = doc.createElement("pen");
 674
 675         penElement.setAttribute( "style", pen->style());
 676         penElement.setAttribute( "color", pen->color().name() );
 677         penElement.setAttribute( "alpha", pen->color().alpha() );
 678         penElement.setAttribute( "cap", pen->capStyle() );
 679         penElement.setAttribute( "join", pen->joinStyle() );
 680         penElement.setAttribute( "width", pen->width() );
 681         penElement.setAttribute( "ml", pen->miterLimit() );
 682
 683         QBrush brush = pen->brush();
 684         penElement.appendChild(Serializer::brush(&brush, doc));
 685
 686         return penElement;
 687 }
 688
 689 /**
 690  * Serializa @p pen utilizando @p writer
 691  * @param pen
 692  * @param writer
 693  */
 694 void Serializer::pen(const QPen *pen, QXmlStreamWriter *writer)
 695 {
 696         writer->writeStartElement("pen");
 697
 698         writer->writeAttribute( "style", QString::number(pen->style()));
 699         writer->writeAttribute( "color", pen->color().name() );
 700         writer->writeAttribute( "alpha", QString::number(pen->color().alpha()) );
 701         writer->writeAttribute( "cap", QString::number(pen->capStyle()) );
 702         writer->writeAttribute( "join", QString::number(pen->joinStyle()) );
 703         writer->writeAttribute( "width", QString::number(pen->width()) );
 704         writer->writeAttribute( "ml", QString::number(pen->miterLimit()) );
 705
 706         QBrush brush = pen->brush();
 707         Serializer::brush(&brush, writer);
 708
 709         writer->writeEndElement();
 710 }
 711
 712 /**
 713  * @~spanish
 714  * Asigna los valores de los atributos @p atts a la estilo de linea @p pen.
 715  */
 716 void Serializer::loadPen(QPen &pen, const QXmlAttributes &atts)
 717 {
 718         pen.setCapStyle( Qt::PenCapStyle(atts.value("cap").toInt() ));
 719         pen.setStyle( Qt::PenStyle(atts.value("style").toInt() ));
 720         pen.setJoinStyle( Qt::PenJoinStyle(atts.value("join").toInt() ));
 721         pen.setWidth( atts.value("width").toInt() );
 722         pen.setMiterLimit( atts.value("ml").toInt() );
 723
 724         if(!atts.value("color").isEmpty())
 725         {
 726                 QColor color(atts.value("color") );
 727                 color.setAlpha(atts.value("alpha").toInt() );
 728         }
 729 }
 730
 731 /**
 732  * @~spanish
 733  * Asigna los valores desde un documento XML utilizando @p reader al estilo de linea @p pen.
 734  */
 735 void Serializer::loadPen(QPen &pen, QXmlStreamReader *reader)
 736 {
 737         pen.setCapStyle( Qt::PenCapStyle(reader->attributes().value("cap").toString().toInt() ));
 738         pen.setStyle( Qt::PenStyle(reader->attributes().value("style").toString().toInt() ));
 739         pen.setJoinStyle( Qt::PenJoinStyle(reader->attributes().value("join").toString().toInt() ));
 740         pen.setWidth( reader->attributes().value("width").toString().toInt() );
 741         pen.setMiterLimit( reader->attributes().value("ml").toString().toInt() );
 742
 743         QString c = reader->attributes().value("color").toString();
 744         if(!c.isEmpty())
 745         {
 746                 QColor color(c);
 747                 color.setAlpha(reader->attributes().value("alpha").toString().toInt() );
 748
 749                 pen.setColor(color);
 750         }
 751
 752         if( reader->readNext() == QXmlStreamReader::StartElement )
 753         {
 754                 if( reader->name() == "brush" )
 755                 {
 756                         QBrush brush;
 757                         loadBrush(brush, reader);
 758                         pen.setBrush(brush);
 759                 }
 760         }
 761 }
 762
 763 void Serializer::loadPen(QPen &pen, const QDomElement &e)
 764 {
 765         pen.setCapStyle( Qt::PenCapStyle(e.attribute("cap").toInt() ));
 766         pen.setStyle( Qt::PenStyle(e.attribute("style").toInt() ));
 767         pen.setJoinStyle( Qt::PenJoinStyle(e.attribute("join").toInt() ));
 768         pen.setWidth( e.attribute("width").toInt() );
 769         pen.setMiterLimit( e.attribute("ml").toInt() );
 770
 771         QString c = e.attribute("color");
 772         if(!c.isEmpty())
 773         {
 774                 QColor color(c);
 775                 color.setAlpha(e.attribute("alpha").toInt() );
 776
 777                 pen.setColor(color);
 778         }
 779
 780         QDomElement brushElement = e.firstChild().toElement();
 781         if( brushElement.tagName() == "brush" )
 782         {
 783                 QBrush brush;
 784                 loadBrush(brush, brushElement);
 785
 786                 pen.setBrush(brush);
 787         }
 788 }
 789
 790 /**
 791  * @~spanish
 792  * Carga un pen utilizando el documento XML @p doc
 793  * @param pen
 794  * @param doc
 795  */
 796 void Serializer::loadPen(QPen &pen, const QString &doc)
 797 {
 798         QXmlStreamReader reader(doc);
 799
 800         while(!reader.atEnd())
 801         {
 802                 if( reader.readNext() == QXmlStreamReader::StartElement )
 803                 {
 804                         if( reader.name() == "pen" )
 805                         {
 806                                 loadPen(pen, &reader);
 807                                 break;
 808                         }
 809                 }
 810         }
 811 }
 812
 813 /**
 814  * @~spanish
 815  * Convierte un tipo de letra @p font a un elemento del documento xml @p doc.
 816  */
 817 QDomElement Serializer::font(const QFont &font, QDomDocument &doc)
 818 {
 819         QDomElement fontElement = doc.createElement("font");
 820
 821         fontElement.setAttribute( "family", font.family());
 822         fontElement.setAttribute( "point-size", font.pointSize());
 823         fontElement.setAttribute( "weight", font.weight());
 824         fontElement.setAttribute( "italic", font.italic());
 825         fontElement.setAttribute( "bold", font.bold());
 826         fontElement.setAttribute( "style", font.style());
 827
 828         fontElement.setAttribute( "underline", font.underline());
 829         fontElement.setAttribute( "overline", font.overline());
 830
 831         return fontElement;
 832 }
 833
 834 /**
 835  * Serializa la letra @p _font
 836  * @param _font
 837  * @param strFont
 838  */
 839 void Serializer::font(const QFont &_font, QString *strFont)
 840 {
 841         QXmlStreamWriter writer(strFont);
 842         font(_font, &writer);
 843 }
 844
 845 /**
 846  * Serializa la letra usando @p writer
 847  * @param _font
 848  * @param writer
 849  */
 850 void Serializer::font(const QFont &_font, QXmlStreamWriter *writer)
 851 {
 852         writer->writeStartElement("font");
 853
 854         writer->writeAttribute( "family", _font.family());
 855         writer->writeAttribute( "point-size", QString::number(_font.pointSize()));
 856         writer->writeAttribute( "weight", QString::number(_font.weight()));
 857         writer->writeAttribute( "italic", QString::number(_font.italic()));
 858         writer->writeAttribute( "bold", QString::number(_font.bold()));
 859         writer->writeAttribute( "style", QString::number(_font.style()));
 860
 861         writer->writeAttribute( "underline", QString::number(_font.underline()));
 862         writer->writeAttribute( "overline", QString::number(_font.overline()));
 863
 864         writer->writeEndElement();
 865 }
 866
 867 /**
 868  * @~spanish
 869  * Asigna los valores de un elemento de un documento xml @p e al tipo de letra @p font.
 870  */
 871 void Serializer::loadFont(QFont &font, const QDomElement &e)
 872 {
 873         font = QFont(e.attribute( "family" ), e.attribute( "point-size", "-1").toInt(), e.attribute( "weight", "-1").toInt(), e.attribute( "italic", "0").toInt());
 874
 875         font.setBold( e.attribute( "bold", "0").toInt( ) );
 876         font.setStyle( QFont::Style(e.attribute( "style").toInt()) );
 877
 878         font.setUnderline( e.attribute( "underline", "0").toInt() );
 879         font.setOverline( e.attribute( "overline", "0").toInt() );
 880
 881 }
 882
 883 /**
 884  * @~spanish
 885  * Asigna los valores de los atributos @p atts al tipo de letra @p font.
 886  */
 887 void Serializer::loadFont(QFont &font, const QXmlAttributes &atts)
 888 {
 889         font = QFont(atts.value( "family" ), atts.value( "point-size", "-1").toInt(), atts.value( "weight", "-1").toInt(), atts.value( "italic", "0").toInt());
 890
 891         font.setBold( atts.value( "bold", "0").toInt( ) );
 892         font.setStyle( QFont::Style(atts.value( "style").toInt()) );
 893
 894
 895         font.setUnderline( atts.value( "underline", "0").toInt() );
 896         font.setOverline( atts.value( "overline", "0").toInt() );
 897 }
 898
 899 /**
 900  * Carga la letra utilizando el documento xml @p properties
 901  * @param font
 902  * @param properties
 903  */
 904 void Serializer::loadFont(QFont &font, const QString &properties)
 905 {
 906         QXmlStreamReader reader(properties);
 907
 908         while( !reader.atEnd() )
 909         {
 910                 if( reader.readNext() == QXmlStreamReader::StartElement )
 911                 {
 912                         if( reader.name() == "font" )
 913                         {
 914                                 loadFont(font, &reader);
 915                                 break;
 916                         }
 917                 }
 918         }
 919
 920         if( reader.hasError() )
 921                 dfDebug << reader.errorString();
 922 }
 923
 924 /**
 925  * Carga la letra utilizando el reader
 926  * @param font
 927  * @param reader
 928  */
 929 void Serializer::loadFont(QFont &font, QXmlStreamReader *reader)
 930 {
 931         Q_ASSERT(reader->name().toString() == "font");
 932
 933         {
 934                 foreach(QXmlStreamAttribute att, reader->attributes())
 935                 {
 936                         QString name = att.name().toString();
 937
 938                         if(name == "family")
 939                         {
 940                                 font.setFamily(att.value().toString());
 941                         }
 942                         else if(name == "point-size")
 943                         {
 944                                 font.setPointSize(att.value().toString().toInt());
 945                         }
 946                         else if(name == "weight")
 947                         {
 948                                 font.setWeight(att.value().toString().toInt());
 949                         }
 950                         else if(name == "italic")
 951                         {
 952                                 font.setItalic(att.value().toString().toInt());
 953                         }
 954                         else if(name == "bold")
 955                         {
 956                                 font.setBold(att.value().toString().toInt());
 957                         }
 958                         else if(name == "style")
 959                         {
 960                                 font.setStyle(QFont::Style(att.value().toString().toInt()));
 961                         }
 962                         else if(name == "undeline")
 963                         {
 964                                 font.setUnderline(att.value().toString().toInt());
 965                         }
 966                         else if(name == "overline")
 967                         {
 968                                 font.setOverline(att.value().toString().toInt());
 969                         }
 970                 }
 971         }
 972 }
 973
 974 }
 975 }