1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "paintcommands.h"

    42 

    43 #include <qdir.h>

    44 #include <qfile.h>

    45 #include <qfileinfo.h>

    46 #include <qpainter.h>

    47 #include <qbitmap.h>

    48 #include <qtextstream.h>

    49 #include <qtextlayout.h>

    50 #include <qdebug.h>

    51 

    52 #ifdef QT3_SUPPORT

    53 #include <q3painter.h>

    54 #endif

    55 

    56 #ifndef QT_NO_OPENGL

    57 #include <qglpixelbuffer.h>

    58 #endif

    59 

    60 /*********************************************************************************

    61 ** everything to populate static tables

    62 **********************************************************************************/

    63 const char *PaintCommands::brushStyleTable[] = {

    64     "NoBrush",

    65     "SolidPattern",

    66     "Dense1Pattern",

    67     "Dense2Pattern",

    68     "Dense3Pattern",

    69     "Dense4Pattern",

    70     "Dense5Pattern",

    71     "Dense6Pattern",

    72     "Dense7Pattern",

    73     "HorPattern",

    74     "VerPattern",

    75     "CrossPattern",

    76     "BDiagPattern",

    77     "FDiagPattern",

    78     "DiagCrossPattern",

    79     "LinearGradientPattern"

    80 };

    81 

    82 const char *PaintCommands::penStyleTable[] = {

    83     "NoPen",

    84     "SolidLine",

    85     "DashLine",

    86     "DotLine",

    87     "DashDotLine",

    88     "DashDotDotLine"

    89 };

    90 

    91 const char *PaintCommands::fontWeightTable[] = {

    92     "Light",

    93     "Normal",

    94     "DemiBold",

    95     "Bold",

    96     "Black"

    97 };

    98 

    99 const char *PaintCommands::clipOperationTable[] = {

   100     "NoClip",

   101     "ReplaceClip",

   102     "IntersectClip",

   103     "UniteClip"

   104 };

   105 

   106 const char *PaintCommands::spreadMethodTable[] = {

   107     "PadSpread",

   108     "ReflectSpread",

   109     "RepeatSpread"

   110 };

   111 

   112 const char *PaintCommands::coordinateMethodTable[] = {

   113     "LogicalMode",

   114     "StretchToDeviceMode",

   115     "ObjectBoundingMode"

   116 };

   117 

   118 const char *PaintCommands::sizeModeTable[] = {

   119     "AbsoluteSize",

   120     "RelativeSize"

   121 };

   122 

   123 const char *PaintCommands::compositionModeTable[] = {

   124     "SourceOver",

   125     "DestinationOver",

   126     "Clear",

   127     "Source",

   128     "Destination",

   129     "SourceIn",

   130     "DestinationIn",

   131     "SourceOut",

   132     "DestinationOut",

   133     "SourceAtop",

   134     "DestinationAtop",

   135     "Xor",

   136     "Plus",

   137     "Multiply",

   138     "Screen",

   139     "Overlay",

   140     "Darken",

   141     "Lighten",

   142     "ColorDodge",

   143     "ColorBurn",

   144     "HardLight",

   145     "SoftLight",

   146     "Difference",

   147     "Exclusion",

   148     "SourceOrDestination",

   149     "SourceAndDestination",

   150     "SourceXorDestination",

   151     "NotSourceAndNotDestination",

   152     "NotSourceOrNotDestination",

   153     "NotSourceXorDestination",

   154     "NotSource",

   155     "NotSourceAndDestination",

   156     "SourceAndNotDestination"

   157 };

   158 

   159 const char *PaintCommands::imageFormatTable[] = {

   160     "Invalid",

   161     "Mono",

   162     "MonoLSB",

   163     "Indexed8",

   164     "RGB32",

   165     "ARGB32",

   166     "ARGB32_Premultiplied",

   167     "Format_RGB16",

   168     "Format_ARGB8565_Premultiplied",

   169     "Format_RGB666",

   170     "Format_ARGB6666_Premultiplied",

   171     "Format_RGB555",

   172     "Format_ARGB8555_Premultiplied",

   173     "Format_RGB888",

   174     "Format_RGB444",

   175     "Format_ARGB4444_Premultiplied"

   176 };

   177 

   178 int PaintCommands::translateEnum(const char *table[], const QString &pattern, int limit)

   179 {

   180     for (int i=0; i<limit; ++i)

   181         if (pattern.toLower() == QString(QLatin1String(table[i])).toLower())

   182             return i;

   183     return -1;

   184 }

   185 

   186 QList<PaintCommands::PaintCommandInfos> PaintCommands::s_commandInfoTable = QList<PaintCommands::PaintCommandInfos>();

   187 QList<QPair<QString,QStringList> > PaintCommands::s_enumsTable = QList<QPair<QString,QStringList> >();

   188 

   189 #define DECL_PAINTCOMMAND(identifier, method, regexp, syntax, sample) \

   190     s_commandInfoTable << PaintCommandInfos(QLatin1String(identifier), &PaintCommands::method, QRegExp(regexp), \

   191                                             QLatin1String(syntax), QLatin1String(sample) );

   192 

   193 #define DECL_PAINTCOMMANDSECTION(title) \

   194     s_commandInfoTable << PaintCommandInfos(QLatin1String(title));

   195 

   196 #define ADD_ENUMLIST(listCaption, cStrArray) { \

   197         QStringList list; \

   198         for (int i=0; i<int(sizeof(cStrArray)/sizeof(char*)); i++)      \

   199         list << cStrArray[i]; \

   200         s_enumsTable << qMakePair(QString(listCaption), list); \

   201     }

   202 

   203 void PaintCommands::staticInit()

   204 {

   205     // check if already done

   206     if (!s_commandInfoTable.isEmpty()) return;

   207 

   208     // populate the command list

   209     DECL_PAINTCOMMANDSECTION("misc");

   210     DECL_PAINTCOMMAND("comment", command_comment,

   211                       "^\\s*#",

   212                       "# this is some comments",

   213                       "# place your comments here");

   214     DECL_PAINTCOMMAND("import", command_import,

   215                       "^import\\s+\"(.*)\"$",

   216                       "import <qrcFilename>",

   217                       "import \"myfile.qrc\"");

   218     DECL_PAINTCOMMAND("begin_block", command_begin_block,

   219                       "^begin_block\\s+(\\w*)$",

   220                       "begin_block <blockName>",

   221                       "begin_block blockName");

   222     DECL_PAINTCOMMAND("end_block", command_end_block,

   223                       "^end_block$",

   224                       "end_block",

   225                       "end_block");

   226     DECL_PAINTCOMMAND("repeat_block", command_repeat_block,

   227                       "^repeat_block\\s+(\\w*)$",

   228                       "repeat_block <blockName>",

   229                       "repeat_block blockName");

   230     DECL_PAINTCOMMAND("textlayout_draw", command_textlayout_draw,

   231                       "^textlayout_draw\\s+\"(.*)\"\\s+([0-9.]*)$",

   232                       "textlayout_draw <text> <width>",

   233                       "textlayout_draw \"your text\" 1.0");

   234     DECL_PAINTCOMMAND("abort", command_abort,

   235                       "^abort$",

   236                       "abort",

   237                       "abort");

   238     DECL_PAINTCOMMAND("noop", command_noop,

   239                       "^$",

   240                       "-",

   241                       "\n");

   242 

   243     DECL_PAINTCOMMANDSECTION("setters");

   244     DECL_PAINTCOMMAND("setBackgroundMode", command_setBgMode,

   245                       "^(setBackgroundMode|setBgMode)\\s+(\\w*)$",

   246                       "setBackgroundMode <OpaqueMode|TransparentMode>",

   247                       "setBackgroundMode TransparentMode");

   248     DECL_PAINTCOMMAND("setBackground", command_setBackground,

   249                       "^setBackground\\s+#?(\\w*)\\s*(\\w*)?$",

   250                       "setBackground <color> [brush style enum]",

   251                       "setBackground black SolidPattern");

   252     DECL_PAINTCOMMAND("setOpacity", command_setOpacity,

   253                       "^setOpacity\\s+(-?\\d*\\.?\\d*)$",

   254                       "setOpacity <opacity>\n  - opacity is in [0,1]",

   255                       "setOpacity 1.0");

   256     DECL_PAINTCOMMAND("path_setFillRule", command_path_setFillRule,

   257                       "^path_setFillRule\\s+(\\w*)\\s+(\\w*)$",

   258                       "path_setFillRule <pathName> [Winding|OddEven]",

   259                       "path_setFillRule pathName Winding");

   260     DECL_PAINTCOMMAND("setBrush", command_setBrush,

   261                       "^setBrush\\s+(#?[\\w.:\\/]*)\\s*(\\w*)?$",

   262                       "setBrush <pixmapFileName>\nsetBrush noBrush\nsetBrush <color> <brush style enum>",

   263                       "setBrush white SolidPattern");

   264     DECL_PAINTCOMMAND("setBrushOrigin", command_setBrushOrigin,

   265                       "^setBrushOrigin\\s*(-?\\w*)\\s+(-?\\w*)$",

   266                       "setBrushOrigin <dx> <dy>",

   267                       "setBrushOrigin 0 0");

   268     DECL_PAINTCOMMAND("brushTranslate", command_brushTranslate,

   269                       "^brushTranslate\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   270                       "brushTranslate <tx> <ty>",

   271                       "brushTranslate 0.0 0.0");

   272     DECL_PAINTCOMMAND("brushScale", command_brushScale,

   273                       "^brushScale\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   274                       "brushScale <kx> <ky>",

   275                       "brushScale 0.0 0.0");

   276     DECL_PAINTCOMMAND("brushRotate", command_brushRotate,

   277                       "^brushRotate\\s+(-?[\\w.]*)$",

   278                       "brushRotate <angle>\n - angle in degrees",

   279                       "brushRotate 0.0");

   280     DECL_PAINTCOMMAND("brushShear", command_brushShear,

   281                       "^brushShear\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   282                       "brushShear <sx> <sy>",

   283                       "brushShear 0.0 0.0");

   284     DECL_PAINTCOMMAND("setCompositionMode", command_setCompositionMode,

   285                       "^setCompositionMode\\s+([\\w_0-9]*)$",

   286                       "setCompositionMode <composition mode enum>",

   287                       "setCompositionMode SourceOver");

   288     DECL_PAINTCOMMAND("setFont", command_setFont,

   289                       "^setFont\\s+\"([\\w\\s]*)\"\\s*(\\w*)\\s*(\\w*)\\s*(\\w*)$",

   290                       "setFont <fontFace> [size] [font weight|font weight enum] [italic]\n  - font weight is an integer between 0 and 99",

   291                       "setFont \"times\" normal");

   292     DECL_PAINTCOMMAND("setPen", command_setPen,

   293                       "^setPen\\s+#?(\\w*)$",

   294                       "setPen <color>\nsetPen <pen style enum>\nsetPen brush",

   295                       "setPen black");

   296     DECL_PAINTCOMMAND("setPen", command_setPen2,

   297                       "^setPen\\s+(#?\\w*)\\s+([\\w.]+)\\s*(\\w*)\\s*(\\w*)\\s*(\\w*)$",

   298                       "setPen brush|<color> [width] [pen style enum] [FlatCap|SquareCap|RoundCap] [MiterJoin|BevelJoin|RoundJoin]",

   299                       "setPen black 1 FlatCap MiterJoin");

   300     DECL_PAINTCOMMAND("pen_setDashOffset", command_pen_setDashOffset,

   301                       "^pen_setDashOffset\\s+(-?[\\w.]+)$",

   302                       "pen_setDashOffset <offset>\n",

   303                       "pen_setDashOffset 1.0");

   304     DECL_PAINTCOMMAND("pen_setDashPattern", command_pen_setDashPattern,

   305                       "^pen_setDashPattern\\s+\\[([\\w\\s.]*)\\]$",

   306                       "pen_setDashPattern <[ <dash_1> <space_1> ... <dash_n> <space_n> ]>",

   307                       "pen_setDashPattern [ 2 1 4 1 3 3 ]");

   308     DECL_PAINTCOMMAND("pen_setCosmetic", command_pen_setCosmetic,

   309                       "^pen_setCosmetic\\s+(\\w*)$",

   310                       "pen_setCosmetic <true|false>",

   311                       "pen_setCosmetic true");

   312     DECL_PAINTCOMMAND("setRenderHint", command_setRenderHint,

   313                       "^setRenderHint\\s+([\\w_0-9]*)\\s*(\\w*)$",

   314                       "setRenderHint <Antialiasing|SmoothPixmapTransform> <true|false>",

   315                       "setRenderHint Antialiasing true");

   316     DECL_PAINTCOMMAND("clearRenderHint", command_clearRenderHint,

   317                       "^clearRenderHint$",

   318                       "clearRenderHint",

   319                       "clearRenderHint");

   320 

   321     DECL_PAINTCOMMANDSECTION("gradients");

   322     DECL_PAINTCOMMAND("gradient_appendStop", command_gradient_appendStop,

   323                       "^gradient_appendStop\\s+([\\w.]*)\\s+#?(\\w*)$",

   324                       "gradient_appendStop <pos> <color>",

   325                       "gradient_appendStop 1.0 red");

   326     DECL_PAINTCOMMAND("gradient_clearStops", command_gradient_clearStops,

   327                       "^gradient_clearStops$",

   328                       "gradient_clearStops",

   329                       "gradient_clearStops");

   330     DECL_PAINTCOMMAND("gradient_setConical", command_gradient_setConical,

   331                       "^gradient_setConical\\s+([\\w.]*)\\s+([\\w.]*)\\s+([\\w.]*)$",

   332                       "gradient_setConical <cx> <cy> <angle>\n  - angle in degrees",

   333                       "gradient_setConical 5.0 5.0 45.0");

   334     DECL_PAINTCOMMAND("gradient_setLinear", command_gradient_setLinear,

   335                       "^gradient_setLinear\\s+([\\w.]*)\\s+([\\w.]*)\\s+([\\w.]*)\\s+([\\w.]*)$",

   336                       "gradient_setLinear <x1> <y1> <x2> <y2>",

   337                       "gradient_setLinear 1.0 1.0 2.0 2.0");

   338     DECL_PAINTCOMMAND("gradient_setRadial", command_gradient_setRadial,

   339                       "^gradient_setRadial\\s+([\\w.]*)\\s+([\\w.]*)\\s+([\\w.]*)\\s?([\\w.]*)\\s?([\\w.]*)$",

   340                       "gradient_setRadial <cx> <cy> <rad> <fx> <fy>\n  - C is the center\n  - rad is the angle in degrees\n  - F is the focal point",

   341                       "gradient_setRadial 1.0 1.0 45.0 2.0 2.0");

   342     DECL_PAINTCOMMAND("gradient_setLinearPen", command_gradient_setLinearPen,

   343                       "^gradient_setLinearPen\\s+([\\w.]*)\\s+([\\w.]*)\\s+([\\w.]*)\\s+([\\w.]*)$",

   344                       "gradient_setLinearPen <x1> <y1> <x2> <y2>",

   345                       "gradient_setLinearPen 1.0 1.0 2.0 2.0");

   346     DECL_PAINTCOMMAND("gradient_setSpread", command_gradient_setSpread,

   347                       "^gradient_setSpread\\s+(\\w*)$",

   348                       "gradient_setSpread <spread method enum>",

   349                       "gradient_setSpread PadSpread");

   350     DECL_PAINTCOMMAND("gradient_setCoordinateMode", command_gradient_setCoordinateMode,

   351                       "^gradient_setCoordinateMode\\s+(\\w*)$",

   352                       "gradient_setCoordinateMode <coordinate method enum>",

   353                       "gradient_setCoordinateMode ObjectBoundingMode");

   354 #ifdef QT3_SUPPORT

   355     DECL_PAINTCOMMANDSECTION("qt3 drawing ops");

   356     DECL_PAINTCOMMAND("qt3_drawArc", command_qt3_drawArc,

   357                       "^qt3_drawArc\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   358                       "qt3_drawArc <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in 1/16th of degree",

   359                       "qt3_drawArc 10 10 20 20 0 5760");

   360     DECL_PAINTCOMMAND("qt3_drawChord", command_qt3_drawChord,

   361                       "^qt3_drawChord\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   362                       "qt3_drawChord <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in 1/16th of degree",

   363                       "qt3_drawChord 10 10 20 20 0 5760");

   364     DECL_PAINTCOMMAND("qt3_drawEllipse", command_qt3_drawEllipse,

   365                       "^qt3_drawEllipse\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   366                       "qt3_drawEllipse <x> <y> <w> <h>",

   367                       "qt3_drawEllipse 10 10 20 20");

   368     DECL_PAINTCOMMAND("qt3_drawPie", command_qt3_drawPie,

   369                       "^qt3_drawPie\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   370                       "qt3_drawPie <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in 1/16th of degree",

   371                       "qt3_drawPie 10 10 20 20 0 5760");

   372     DECL_PAINTCOMMAND("qt3_drawRect", command_qt3_drawRect,

   373                       "^qt3_drawRect\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   374                       "qt3_drawRect <x> <y> <w> <h>",

   375                       "qt3_drawRect 10 10 20 20");

   376     DECL_PAINTCOMMAND("qt3_drawRoundRect", command_qt3_drawRoundRect,

   377                       "^qt3_drawRoundRect\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s*(-?\\w)?\\s*(-?\\w)?$",

   378                       "qt3_drawRoundRect <x> <y> <w> <h> [rx] [ry]",

   379                       "qt3_drawRoundRect 10 10 20 20 3 3");

   380 #endif

   381     DECL_PAINTCOMMANDSECTION("drawing ops");

   382     DECL_PAINTCOMMAND("drawPoint", command_drawPoint,

   383                       "^drawPoint\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   384                       "drawPoint <x> <y>",

   385                       "drawPoint 10.0 10.0");

   386     DECL_PAINTCOMMAND("drawLine", command_drawLine,

   387                       "^drawLine\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   388                       "drawLine <x1> <y1> <x2> <y2>",

   389                       "drawLine 10.0 10.0 20.0 20.0");

   390     DECL_PAINTCOMMAND("drawRect", command_drawRect,

   391                       "^drawRect\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   392                       "drawRect <x> <y> <w> <h>",

   393                       "drawRect 10.0 10.0 20.0 20.0");

   394     DECL_PAINTCOMMAND("drawRoundRect", command_drawRoundRect,

   395                       "^drawRoundRect\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s*(-?\\w*)?\\s*(-?\\w*)?$",

   396                       "drawRoundRect <x> <y> <w> <h> [rx] [ry]",

   397                       "drawRoundRect 10 10 20 20 3 3");

   398     DECL_PAINTCOMMAND("drawRoundedRect", command_drawRoundedRect,

   399                       "^drawRoundedRect\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s*(\\w*)?$",

   400                       "drawRoundedRect <x> <y> <w> <h> <rx> <ry> [SizeMode enum]",

   401                       "drawRoundedRect 10 10 20 20 4 4 AbsoluteSize");

   402     DECL_PAINTCOMMAND("drawArc", command_drawArc,

   403                       "^drawArc\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   404                       "drawArc <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in 1/16th of degree",

   405                       "drawArc 10 10 20 20 0 5760");

   406     DECL_PAINTCOMMAND("drawChord", command_drawChord,

   407                       "^drawChord\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   408                       "drawChord <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in 1/16th of degree",

   409                       "drawChord 10 10 20 20 0 5760");

   410     DECL_PAINTCOMMAND("drawEllipse", command_drawEllipse,

   411                       "^drawEllipse\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   412                       "drawEllipse <x> <y> <w> <h>",

   413                       "drawEllipse 10.0 10.0 20.0 20.0");

   414     DECL_PAINTCOMMAND("drawPath", command_drawPath,

   415                       "^drawPath\\s+(\\w*)$",

   416                       "drawPath <pathName>",

   417                       "drawPath mypath");

   418     DECL_PAINTCOMMAND("drawPie", command_drawPie,

   419                       "^drawPie\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   420                       "drawPie <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in 1/16th of degree",

   421                       "drawPie 10 10 20 20 0 5760");

   422     DECL_PAINTCOMMAND("drawPixmap", command_drawPixmap,

   423                       "^drawPixmap\\s+([\\w.:\\-/]*)"

   424                       "\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?"    // target rect

   425                       "\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?$", // source rect

   426                       "drawPixmap <filename> <tx> <ty> <tw> <th> <sx> <sy> <sw> <sh>"

   427                       "\n- where t means target and s means source"

   428                       "\n- a width or height of -1 means maximum space",

   429                       "drawPixmap :/images/face.png 0 0 -1 -1 0 0 -1 -1");

   430     DECL_PAINTCOMMAND("drawImage", command_drawImage,

   431                       "^drawImage\\s+([\\w.:\\/]*)"

   432                       "\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?"    // target rect

   433                       "\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?\\s*(-?[\\w.]*)?$", // source rect

   434                       "drawImage <filename> <tx> <ty> <tw> <th> <sx> <sy> <sw> <sh>"

   435                       "\n- where t means target and s means source"

   436                       "\n- a width or height of -1 means maximum space",

   437                       "drawImage :/images/face.png 0 0 -1 -1 0 0 -1 -1");

   438     DECL_PAINTCOMMAND("drawPolygon", command_drawPolygon,

   439                       "^drawPolygon\\s+\\[([\\w\\s-.]*)\\]\\s*(\\w*)$",

   440                       "drawPolygon <[ <x1> <y1> ... <xn> <yn> ]> <Winding|OddEven>",

   441                       "drawPolygon [ 1 4  6 8  5 3 ] Winding");

   442     DECL_PAINTCOMMAND("drawConvexPolygon", command_drawConvexPolygon,

   443                       "^drawConvexPolygon\\s+\\[([\\w\\s-.]*)\\]$",

   444                       "drawConvexPolygon <[ <x1> <y1> ... <xn> <yn> ]>",

   445                       "drawConvexPolygon [ 1 4  6 8  5 3 ]");

   446     DECL_PAINTCOMMAND("drawPolyline", command_drawPolyline,

   447                       "^drawPolyline\\s+\\[([\\w\\s]*)\\]$",

   448                       "drawPolyline <[ <x1> <y1> ... <xn> <yn> ]>",

   449                       "drawPolyline [ 1 4  6 8  5 3 ]");

   450     DECL_PAINTCOMMAND("drawText", command_drawText,

   451                       "^drawText\\s+(-?\\w*)\\s+(-?\\w*)\\s+\"(.*)\"$",

   452                       "drawText <x> <y> <text>",

   453                       "drawText 10 10 \"my text\"");

   454     DECL_PAINTCOMMAND("drawTiledPixmap", command_drawTiledPixmap,

   455                       "^drawTiledPixmap\\s+([\\w.:\\/]*)"

   456                       "\\s+(-?\\w*)\\s+(-?\\w*)\\s*(-?\\w*)\\s*(-?\\w*)"

   457                       "\\s*(-?\\w*)\\s*(-?\\w*)$",

   458                       "drawTiledPixmap <tile image filename> <tx> <ty> <tx> <ty> <sx> <sy>"

   459                       "\n  - where t means tile"

   460                       "\n  - and s is an offset in the tile",

   461                       "drawTiledPixmap :/images/alpha.png ");

   462 

   463     DECL_PAINTCOMMANDSECTION("painterPaths");

   464     DECL_PAINTCOMMAND("path_moveTo", command_path_moveTo,

   465                       "^path_moveTo\\s+([.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   466                       "path_moveTo <pathName> <x> <y>",

   467                       "path_moveTo mypath 1.0 1.0");

   468     DECL_PAINTCOMMAND("path_lineTo", command_path_lineTo,

   469                       "^path_lineTo\\s+([.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   470                       "path_lineTo <pathName> <x> <y>",

   471                       "path_lineTo mypath 1.0 1.0");

   472     DECL_PAINTCOMMAND("path_addEllipse", command_path_addEllipse,

   473                       "^path_addEllipse\\s+(\\w*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   474                       "path_addEllipse <pathName> <x1> <y1> <x2> <y2>",

   475                       "path_addEllipse mypath 10.0 10.0 20.0 20.0");

   476     DECL_PAINTCOMMAND("path_addPolygon", command_path_addPolygon,

   477                       "^path_addPolygon\\s+(\\w*)\\s+\\[([\\w\\s]*)\\]\\s*(\\w*)$",

   478                       "path_addPolygon <pathName> <[ <x1> <y1> ... <xn> <yn> ]>",

   479                       "path_addPolygon mypath [ 1 4  6 8  5 3 ]");

   480     DECL_PAINTCOMMAND("path_addRect", command_path_addRect,

   481                       "^path_addRect\\s+(\\w*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   482                       "path_addRect <pathName> <x1> <y1> <x2> <y2>",

   483                       "path_addRect mypath 10.0 10.0 20.0 20.0");

   484     DECL_PAINTCOMMAND("path_addText", command_path_addText,

   485                       "^path_addText\\s+(\\w*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+\"(.*)\"$",

   486                       "path_addText <pathName> <x> <y> <text>",

   487                       "path_addText mypath 10.0 20.0 \"some text\"");

   488     DECL_PAINTCOMMAND("path_arcTo", command_path_arcTo,

   489                       "^path_arcTo\\s+(\\w*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   490                       "path_arcTo <pathName> <x> <y> <w> <h> <angleStart> <angleArc>\n  - angles are expressed in degrees",

   491                       "path_arcTo mypath 0.0 0.0 10.0 10.0 0.0 360.0");

   492     DECL_PAINTCOMMAND("path_cubicTo", command_path_cubicTo,

   493                       "^path_cubicTo\\s+(\\w*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   494                       "path_cubicTo <pathName> <x1> <y1> <x2> <y2> <x3> <y3>",

   495                       "path_cubicTo mypath 0.0 0.0 10.0 10.0 20.0 20.0");

   496     DECL_PAINTCOMMAND("path_closeSubpath", command_path_closeSubpath,

   497                       "^path_closeSubpath\\s+(\\w*)$",

   498                       "path_closeSubpath <pathName>",

   499                       "path_closeSubpath mypath");

   500     DECL_PAINTCOMMAND("path_createOutline", command_path_createOutline,

   501                       "^path_createOutline\\s+(\\w*)\\s+(\\w*)$",

   502                       "path_createOutline <pathName> <newName>",

   503                       "path_createOutline mypath myoutline");

   504     DECL_PAINTCOMMAND("path_debugPrint", command_path_debugPrint,

   505                       "^path_debugPrint\\s+(\\w*)$",

   506                       "path_debugPrint <pathName>",

   507                       "path_debugPrint mypath");

   508 

   509     DECL_PAINTCOMMANDSECTION("regions");

   510     DECL_PAINTCOMMAND("region_addRect", command_region_addRect,

   511                       "^region_addRect\\s+(\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   512                       "region_addRect <regionName> <x1> <y1> <x2> <y2>",

   513                       "region_addRect myregion 0.0 0.0 10.0 10.0");

   514     DECL_PAINTCOMMAND("region_addEllipse", command_region_addEllipse,

   515                       "^region_addEllipse\\s+(\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)$",

   516                       "region_addEllipse <regionName> <x1> <y1> <x2> <y2>",

   517                       "region_addEllipse myregion 0.0 0.0 10.0 10.0");

   518 

   519     DECL_PAINTCOMMANDSECTION("clipping");

   520     DECL_PAINTCOMMAND("region_getClipRegion", command_region_getClipRegion,

   521                       "^region_getClipRegion\\s+(\\w*)$",

   522                       "region_getClipRegion <regionName>",

   523                       "region_getClipRegion myregion");

   524     DECL_PAINTCOMMAND("setClipRegion", command_setClipRegion,

   525                       "^setClipRegion\\s+(\\w*)\\s*(\\w*)$",

   526                       "setClipRegion <regionName> <clip operation enum>",

   527                       "setClipRegion myregion ReplaceClip");

   528     DECL_PAINTCOMMAND("path_getClipPath", command_path_getClipPath,

   529                       "^path_getClipPath\\s+([\\w0-9]*)$",

   530                       "path_getClipPath <pathName>",

   531                       "path_getClipPath mypath");

   532     DECL_PAINTCOMMAND("setClipPath", command_setClipPath,

   533                       "^setClipPath\\s+(\\w*)\\s*(\\w*)$",

   534                       "setClipPath <pathName> <clip operation enum>",

   535                       "setClipPath mypath ReplaceClip");

   536     DECL_PAINTCOMMAND("setClipRect", command_setClipRect,

   537                       "^setClipRect\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s+(-?\\w*)\\s*(\\w*)$",

   538                       "setClipRect <x1> <y1> <x2> <y2> <clip operation enum>",

   539                       "setClipRect 0.0 0.0 10.0 10.0 ReplaceClip");

   540     DECL_PAINTCOMMAND("setClipping", command_setClipping,

   541                       "^setClipping\\s+(\\w*)$",

   542                       "setClipping <true|false>",

   543                       "setClipping true");

   544 

   545     DECL_PAINTCOMMANDSECTION("surface");

   546     DECL_PAINTCOMMAND("surface_begin", command_surface_begin,

   547                       "^surface_begin\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   548                       "surface_begin <x> <y> <w> <h>",

   549                       "surface_begin 0.0 0.0 10.0 10.0");

   550     DECL_PAINTCOMMAND("surface_end", command_surface_end,

   551                       "^surface_end$",

   552                       "surface_end",

   553                       "surface_end");

   554 

   555     DECL_PAINTCOMMANDSECTION("painter states");

   556     DECL_PAINTCOMMAND("restore", command_restore,

   557                       "^restore$",

   558                       "restore",

   559                       "restore");

   560     DECL_PAINTCOMMAND("save", command_save,

   561                       "^save$",

   562                       "save",

   563                       "save");

   564 

   565     DECL_PAINTCOMMANDSECTION("pixmaps'n'images");

   566     DECL_PAINTCOMMAND("pixmap_load", command_pixmap_load,

   567                       "^pixmap_load\\s+([\\w.:\\/]*)\\s*([\\w.:\\/]*)$",

   568                       "pixmap_load <image filename> <pixmapName>",

   569                       "pixmap_load :/images/face.png myPixmap");

   570     DECL_PAINTCOMMAND("pixmap_setMask", command_pixmap_setMask,

   571                       "^pixmap_setMask\\s+([\\w.:\\/]*)\\s+([\\w.:\\/]*)$",

   572                       "pixmap_setMask <pixmapName> <bitmap filename>",

   573                       "pixmap_setMask myPixmap :/images/bitmap.png");

   574     DECL_PAINTCOMMAND("bitmap_load", command_bitmap_load,

   575                       "^bitmap_load\\s+([\\w.:\\/]*)\\s*([\\w.:\\/]*)$",

   576                       "bitmap_load <bitmap filename> <bitmapName>\n  - note that the image is stored as a pixmap",

   577                       "bitmap_load :/images/bitmap.png myBitmap");

   578     DECL_PAINTCOMMAND("image_convertToFormat", command_image_convertToFormat,

   579                       "^image_convertToFormat\\s+([\\w.:\\/]*)\\s+([\\w.:\\/]+)\\s+([\\w0-9_]*)$",

   580                       "image_convertToFormat <sourceImageName> <destImageName> <image format enum>",

   581                       "image_convertToFormat myImage myNewImage Indexed8");

   582     DECL_PAINTCOMMAND("image_load", command_image_load,

   583                       "^image_load\\s+([\\w.:\\/]*)\\s*([\\w.:\\/]*)$",

   584                       "image_load <filename> <imageName>",

   585                       "image_load :/images/face.png myImage");

   586     DECL_PAINTCOMMAND("image_setColor", command_image_setColor,

   587                       "^image_setColor\\s+([\\w.:\\/]*)\\s+([0-9]*)\\s+#([0-9]*)$",

   588                       "image_setColor <imageName> <index> <color>",

   589                       "image_setColor myImage 0 black");

   590     DECL_PAINTCOMMAND("image_setNumColors", command_image_setNumColors,

   591                       "^image_setNumColors\\s+([\\w.:\\/]*)\\s+([0-9]*)$",

   592                       "image_setNumColors <imageName> <nbColors>",

   593                       "image_setNumColors myImage 128");

   594 

   595     DECL_PAINTCOMMANDSECTION("transformations");

   596     DECL_PAINTCOMMAND("resetMatrix", command_resetMatrix,

   597                       "^resetMatrix$",

   598                       "resetMatrix",

   599                       "resetMatrix");

   600     DECL_PAINTCOMMAND("setMatrix", command_setMatrix,

   601                       "^setMatrix\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   602                       "setMatrix <m11> <m12> <m13> <m21> <m22> <m23> <m31> <m32> <m33>",

   603                       "setMatrix 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0");

   604     DECL_PAINTCOMMAND("translate", command_translate,

   605                       "^translate\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   606                       "translate <tx> <ty>",

   607                       "translate 10.0 10.0");

   608     DECL_PAINTCOMMAND("rotate", command_rotate,

   609                       "^rotate\\s+(-?[\\w.]*)$",

   610                       "rotate <angle>\n  - with angle in degrees",

   611                       "rotate 30.0");

   612     DECL_PAINTCOMMAND("rotate_x", command_rotate_x,

   613                       "^rotate_x\\s+(-?[\\w.]*)$",

   614                       "rotate_x <angle>\n  - with angle in degrees",

   615                       "rotate_x 30.0");

   616     DECL_PAINTCOMMAND("rotate_y", command_rotate_y,

   617                       "^rotate_y\\s+(-?[\\w.]*)$",

   618                       "rotate_y <angle>\n  - with angle in degrees",

   619                       "rotate_y 30.0");

   620     DECL_PAINTCOMMAND("scale", command_scale,

   621                       "^scale\\s+(-?[\\w.]*)\\s+(-?[\\w.]*)$",

   622                       "scale <sx> <sy>",

   623                       "scale 2.0 1.0");

   624     DECL_PAINTCOMMAND("mapQuadToQuad", command_mapQuadToQuad,

   625                       "^mapQuadToQuad\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)\\s+(-?[.\\w]*)$",

   626                       "mapQuadToQuad <x1> <y1> <x2> <y2> <x3> <y3> <x4> <y4> <x5> <y5> <x6> <y6> <x7> <y7> <x8> <y8>"

   627                       "\n  - where vertices 1 to 4 defines the source quad and 5 to 8 the destination quad",

   628                       "mapQuadToQuad 0.0 0.0 1.0 1.0 0.0 0.0 -1.0 -1.0");

   629 

   630     // populate the enums list

   631     ADD_ENUMLIST("brush styles", brushStyleTable);

   632     ADD_ENUMLIST("pen styles", penStyleTable);

   633     ADD_ENUMLIST("font weights", fontWeightTable);

   634     ADD_ENUMLIST("clip operations", clipOperationTable);

   635     ADD_ENUMLIST("spread methods", spreadMethodTable);

   636     ADD_ENUMLIST("composition modes", compositionModeTable);

   637     ADD_ENUMLIST("image formats", imageFormatTable);

   638     ADD_ENUMLIST("coordinate modes", coordinateMethodTable);

   639     ADD_ENUMLIST("size modes", sizeModeTable);

   640 }

   641 

   642 #undef DECL_PAINTCOMMAND

   643 #undef ADD_ENUMLIST

   644 /*********************************************************************************

   645 ** utility

   646 **********************************************************************************/

   647 template <typename T> T PaintCommands::image_load(const QString &filepath)

   648 {

   649     T t(filepath);

   650 

   651     if (t.isNull())

   652         t = T(":images/" + filepath);

   653 

   654     if (t.isNull())

   655         t = T("images/" + filepath);

   656 

   657     if (t.isNull()) {

   658         QFileInfo fi(filepath);

   659         QDir dir = fi.absoluteDir();

   660         dir.cdUp();

   661         dir.cd("images");

   662         QString fileName = QString("%1/%2").arg(dir.absolutePath()).arg(fi.fileName());

   663         t = T(fileName);

   664         if (t.isNull() && !fileName.endsWith(".png")) {

   665             fileName.append(".png");

   666             t = T(fileName);

   667         }

   668     }

   669 

   670     return t;

   671 }

   672 

   673 /*********************************************************************************

   674 ** setters

   675 **********************************************************************************/

   676 void PaintCommands::insertAt(int commandIndex, const QStringList &newCommands)

   677 {

   678     int index = 0;

   679     int left = newCommands.size();

   680     while (left--)

   681         m_commands.insert(++commandIndex, newCommands.at(index++));

   682 }

   683 

   684 /*********************************************************************************

   685 ** run

   686 **********************************************************************************/

   687 void PaintCommands::runCommand(const QString &scriptLine)

   688 {

   689     staticInit();

   690     foreach (PaintCommandInfos command, s_commandInfoTable)

   691         if (!command.isSectionHeader() && command.regExp.indexIn(scriptLine) >= 0) {

   692             (this->*(command.paintMethod))(command.regExp);

   693             return;

   694         }

   695     qWarning("ERROR: unknown command or argument syntax error in \"%s\"", qPrintable(scriptLine));

   696 }

   697 

   698 void PaintCommands::runCommands()

   699 {

   700     staticInit();

   701     int width = m_painter->window().width();

   702     int height = m_painter->window().height();

   703 

   704     if (width <= 0)

   705         width = 800;

   706     if (height <= 0)

   707         height = 800;

   708 

   709     // paint background

   710     if (m_checkers_background) {

   711         QPixmap pm(20, 20);

   712         pm.fill(Qt::white);

   713         QPainter pt(&pm);

   714         pt.fillRect(0, 0, 10, 10, QColor::fromRgba(0xffdfdfdf));

   715         pt.fillRect(10, 10, 10, 10, QColor::fromRgba(0xffdfdfdf));

   716 

   717         m_painter->drawTiledPixmap(0, 0, width, height, pm);

   718     } else {

   719         m_painter->fillRect(0, 0, width, height, Qt::white);

   720     }

   721 

   722     // run each command

   723     m_abort = false;

   724     for (int i=0; i<m_commands.size() && !m_abort; ++i) {

   725         const QString &commandNow = m_commands.at(i);

   726         m_currentCommand = commandNow;

   727         m_currentCommandIndex = i;

   728         runCommand(commandNow.trimmed());

   729     }

   730 }

   731 

   732 /*********************************************************************************

   733 ** conversions

   734 **********************************************************************************/

   735 int PaintCommands::convertToInt(const QString &str)

   736 {

   737     return qRound(convertToDouble(str));

   738 }

   739 

   740 float PaintCommands::convertToFloat(const QString &str)

   741 {

   742     return float(convertToDouble(str));

   743 }

   744 

   745 double PaintCommands::convertToDouble(const QString &str)

   746 {

   747     static QRegExp re("cp([0-9])([xy])");

   748     if (str.toLower() == "width") {

   749         if (m_painter->device()->devType() == Qt::Widget)

   750             return m_painter->window().width();

   751         else

   752             return 800;

   753     }

   754     if (str.toLower() == "height") {

   755         if (m_painter->device()->devType() == Qt::Widget)

   756             return m_painter->window().height();

   757         else

   758             return 800;

   759     }

   760     if (re.indexIn(str) >= 0) {

   761         int index = re.cap(1).toInt();

   762         bool is_it_x = re.cap(2) == "x";

   763         if (index < 0 || index >= m_controlPoints.size()) {

   764             qWarning("ERROR: control point index=%d is out of bounds", index);

   765             return 0;

   766         }

   767         return is_it_x ? m_controlPoints.at(index).x() : m_controlPoints.at(index).y();

   768     }

   769     return str.toDouble();

   770 }

   771 

   772 QColor PaintCommands::convertToColor(const QString &str)

   773 {

   774     static QRegExp alphaColor("#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})");

   775     static QRegExp opaqueColor("#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})");

   776 

   777     Q_ASSERT(alphaColor.isValid());

   778     Q_ASSERT(opaqueColor.isValid());

   779 

   780     if (alphaColor.indexIn(str) >= 0) {

   781         return QColor(alphaColor.cap(2).toInt(0, 16),

   782                       alphaColor.cap(3).toInt(0, 16),

   783                       alphaColor.cap(4).toInt(0, 16),

   784                       alphaColor.cap(1).toInt(0, 16));

   785     } else if (opaqueColor.indexIn(str) >= 0) {

   786         return QColor(opaqueColor.cap(1).toInt(0, 16),

   787                       opaqueColor.cap(2).toInt(0, 16),

   788                       opaqueColor.cap(3).toInt(0, 16));

   789     }

   790     return QColor(str);

   791 }

   792 

   793 /*********************************************************************************

   794 ** command implementations

   795 **********************************************************************************/

   796 void PaintCommands::command_comment(QRegExp)

   797 {

   798     if (m_verboseMode)

   799         printf(" -(lance) comment: %s\n", qPrintable(m_currentCommand));

   800 }

   801 

   802 /***************************************************************************************************/

   803 void PaintCommands::command_import(QRegExp re)

   804 {

   805     QString importFile(re.cap(1));

   806     QFileInfo fi(m_filepath);

   807     QDir dir = fi.absoluteDir();

   808     QFile *file = new QFile(dir.absolutePath() + QDir::separator() + importFile);

   809 

   810     if (importFile.isEmpty() || !file->exists()) {

   811         dir.cdUp();

   812         dir.cd("data");

   813         dir.cd("qps");

   814         delete file;

   815         file = new QFile(dir.absolutePath() + QDir::separator() + importFile);

   816     }

   817 

   818     if (importFile.isEmpty() || !file->exists()) {

   819         dir.cdUp();

   820         dir.cd("images");

   821         delete file;

   822         file = new QFile(dir.absolutePath() + QDir::separator() + importFile);

   823     }

   824 

   825     if (importFile.isEmpty() || !file->exists()) {

   826         printf(" - importing non-existing file at line %d (%s)\n", m_currentCommandIndex,

   827                qPrintable(file->fileName()));

   828         delete file;

   829         return;

   830     }

   831 

   832     if (!file->open(QIODevice::ReadOnly)) {

   833         printf(" - failed to read file: '%s'\n", qPrintable(file->fileName()));

   834         delete file;

   835         return;

   836     }

   837     if (m_verboseMode)

   838         printf(" -(lance) importing file at line %d (%s)\n", m_currentCommandIndex,

   839                qPrintable(fi.fileName()));

   840 

   841     QFileInfo fileinfo(*file);

   842     m_commands[m_currentCommandIndex] = QString("# import file (%1) start").arg(fileinfo.fileName());

   843     QTextStream textFile(file);

   844     QString rawContent = textFile.readAll();

   845     QStringList importedData = rawContent.split('\n', QString::SkipEmptyParts);

   846     importedData.append(QString("# import file (%1) end ---").arg(fileinfo.fileName()));

   847     insertAt(m_currentCommandIndex, importedData);

   848 

   849     if (m_verboseMode) {

   850         printf(" -(lance) Command buffer now looks like:\n");

   851         for (int i = 0; i < m_commands.count(); ++i)

   852             printf(" ---> {%s}\n", qPrintable(m_commands.at(i)));

   853     }

   854     delete file;

   855 }

   856 

   857 /***************************************************************************************************/

   858 void PaintCommands::command_begin_block(QRegExp re)

   859 {

   860     const QString &blockName = re.cap(1);

   861     if (m_verboseMode)

   862         printf(" -(lance) begin_block (%s)\n", qPrintable(blockName));

   863 

   864     m_commands[m_currentCommandIndex] = QString("# begin block (%1)").arg(blockName);

   865     QStringList newBlock;

   866     int i = m_currentCommandIndex + 1;

   867     for (; i < m_commands.count(); ++i) {

   868         const QString &nextCmd = m_commands.at(i);

   869         if (nextCmd.startsWith("end_block")) {

   870             m_commands[i] = QString("# end block (%1)").arg(blockName);

   871             break;

   872         }

   873         newBlock += nextCmd;

   874     }

   875 

   876     if (m_verboseMode)

   877         for (int j = 0; j < newBlock.count(); ++j)

   878             printf("      %d: %s\n", j, qPrintable(newBlock.at(j)));

   879 

   880     if (i >= m_commands.count())

   881         printf(" - Warning! Block doesn't have an 'end_block' marker!\n");

   882 

   883     m_blockMap.insert(blockName, newBlock);

   884 }

   885 

   886 /***************************************************************************************************/

   887 void PaintCommands::command_end_block(QRegExp)

   888 {

   889     printf(" - end_block should be consumed by begin_block command.\n");

   890     printf("   You will never see this if your block markers are in sync\n");

   891     printf("   (noop)\n");

   892 }

   893 

   894 /***************************************************************************************************/

   895 void PaintCommands::command_repeat_block(QRegExp re)

   896 {

   897     QString blockName = re.cap(1);

   898     if (m_verboseMode)

   899         printf(" -(lance) repeating block (%s)\n", qPrintable(blockName));

   900 

   901     QStringList block = m_blockMap.value(blockName);

   902     if (block.isEmpty()) {

   903         printf(" - repeated block (%s) is empty!\n", qPrintable(blockName));

   904         return;

   905     }

   906 

   907     m_commands[m_currentCommandIndex] = QString("# repeated block (%1)").arg(blockName);

   908     insertAt(m_currentCommandIndex, block);

   909 }

   910 

   911 /***************************************************************************************************/

   912 void PaintCommands::command_drawLine(QRegExp re)

   913 {

   914     QStringList caps = re.capturedTexts();

   915     double x1 = convertToDouble(caps.at(1));

   916     double y1 = convertToDouble(caps.at(2));

   917     double x2 = convertToDouble(caps.at(3));

   918     double y2 = convertToDouble(caps.at(4));

   919 

   920     if (m_verboseMode)

   921         printf(" -(lance) drawLine((%.2f, %.2f), (%.2f, %.2f))\n", x1, y1, x2, y2);

   922 

   923     m_painter->drawLine(QLineF(x1, y1, x2, y2));

   924 }

   925 

   926 /***************************************************************************************************/

   927 void PaintCommands::command_drawPath(QRegExp re)

   928 {

   929     if (m_verboseMode)

   930         printf(" -(lance) drawPath(name=%s)\n", qPrintable(re.cap(1)));

   931 

   932     QPainterPath &path = m_pathMap[re.cap(1)];

   933     m_painter->drawPath(path);

   934 }

   935 

   936 /***************************************************************************************************/

   937 void PaintCommands::command_drawPixmap(QRegExp re)

   938 {

   939     QPixmap pm;

   940     pm = m_pixmapMap[re.cap(1)]; // try cache first

   941     if (pm.isNull())

   942         pm = image_load<QPixmap>(re.cap(1));

   943     if (pm.isNull()) {

   944         QFileInfo fi(m_filepath);

   945         QDir dir = fi.absoluteDir();

   946         dir.cdUp();

   947         dir.cd("images");

   948         QString fileName = QString("%1/%2").arg(dir.absolutePath()).arg(re.cap(1));

   949         pm = QPixmap(fileName);

   950         if (pm.isNull() && !fileName.endsWith(".png")) {

   951             fileName.append(".png");

   952             pm = QPixmap(fileName);

   953         }

   954     }

   955     if (pm.isNull()) {

   956         fprintf(stderr, "ERROR(drawPixmap): failed to load pixmap: '%s'\n",

   957                 qPrintable(re.cap(1)));

   958         return;

   959     }

   960 

   961     qreal tx = convertToFloat(re.cap(2));

   962     qreal ty = convertToFloat(re.cap(3));

   963     qreal tw = convertToFloat(re.cap(4));

   964     qreal th = convertToFloat(re.cap(5));

   965 

   966     qreal sx = convertToFloat(re.cap(6));

   967     qreal sy = convertToFloat(re.cap(7));

   968     qreal sw = convertToFloat(re.cap(8));

   969     qreal sh = convertToFloat(re.cap(9));

   970 

   971     if (tw == 0) tw = -1;

   972     if (th == 0) th = -1;

   973     if (sw == 0) sw = -1;

   974     if (sh == 0) sh = -1;

   975 

   976     if (m_verboseMode)

   977         printf(" -(lance) drawPixmap('%s' dim=(%d, %d), depth=%d, (%d, %d, %d, %d), (%d, %d, %d, %d)\n",

   978                qPrintable(re.cap(1)), pm.width(), pm.height(), pm.depth(),

   979                tx, ty, tw, th, sx, sy, sw, sh);

   980 

   981     m_painter->drawPixmap(QRectF(tx, ty, tw, th), pm, QRectF(sx, sy, sw, sh));

   982 }

   983 

   984 /***************************************************************************************************/

   985 void PaintCommands::command_drawImage(QRegExp re)

   986 {

   987     QImage im;

   988     im = m_imageMap[re.cap(1)]; // try cache first

   989     if (im.isNull())

   990         im = image_load<QImage>(re.cap(1));

   991 

   992     if (im.isNull()) {

   993         QFileInfo fi(m_filepath);

   994         QDir dir = fi.absoluteDir();

   995         dir.cdUp();

   996         dir.cd("images");

   997         QString fileName = QString("%1/%2").arg(dir.absolutePath()).arg(re.cap(1));

   998         im = QImage(fileName);

   999         if (im.isNull() && !fileName.endsWith(".png")) {

  1000             fileName.append(".png");

  1001             im = QImage(fileName);

  1002         }

  1003     }

  1004     if (im.isNull()) {

  1005         fprintf(stderr, "ERROR(drawImage): failed to load image: '%s'\n", qPrintable(re.cap(1)));

  1006         return;

  1007     }

  1008 

  1009     qreal tx = convertToFloat(re.cap(2));

  1010     qreal ty = convertToFloat(re.cap(3));

  1011     qreal tw = convertToFloat(re.cap(4));

  1012     qreal th = convertToFloat(re.cap(5));

  1013 

  1014     qreal sx = convertToFloat(re.cap(6));

  1015     qreal sy = convertToFloat(re.cap(7));

  1016     qreal sw = convertToFloat(re.cap(8));

  1017     qreal sh = convertToFloat(re.cap(9));

  1018 

  1019     if (tw == 0) tw = -1;

  1020     if (th == 0) th = -1;

  1021     if (sw == 0) sw = -1;

  1022     if (sh == 0) sh = -1;

  1023 

  1024     if (m_verboseMode)

  1025         printf(" -(lance) drawImage('%s' dim=(%d, %d), (%d, %d, %d, %d), (%d, %d, %d, %d)\n",

  1026                qPrintable(re.cap(1)), im.width(), im.height(), tx, ty, tw, th, sx, sy, sw, sh);

  1027 

  1028     m_painter->drawImage(QRectF(tx, ty, tw, th), im, QRectF(sx, sy, sw, sh), Qt::OrderedDither | Qt::OrderedAlphaDither);

  1029 }

  1030 

  1031 /***************************************************************************************************/

  1032 void PaintCommands::command_drawTiledPixmap(QRegExp re)

  1033 {

  1034     QPixmap pm;

  1035     pm = m_pixmapMap[re.cap(1)]; // try cache first

  1036     if (pm.isNull())

  1037         pm = image_load<QPixmap>(re.cap(1));

  1038     if (pm.isNull()) {

  1039         QFileInfo fi(m_filepath);

  1040         QDir dir = fi.absoluteDir();

  1041         dir.cdUp();

  1042         dir.cd("images");

  1043         QString fileName = QString("%1/%2").arg(dir.absolutePath()).arg(re.cap(1));

  1044         pm = QPixmap(fileName);

  1045         if (pm.isNull() && !fileName.endsWith(".png")) {

  1046             fileName.append(".png");

  1047             pm = QPixmap(fileName);

  1048         }

  1049     }

  1050     if (pm.isNull()) {

  1051         fprintf(stderr, "ERROR(drawTiledPixmap): failed to load pixmap: '%s'\n",

  1052                 qPrintable(re.cap(1)));

  1053         return;

  1054     }

  1055 

  1056     int tx = convertToInt(re.cap(2));

  1057     int ty = convertToInt(re.cap(3));

  1058     int tw = convertToInt(re.cap(4));

  1059     int th = convertToInt(re.cap(5));

  1060 

  1061     int sx = convertToInt(re.cap(6));

  1062     int sy = convertToInt(re.cap(7));

  1063 

  1064     if (tw == 0) tw = -1;

  1065     if (th == 0) th = -1;

  1066 

  1067     if (m_verboseMode)

  1068         printf(" -(lance) drawTiledPixmap('%s' dim=(%d, %d), (%d, %d, %d, %d), (%d, %d)\n",

  1069                qPrintable(re.cap(1)), pm.width(), pm.height(), tx, ty, tw, th, sx, sy);

  1070 

  1071     m_painter->drawTiledPixmap(tx, ty, tw, th, pm, sx, sy);

  1072 }

  1073 

  1074 /***************************************************************************************************/

  1075 void PaintCommands::command_drawPoint(QRegExp re)

  1076 {

  1077     QStringList caps = re.capturedTexts();

  1078     float x = convertToFloat(caps.at(1));

  1079     float y = convertToFloat(caps.at(2));

  1080 

  1081     if (m_verboseMode)

  1082         printf(" -(lance) drawPoint(%.2f, %.2f)\n", x, y);

  1083 

  1084     m_painter->drawPoint(QPointF(x, y));

  1085 }

  1086 

  1087 /***************************************************************************************************/

  1088 void PaintCommands::command_drawPolygon(QRegExp re)

  1089 {

  1090     static QRegExp separators("\\s");

  1091     QStringList caps = re.capturedTexts();

  1092     QString cap = caps.at(1);

  1093     QStringList numbers = cap.split(separators, QString::SkipEmptyParts);

  1094 

  1095     QPolygonF array;

  1096     for (int i=0; i + 1<numbers.size(); i+=2)

  1097         array.append(QPointF(convertToDouble(numbers.at(i)), convertToDouble(numbers.at(i+1))));

  1098 

  1099     if (m_verboseMode)

  1100         printf(" -(lance) drawPolygon(size=%d)\n", array.size());

  1101 

  1102     m_painter->drawPolygon(array, caps.at(2).toLower() == "winding" ? Qt::WindingFill : Qt::OddEvenFill);

  1103 }

  1104 

  1105 /***************************************************************************************************/

  1106 void PaintCommands::command_drawPolyline(QRegExp re)

  1107 {

  1108     static QRegExp separators("\\s");

  1109     QStringList numbers = re.cap(1).split(separators, QString::SkipEmptyParts);

  1110 

  1111     QPolygonF array;

  1112     for (int i=0; i + 1<numbers.size(); i+=2)

  1113         array.append(QPointF(numbers.at(i).toFloat(),numbers.at(i+1).toFloat()));

  1114 

  1115     if (m_verboseMode)

  1116         printf(" -(lance) drawPolyline(size=%d)\n", array.size());

  1117 

  1118     m_painter->drawPolyline(array.toPolygon());

  1119 }

  1120 

  1121 /***************************************************************************************************/

  1122 void PaintCommands::command_drawRect(QRegExp re)

  1123 {

  1124     QStringList caps = re.capturedTexts();

  1125     float x = convertToFloat(caps.at(1));

  1126     float y = convertToFloat(caps.at(2));

  1127     float w = convertToFloat(caps.at(3));

  1128     float h = convertToFloat(caps.at(4));

  1129 

  1130     if (m_verboseMode)

  1131         printf(" -(lance) drawRect(%.2f, %.2f, %.2f, %.2f)\n", x, y, w, h);

  1132 

  1133     m_painter->drawRect(QRectF(x, y, w, h));

  1134 }