Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

8 files changed, 1343 insertions, 0 deletions

diff --git a/tests/arthur/lance/enum.png b/tests/arthur/lance/enum.png
new file mode 100644
index 0000000000..ae19bd49b0
--- /dev/null
+++ b/tests/arthur/lance/enum.png
diff --git a/tests/arthur/lance/icons.qrc b/tests/arthur/lance/icons.qrc
new file mode 100644
index 0000000000..bf0f12d845
--- /dev/null
+++ b/tests/arthur/lance/icons.qrc
@@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/icons" >
+        <file>enum.png</file>
+        <file>tools.png</file>
+    </qresource>
+</RCC>
diff --git a/tests/arthur/lance/interactivewidget.cpp b/tests/arthur/lance/interactivewidget.cpp
new file mode 100644
index 0000000000..2fb03ab67c
--- /dev/null
+++ b/tests/arthur/lance/interactivewidget.cpp
@@ -0,0 +1,202 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "interactivewidget.h"
+#include <QtGui/QToolBox>
+
+InteractiveWidget::InteractiveWidget()
+{
+    m_onScreenWidget = new OnScreenWidget<QWidget>("");
+    m_onScreenWidget->setMinimumSize(320, 240);
+
+    setCentralWidget(m_onScreenWidget);
+
+    ui_textEdit = new QTextEdit();
+    ui_textEdit->installEventFilter(this);
+
+    QWidget *panelContent = new QWidget();
+    QVBoxLayout *vlayout = new QVBoxLayout(panelContent);
+    vlayout->setMargin(0);
+    vlayout->setSpacing(0);
+
+    // create and populate the command toolbox
+    m_commandsToolBox = new QToolBox();
+    QListWidget *currentListWidget = 0;
+    foreach (PaintCommands::PaintCommandInfos paintCommandInfo, PaintCommands::s_commandInfoTable) {
+        if (paintCommandInfo.isSectionHeader()) {
+            currentListWidget = new QListWidget();
+            m_commandsToolBox->addItem(currentListWidget, QIcon(":/icons/tools.png"), "commands - "+paintCommandInfo.identifier);
+            connect(currentListWidget, SIGNAL(itemActivated(QListWidgetItem*)), SLOT(cmdSelected(QListWidgetItem*)));
+        } else {
+            (new QListWidgetItem(paintCommandInfo.identifier, currentListWidget))->setToolTip(paintCommandInfo.syntax);
+        }
+    }
+
+    // create and populate the enumerations toolbox
+    m_enumsToolBox = new QToolBox();
+    typedef QPair<QString,QStringList> EnumListType;
+    foreach (EnumListType enumInfos, PaintCommands::s_enumsTable) {
+        currentListWidget = new QListWidget();
+        m_commandsToolBox->addItem(currentListWidget, QIcon(":/icons/enum.png"), "enums - "+enumInfos.first);
+        connect(currentListWidget, SIGNAL(itemActivated(QListWidgetItem*)), SLOT(enumSelected(QListWidgetItem*)));
+        foreach (QString enumItem, enumInfos.second)
+            new QListWidgetItem(enumItem, currentListWidget);
+    }
+
+    // add other widgets and layout
+    vlayout->addWidget(m_commandsToolBox);
+    vlayout->addWidget(m_enumsToolBox);
+
+    QPushButton *run = new QPushButton("&Run");
+    QPushButton *load = new QPushButton("&Load");
+    QPushButton *save = new QPushButton("&Save");
+    run->setFocusPolicy(Qt::NoFocus);
+
+    vlayout->addSpacing(20);
+    vlayout->addWidget(run);
+    vlayout->addWidget(load);
+    vlayout->addWidget(save);
+
+    QDockWidget *panel = new QDockWidget("Commands");
+    panel->setWidget(panelContent);
+    addDockWidget(Qt::LeftDockWidgetArea, panel);
+
+    QDockWidget *editor = new QDockWidget("Editor");
+    editor->setWidget(ui_textEdit);
+    addDockWidget(Qt::RightDockWidgetArea, editor);
+
+    // connect gui signals
+    connect(run, SIGNAL(clicked()), SLOT(run()));
+    connect(load, SIGNAL(clicked()), SLOT(load()));
+    connect(save, SIGNAL(clicked()), SLOT(save()));
+}
+
+/***************************************************************************************************/
+void InteractiveWidget::run()
+{
+    m_onScreenWidget->m_commands.clear();
+    QString script = ui_textEdit->toPlainText();
+    QStringList lines = script.split("\n");
+    for (int i = 0; i < lines.size(); ++i)
+        m_onScreenWidget->m_commands.append(lines.at(i));
+    m_onScreenWidget->repaint();
+}
+
+/***************************************************************************************************/
+void InteractiveWidget::cmdSelected(QListWidgetItem *item)
+{
+    if (ui_textEdit->textCursor().atBlockStart()) {
+        ui_textEdit->insertPlainText(PaintCommands::findCommandById(item->text())->sample + "\n");
+    } else {
+        ui_textEdit->moveCursor(QTextCursor::EndOfLine);
+        ui_textEdit->insertPlainText("\n" + PaintCommands::findCommandById(item->text())->sample);
+    }
+    ui_textEdit->setFocus();
+}
+
+/***************************************************************************************************/
+void InteractiveWidget::enumSelected(QListWidgetItem *item)
+{
+    ui_textEdit->insertPlainText(item->text());
+    ui_textEdit->setFocus();
+}
+
+/***************************************************************************************************/
+void InteractiveWidget::load()
+{
+    QString fname = QFileDialog::getOpenFileName(
+        this,
+        QString("Load QPaintEngine Script"),
+        QFileInfo(m_filename).absoluteFilePath(),
+        QString("QPaintEngine Script (*.qps);;All files (*.*)"));
+
+    load(fname);
+}
+
+/***************************************************************************************************/
+void InteractiveWidget::load(const QString &fname)
+{
+    if (!fname.isEmpty()) {
+        m_filename = fname;
+        ui_textEdit->clear();
+        QFile file(fname);
+        file.open(QIODevice::ReadOnly | QIODevice::Text);
+        QTextStream textFile(&file);
+        QString script = textFile.readAll();
+        ui_textEdit->setPlainText(script);
+        m_onScreenWidget->m_filename = fname;
+    }
+}
+
+/***************************************************************************************************/
+void InteractiveWidget::save()
+{
+    QString script = ui_textEdit->toPlainText();
+    if (!script.endsWith("\n"))
+        script += QString("\n");
+    QString fname = QFileDialog::getSaveFileName(this,
+                            QString("Save QPaintEngine Script"),
+                            QFileInfo(m_filename).absoluteFilePath(),
+                            QString("QPaintEngine Script (*.qps);;All files (*.*)"));
+    if (!fname.isEmpty()) {
+        m_filename = fname;
+        QFile file(fname);
+        file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
+        QTextStream textFile(&file);
+        textFile << script;
+        m_onScreenWidget->m_filename = fname;
+    }
+}
+
+/***************************************************************************************************/
+bool InteractiveWidget::eventFilter(QObject *o, QEvent *e)
+{
+    if (qobject_cast<QTextEdit *>(o) && e->type() == QEvent::KeyPress) {
+        QKeyEvent *ke = static_cast<QKeyEvent *>(e);
+        if (ke->key() == Qt::Key_Tab) {
+            m_commandsToolBox->currentWidget()->setFocus();
+            return true;
+        } else if (ke->key() == Qt::Key_Return && ke->modifiers() == Qt::ControlModifier) {
+            run();
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/tests/arthur/lance/interactivewidget.h b/tests/arthur/lance/interactivewidget.h
new file mode 100644
index 0000000000..86cc7fc1e8
--- /dev/null
+++ b/tests/arthur/lance/interactivewidget.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef INTERACTIVEWIDGET_H
+#define INTERACTIVEWIDGET_H
+
+#include "widgets.h"
+#include "paintcommands.h"
+
+#include <QtGui>
+
+#include <private/qmath_p.h>
+
+QT_FORWARD_DECLARE_CLASS(QToolBox)
+
+class InteractiveWidget : public QMainWindow
+{
+    Q_OBJECT
+public:
+    InteractiveWidget();
+
+public slots:
+    void run();
+    void load();
+    void load(const QString &fname);
+    void save();
+
+protected:
+    bool eventFilter(QObject *o, QEvent *e);
+
+protected slots:
+    void cmdSelected(QListWidgetItem *item);
+    void enumSelected(QListWidgetItem *item);
+
+private:
+    QToolBox *m_commandsToolBox;
+    QToolBox *m_enumsToolBox;
+    OnScreenWidget<QWidget> *m_onScreenWidget;
+    QTextEdit *ui_textEdit;
+    QString m_filename;
+};
+
+#endif
diff --git a/tests/arthur/lance/lance.pro b/tests/arthur/lance/lance.pro
new file mode 100644
index 0000000000..56b7f25b81
--- /dev/null
+++ b/tests/arthur/lance/lance.pro
@@ -0,0 +1,23 @@
+COMMON_FOLDER = $$PWD/../common
+include(../arthurtester.pri)
+CONFIG+=console moc
+TEMPLATE = app
+INCLUDEPATH += .
+
+# Input
+HEADERS += widgets.h interactivewidget.h
+SOURCES += interactivewidget.cpp main.cpp
+RESOURCES += icons.qrc
+
+contains(QT_CONFIG, opengl)|contains(QT_CONFIG, opengles1)|contains(QT_CONFIG, opengles2):QT += opengl
+contains(QT_CONFIG, qt3support):QT += qt3support
+
+symbian*: {
+    testData.files = $$QT_BUILD_TREE/tests/arthur/data/qps
+    testData.path = .
+    DEPLOYMENT += testData
+}
+
+QT += xml svg 
+
+
diff --git a/tests/arthur/lance/main.cpp b/tests/arthur/lance/main.cpp
new file mode 100644
index 0000000000..2bda932130
--- /dev/null
+++ b/tests/arthur/lance/main.cpp
@@ -0,0 +1,678 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "interactivewidget.h"
+#include "widgets.h"
+#include "paintcommands.h"
+
+#include <QtCore>
+#include <QtGui>
+#include <qimage.h>
+#include <QPicture>
+
+#include <private/qmath_p.h>
+
+#ifdef USE_CUSTOM_DEVICE
+#include "customdevice.h"
+#endif
+
+#ifndef QT_NO_OPENGL
+#include <qgl.h>
+#include <QGLPixelBuffer>
+#endif
+
+// #define DO_QWS_DEBUGGING
+
+#ifdef DO_QWS_DEBUGGING
+extern bool qt_show_painter_debug_output = false;
+#endif
+
+//#define CONSOLE_APPLICATION
+
+static const struct {
+    const char *name;
+    QImage::Format format;
+} imageFormats[] = {
+    { "mono", QImage::Format_Mono },
+    { "monolsb", QImage::Format_MonoLSB },
+    { "indexed8", QImage::Format_Indexed8 },
+    { "rgb32", QImage::Format_RGB32 },
+    { "argb32", QImage::Format_ARGB32 },
+    { "argb32_premultiplied", QImage::Format_ARGB32_Premultiplied },
+    { "rgb16", QImage::Format_RGB16 },
+    { "argb8565_premultiplied", QImage::Format_ARGB8565_Premultiplied },
+    { "rgb666", QImage::Format_RGB666 },
+    { "argb6666_premultiplied", QImage::Format_ARGB6666_Premultiplied },
+    { "rgb555", QImage::Format_RGB555 },
+    { "argb8555_premultiplied", QImage::Format_ARGB8555_Premultiplied },
+    { "rgb888", QImage::Format_RGB888 },
+    { "rgb444", QImage::Format_RGB444 },
+    { "argb4444_premultiplied", QImage::Format_ARGB4444_Premultiplied }
+};
+
+static void printHelp()
+{
+    printf("\nUsage:\n\n"
+           "  paintcmd [options] files\n"
+           "\n"
+           "  Options:\n"
+           "    -widget         Paints the files to a widget on screen\n"
+           "    -pixmap         Paints the files to a pixmap\n"
+           "    -bitmap         Paints the files to a bitmap\n"
+           "    -image          Paints the files to an image\n"
+           "    -imageformat    Set the format of the image when painting to an image\n"
+           "    -imagemono      Paints the files to a monochrome image\n"
+           "    -imagewidget    same as image, but with interacion...\n"
+#ifndef QT_NO_OPENGL
+           "    -opengl         Paints the files to an OpenGL on screen\n"
+#endif
+#ifdef USE_CUSTOM_DEVICE
+           "    -customdevice   Paints the files to the custom paint device\n"
+           "    -customwidget   Paints the files to a custom widget on screen\n"
+#endif
+           "    -pdf            Paints to a pdf\n"
+           "    -ps             Paints to a ps\n"
+           "    -picture        Prints into a picture, then shows the result in a label\n"
+           "    -printer        Prints the commands to a file called output.ps|pdf\n"
+           "    -highres        Prints in highres mode\n"
+           "    -printdialog    Opens a print dialog, then prints to the selected printer\n"
+           "    -grab           Paints the files to an image called filename_qps.png\n"
+           "    -i              Interactive mode.\n"
+           "    -v              Verbose.\n"
+           "    -bg-white       No checkers background\n"
+           "    -commands       Displays all available commands\n");
+}
+
+static void displayCommands()
+{
+    printf("Drawing operations:\n"
+           "  drawArc x y width height angle sweep\n"
+           "  drawChord x y width height angle sweep\n"
+           "  drawEllipse x y width height\n"
+           "  drawLine x1 y1 x2 y2\n"
+           "  drawPath pathname\n"
+           "  drawPie x y width height angle sweep\n"
+           "  drawPixmap pixmapfile x y width height sx sy sw sh\n"
+           "  drawPolygon [ x1 y1 x2 y2 ... ] winding|oddeven\n"
+           "  drawPolyline [ x1 y1 x2 y2 ... ]\n"
+           "  drawRect x y width height\n"
+           "  drawRoundRect x y width height xfactor yfactor\n"
+           "  drawText x y \"text\"\n"
+           "  drawTiledPixmap pixmapfile x y width height sx sy\n"
+           "\n"
+           "Compat functions for Qt 3:\n"
+           "  qt3_drawArc x y width height angle sweep\n"
+           "  qt3_drawChord x y width height angle sweep\n"
+           "  qt3_drawEllipse x y width height\n"
+           "  qt3_drawPie x y width height angle sweep\n"
+           "  qt3_drawRect x y width height\n"
+           "  qt3_drawRoundRect x y width height xfactor yfactor\n"
+           "\n"
+           "Path commands:\n"
+           "  path_addEllipse pathname x y width height\n"
+           "  path_addPolygon pathname [ x1 y1 x2 y2 ... ] winding?\n"
+           "  path_addRect pathname x y width height\n"
+           "  path_addText pathname x y \"text\"                        Uses current font\n"
+           "  path_arcTo pathname x y width hegiht\n"
+           "  path_closeSubpath pathname\n"
+           "  path_createOutline pathname newoutlinename                Uses current pen\n"
+           "  path_cubicTo pathname c1x c1y c2x c2y endx endy\n"
+           "  path_lineTo pathname x y\n"
+           "  path_moveTo pathname x y\n"
+           "  path_setFillRule pathname winding?\n"
+           "\n"
+           "Painter configuration:\n"
+           "  resetMatrix\n"
+           "  restore\n"
+           "  save\n"
+           "  rotate degrees\n"
+           "  translate dx dy\n"
+           "  scale sx sy\n"
+           "  mapQuadToQuad x0 y0 x1 y1 x2 y2 x3 y3  x4 y4 x5 y5 x6 y6 x7 y7"
+           "  setMatrix m11 m12 m13 m21 m22 m23 m31 m32 m33"
+           "  setBackground color pattern?\n"
+           "  setBackgroundMode TransparentMode|OpaqueMode\n"
+           "  setBrush pixmapfile\n"
+           "  setBrush nobrush\n"
+           "  setBrush color pattern\n"
+           "  setBrush x1 y1 color1 x2 y2 color2                        gradient brush\n"
+           "  setBrushOrigin x y\n"
+           "  setFont \"fontname\" pointsize bold? italic?\n"
+           "  setPen style color\n"
+           "  setPen color width style capstyle joinstyle\n"
+           "  setRenderHint LineAntialiasing\n"
+           "  gradient_clearStops\n"
+           "  gradient_appendStop pos color"
+           "  gradient_setSpread [PadSpread|ReflectSpread|RepeatSpread]\n"
+           "  gradient_setLinear x1 y1 x2 y2\n"
+           "  gradient_setRadial center_x center_y radius focal_x focal_y\n"
+           "  gradient_setConical center_x center_y angle\n"
+           "\n"
+           "Clipping commands:\n"
+           "  region_addRect regionname x y width height\n"
+           "  region_getClipRegion regionname\n"
+           "  setClipRect x y width height\n"
+           "  setClipRegion regionname\n"
+           "  setClipping true|false\n"
+           "  setClipPath pathname\n"
+           "\n"
+           "Various commands:\n"
+           "  surface_begin x y width height\n"
+           "  surface_end\n"
+           "  pixmap_load filename name_in_script\n"
+           "  image_load filename name_in_script\n");
+}
+static InteractiveWidget *interactive_widget = 0;
+
+static void runInteractive()
+{
+    interactive_widget = new InteractiveWidget;
+    interactive_widget->show();
+}
+
+static QLabel* createLabel()
+{
+    QLabel *label = new QLabel;
+    QPalette palette = label->palette();
+    palette.setBrush(QPalette::Window, QBrush(Qt::white));
+    label->setPalette(palette);
+    return label;
+}
+
+int main(int argc, char **argv)
+{
+#ifdef CONSOLE_APPLICATION
+    QApplication app(argc, argv, QApplication::Tty);
+#else
+    QApplication app(argc, argv);
+#endif
+#ifdef DO_QWS_DEBUGGING
+    qt_show_painter_debug_output = false;
+#endif
+
+    DeviceType type = WidgetType;
+    bool checkers_background = true;
+
+    QImage::Format imageFormat = QImage::Format_ARGB32_Premultiplied;
+
+    QLocale::setDefault(QLocale::c());
+
+    QStringList files;
+
+    bool interactive = false;
+    bool printdlg = false;
+    bool highres = false;
+    bool show_cmp = false;
+    int width = 800, height = 800;
+    bool verboseMode = false;
+
+#ifndef QT_NO_OPENGL
+    QGLFormat f = QGLFormat::defaultFormat();
+    f.setSampleBuffers(true);
+    f.setStencil(true);
+    f.setAlpha(true);
+    f.setAlphaBufferSize(8);
+    QGLFormat::setDefaultFormat(f);
+#endif
+
+    char *arg;
+    for (int i=1; i<argc; ++i) {
+        arg = argv[i];
+        if (*arg == '-') {
+            QString option = QString(arg + 1).toLower();
+            if (option == "widget")
+                type = WidgetType;
+            else if (option == "bitmap")
+                type = BitmapType;
+            else if (option == "pixmap")
+                type = PixmapType;
+            else if (option == "image")
+                type = ImageType;
+            else if (option == "imageformat") {
+                Q_ASSERT_X(i + 1 < argc, "main", "-imageformat must be followed by a value");
+                QString format = QString(argv[++i]).toLower();
+
+                imageFormat = QImage::Format_Invalid;
+                static const int formatCount =
+                    sizeof(imageFormats) / sizeof(imageFormats[0]);
+                for (int ff = 0; ff < formatCount; ++ff) {
+                    if (QLatin1String(imageFormats[ff].name) == format) {
+                        imageFormat = imageFormats[ff].format;
+                        break;
+                    }
+                }
+
+                if (imageFormat == QImage::Format_Invalid) {
+                    printf("Invalid image format.  Available formats are:\n");
+                    for (int ff = 0; ff < formatCount; ++ff)
+                        printf("\t%s\n", imageFormats[ff].name);
+                    return -1;
+                }
+            } else if (option == "imagemono")
+                type = ImageMonoType;
+            else if (option == "imagewidget")
+                type = ImageWidgetType;
+#ifndef QT_NO_OPENGL
+            else if (option == "opengl")
+                type = OpenGLType;
+            else if (option == "pbuffer")
+                type = OpenGLPBufferType;
+#endif
+#ifdef USE_CUSTOM_DEVICE
+            else if (option == "customdevice")
+                type = CustomDeviceType;
+            else if (option == "customwidget")
+                type = CustomWidgetType;
+#endif
+            else if (option == "pdf")
+                type = PdfType;
+            else if (option == "ps")
+                type = PsType;
+            else if (option == "picture")
+                type = PictureType;
+            else if (option == "printer")
+                type = PrinterType;
+            else if (option == "highres") {
+                type = PrinterType;
+                highres = true;
+            } else if (option == "printdialog") {
+                type = PrinterType;
+                printdlg = true;
+            }
+            else if (option == "grab")
+                type = GrabType;
+            else if (option == "i")
+                interactive = true;
+            else if (option == "v")
+                verboseMode = true;
+            else if (option == "commands") {
+                displayCommands();
+                return 0;
+            } else if (option == "w") {
+                Q_ASSERT_X(i + 1 < argc, "main", "-w must be followed by a value");
+                width = atoi(argv[++i]);
+            } else if (option == "h") {
+                Q_ASSERT_X(i + 1 < argc, "main", "-h must be followed by a value");
+                height = atoi(argv[++i]);
+            } else if (option == "cmp") {
+                show_cmp = true;
+            } else if (option == "bg-white") {
+                checkers_background = false;
+            }
+        } else {
+#if defined (Q_WS_WIN)
+            QString input = QString::fromLocal8Bit(argv[i]);
+            if (input.indexOf('*') >= 0) {
+                QFileInfo info(input);
+                QDir dir = info.dir();
+                QFileInfoList infos = dir.entryInfoList(QStringList(info.fileName()));
+                for (int ii=0; ii<infos.size(); ++ii)
+                    files.append(infos.at(ii).absoluteFilePath());
+            } else {
+                files.append(input);
+            }
+#else
+            files.append(QString(argv[i]));
+#endif
+        }
+    }
+
+    PaintCommands pcmd(QStringList(), 800, 800);
+    pcmd.setVerboseMode(verboseMode);
+    pcmd.setType(type);
+    pcmd.setCheckersBackground(checkers_background);
+
+    QWidget *activeWidget = 0;
+
+    if (interactive) {
+        runInteractive();
+        if (!files.isEmpty())
+            interactive_widget->load(files.at(0));
+    } else if (files.isEmpty()) {
+        printHelp();
+        return 0;
+    } else {
+        for (int j=0; j<files.size(); ++j) {
+            const QString &fileName = files.at(j);
+            QStringList content;
+
+            QFile file(fileName);
+            QFileInfo fileinfo(file);
+            if (file.open(QIODevice::ReadOnly)) {
+                QTextStream textFile(&file);
+                QString script = textFile.readAll();
+                content = script.split("\n", QString::SkipEmptyParts);
+            } else {
+                printf("failed to read file: '%s'\n", qPrintable(fileinfo.absoluteFilePath()));
+                continue;
+            }
+            pcmd.setContents(content);
+
+            if (show_cmp) {
+                QString pmFile = QString(files.at(j)).replace(".qps", "_qps") + ".png";
+                qDebug() << pmFile << QFileInfo(pmFile).exists();
+                QPixmap pixmap(pmFile);
+                if (!pixmap.isNull()) {
+                    QLabel *label = createLabel();
+                    label->setWindowTitle("VERIFY: " + pmFile);
+                    label->setPixmap(pixmap);
+                    label->show();
+                }
+            }
+
+            switch (type) {
+
+            case WidgetType:
+            {
+                OnScreenWidget<QWidget> *qWidget =
+                    new OnScreenWidget<QWidget>(files.at(j));
+                qWidget->setVerboseMode(verboseMode);
+                qWidget->setType(type);
+                qWidget->setCheckersBackground(checkers_background);
+                qWidget->m_commands = content;
+                qWidget->resize(width, height);
+                qWidget->show();
+                activeWidget = qWidget;
+                break;
+            }
+
+            case ImageWidgetType:
+            {
+                OnScreenWidget<QWidget> *qWidget = new OnScreenWidget<QWidget>(files.at(j));
+                qWidget->setVerboseMode(verboseMode);
+                qWidget->setType(type);
+                qWidget->setCheckersBackground(checkers_background);
+                qWidget->m_commands = content;
+                qWidget->resize(width, height);
+                qWidget->show();
+                activeWidget = qWidget;
+                break;
+
+            }
+#ifndef QT_NO_OPENGL
+            case OpenGLPBufferType:
+            {
+                QGLPixelBuffer pbuffer(QSize(width, height));
+                QPainter pt(&pbuffer);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+
+                QImage image = pbuffer.toImage();
+
+                QLabel *label = createLabel();
+                label->setPixmap(QPixmap::fromImage(image));
+                label->resize(label->sizeHint());
+                label->show();
+                activeWidget = label;
+                break;
+            }
+            case OpenGLType:
+            {
+                OnScreenWidget<QGLWidget> *qGLWidget = new OnScreenWidget<QGLWidget>(files.at(j));
+                qGLWidget->setVerboseMode(verboseMode);
+                qGLWidget->setType(type);
+                qGLWidget->setCheckersBackground(checkers_background);
+                qGLWidget->m_commands = content;
+                qGLWidget->resize(width, height);
+                qGLWidget->show();
+                activeWidget = qGLWidget;
+                break;
+            }
+#else
+            case OpenGLType:
+                printf("OpenGL type not supported in this Qt build\n");
+                break;
+#endif
+#ifdef USE_CUSTOM_DEVICE
+            case CustomDeviceType:
+            {
+                CustomPaintDevice custom(width, height);
+                QPainter pt;
+                pt.begin(&custom);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+                QImage *img = custom.image();
+                if (img) {
+                    QLabel *label = createLabel();
+                    label->setPixmap(QPixmap::fromImage(*img));
+                    label->resize(label->sizeHint());
+                    label->show();
+                    activeWidget = label;
+                    img->save("custom_output_pixmap.png", "PNG");
+                } else {
+                    custom.save("custom_output_pixmap.png", "PNG");
+                }
+                break;
+            }
+            case CustomWidgetType:
+            {
+                OnScreenWidget<CustomWidget> *cWidget = new OnScreenWidget<CustomWidget>;
+                cWidget->setVerboseMode(verboseMode);
+                cWidget->setType(type);
+                cWidget->setCheckersBackground(checkers_background);
+                cWidget->m_filename = files.at(j);
+                cWidget->setWindowTitle(fileinfo.filePath());
+                cWidget->m_commands = content;
+                cWidget->resize(width, height);
+                cWidget->show();
+                activeWidget = cWidget;
+                break;
+            }
+#endif
+            case PixmapType:
+            {
+                QPixmap pixmap(width, height);
+                pixmap.fill(Qt::white);
+                QPainter pt(&pixmap);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+                pixmap.save("output_pixmap.png", "PNG");
+                break;
+            }
+
+            case BitmapType:
+            {
+                QBitmap bitmap(width, height);
+                QPainter pt(&bitmap);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+                bitmap.save("output_bitmap.png", "PNG");
+
+                QLabel *label = createLabel();
+                label->setPixmap(bitmap);
+                label->resize(label->sizeHint());
+                label->show();
+                activeWidget = label;
+                break;
+            }
+
+            case ImageMonoType:
+            case ImageType:
+            {
+                qDebug() << "Creating image";
+                QImage image(width, height, type == ImageMonoType
+                             ? QImage::Format_MonoLSB
+                             : imageFormat);
+                image.fill(0);
+                QPainter pt(&image);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+                image.convertToFormat(QImage::Format_ARGB32).save("output_image.png", "PNG");
+#ifndef CONSOLE_APPLICATION
+                QLabel *label = createLabel();
+                label->setPixmap(QPixmap::fromImage(image));
+                label->resize(label->sizeHint());
+                label->show();
+                activeWidget = label;
+#endif
+                break;
+            }
+
+            case PictureType:
+            {
+                QPicture pic;
+                QPainter pt(&pic);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+
+                QImage image(width, height, QImage::Format_ARGB32_Premultiplied);
+                image.fill(0);
+                pt.begin(&image);
+                pt.drawPicture(0, 0, pic);
+                pt.end();
+                QLabel *label = createLabel();
+                label->setWindowTitle(fileinfo.absolutePath());
+                label->setPixmap(QPixmap::fromImage(image));
+                label->resize(label->sizeHint());
+                label->show();
+                activeWidget = label;
+                break;
+            }
+
+            case PrinterType:
+            {
+#ifndef QT_NO_PRINTER
+                PaintCommands pcmd(QStringList(), 800, 800);
+                pcmd.setVerboseMode(verboseMode);
+                pcmd.setType(type);
+                pcmd.setCheckersBackground(checkers_background);
+                pcmd.setContents(content);
+                QString file = QString(files.at(j)).replace(".", "_") + ".ps";
+
+                QPrinter p(highres ? QPrinter::HighResolution : QPrinter::ScreenResolution);
+                if (printdlg) {
+                    QPrintDialog printDialog(&p, 0);
+                    if (printDialog.exec() != QDialog::Accepted)
+                        break;
+                } else {
+                    p.setOutputFileName(file);
+                }
+
+                QPainter pt(&p);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+
+                if (!printdlg) {
+                    printf("wrote file: %s\n", qPrintable(file));
+                }
+
+                Q_ASSERT(!p.paintingActive());
+#endif
+                break;
+            }
+            case PsType:
+            case PdfType:
+            {
+#ifndef QT_NO_PRINTER
+                PaintCommands pcmd(QStringList(), 800, 800);
+                pcmd.setVerboseMode(verboseMode);
+                pcmd.setType(type);
+                pcmd.setCheckersBackground(checkers_background);
+                pcmd.setContents(content);
+                bool ps = type == PsType;
+                QPrinter p(highres ? QPrinter::HighResolution : QPrinter::ScreenResolution);
+                QFileInfo input(files.at(j));
+                QString file = QString("%1_%2.%3")
+                               .arg(input.baseName())
+                               .arg(input.suffix())
+                               .arg(ps ? "ps" : "pdf");
+                p.setOutputFormat(ps ? QPrinter::PdfFormat : QPrinter::PostScriptFormat);
+                p.setOutputFileName(file);
+                p.setPageSize(QPrinter::A4);
+                QPainter pt(&p);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+
+                printf("write file: %s\n", qPrintable(file));
+#endif
+                break;
+            }
+            case GrabType:
+            {
+                QImage image(width, height, QImage::Format_ARGB32_Premultiplied);
+                image.fill(QColor(Qt::white).rgb());
+                QPainter pt(&image);
+                pcmd.setPainter(&pt);
+                pcmd.setFilePath(fileinfo.absolutePath());
+                pcmd.runCommands();
+                pt.end();
+                QImage image1(width, height, QImage::Format_RGB32);
+                image1.fill(QColor(Qt::white).rgb());
+                QPainter pt1(&image1);
+                pt1.drawImage(QPointF(0, 0), image);
+                pt1.end();
+
+                QString filename = QString(files.at(j)).replace(".qps", "_qps") + ".png";
+                image1.save(filename, "PNG");
+                printf("%s grabbed to %s\n", qPrintable(files.at(j)), qPrintable(filename));
+                break;
+            }
+            default:
+                break;
+            }
+        }
+    }
+#ifndef CONSOLE_APPLICATION
+    if (activeWidget || interactive) {
+        QObject::connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));
+        app.exec();
+    }
+    delete activeWidget;
+#endif
+    delete interactive_widget;
+    return 0;
+}
+
diff --git a/tests/arthur/lance/tools.png b/tests/arthur/lance/tools.png
new file mode 100644
index 0000000000..822e1e576e
--- /dev/null
+++ b/tests/arthur/lance/tools.png
diff --git a/tests/arthur/lance/widgets.h b/tests/arthur/lance/widgets.h
new file mode 100644
index 0000000000..4643411f69
--- /dev/null
+++ b/tests/arthur/lance/widgets.h
@@ -0,0 +1,354 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef WIDGETS_H
+#define WIDGETS_H
+
+#include "paintcommands.h"
+
+#include <QWidget>
+#include <QSettings>
+#include <QFileInfo>
+#include <QPainter>
+#include <QPaintEvent>
+#include <QListWidgetItem>
+#include <QTextEdit>
+#include <QHBoxLayout>
+#include <QSplitter>
+#include <QPushButton>
+#include <QFileDialog>
+#include <QTextStream>
+#include <QPaintEngine>
+#include <QSignalMapper>
+#include <QAction>
+
+
+#include <private/qwindowsurface_p.h>
+
+#include <qmath.h>
+
+const int CP_RADIUS = 10;
+
+class StupidWorkaround : public QObject
+{
+    Q_OBJECT
+public:
+    StupidWorkaround(QWidget *widget, int *value)
+        : QObject(widget), w(widget), mode(value)
+    {
+    }
+
+public slots:
+    void setViewMode(int m) {
+        *mode = m;
+        w->update();
+    }
+
+private:
+    QWidget *w;
+    int *mode;
+};
+
+template <class T>
+class OnScreenWidget : public T
+{
+public:
+
+    enum ViewMode {
+        RenderView,
+        BaselineView,
+        DifferenceView
+    };
+
+    OnScreenWidget(const QString &file, QWidget *parent = 0)
+        : T(parent),
+          m_filename(file),
+          m_view_mode(RenderView)
+    {
+        QSettings settings("Trolltech", "lance");
+        for (int i=0; i<10; ++i) {
+            QPointF suggestion(100 + i * 40, 100 + 100 * qSin(i * 3.1415 / 10.0));
+            m_controlPoints << settings.value("cp" + QString::number(i), suggestion).toPointF();
+        }
+
+        m_currentPoint = -1;
+        m_showControlPoints = false;
+        m_deviceType = WidgetType;
+        m_checkersBackground = true;
+        m_verboseMode = false;
+
+        m_baseline_name = QString(m_filename).replace(".qps", "_qps") + ".png";
+        if (QFileInfo(m_baseline_name).exists()) {
+            m_baseline = QPixmap(m_baseline_name);
+        }
+
+        if (m_baseline.isNull()) {
+            T::setWindowTitle("Rendering: '" + file + "'. No baseline available");
+        } else {
+            T::setWindowTitle("Rendering: '" + file + "'. Shortcuts: 1=render, 2=baseline, 3=difference");
+
+            StupidWorkaround *workaround = new StupidWorkaround(this, &m_view_mode);
+
+            QSignalMapper *mapper = new QSignalMapper(this);
+            T::connect(mapper, SIGNAL(mapped(int)), workaround, SLOT(setViewMode(int)));
+            T::connect(mapper, SIGNAL(mapped(QString)), this, SLOT(setWindowTitle(QString)));
+
+            QAction *renderViewAction = new QAction("Render View", this);
+            renderViewAction->setShortcut(Qt::Key_1);
+            T::connect(renderViewAction, SIGNAL(triggered()), mapper, SLOT(map()));
+            mapper->setMapping(renderViewAction, RenderView);
+            mapper->setMapping(renderViewAction, "Render View: " + file);
+            T::addAction(renderViewAction);
+
+            QAction *baselineAction = new QAction("Baseline", this);
+            baselineAction->setShortcut(Qt::Key_2);
+            T::connect(baselineAction, SIGNAL(triggered()), mapper, SLOT(map()));
+            mapper->setMapping(baselineAction, BaselineView);
+            mapper->setMapping(baselineAction, "Baseline View: " + file);
+            T::addAction(baselineAction);
+
+            QAction *differenceAction = new QAction("Differenfe View", this);
+            differenceAction->setShortcut(Qt::Key_3);
+            T::connect(differenceAction, SIGNAL(triggered()), mapper, SLOT(map()));
+            mapper->setMapping(differenceAction, DifferenceView);
+            mapper->setMapping(differenceAction, "Difference View" + file);
+            T::addAction(differenceAction);
+
+        }
+
+    }
+
+    ~OnScreenWidget()
+    {
+        QSettings settings("Trolltech", "lance");
+        for (int i=0; i<10; ++i) {
+            settings.setValue("cp" + QString::number(i), m_controlPoints.at(i));
+        }
+        settings.sync();
+    }
+
+    void setVerboseMode(bool v) { m_verboseMode = v; }
+    void setCheckersBackground(bool b) { m_checkersBackground = b; }
+    void setType(DeviceType t) { m_deviceType = t; }
+
+    void resizeEvent(QResizeEvent *e) {
+        m_image = QImage();
+        T::resizeEvent(e);
+    }
+
+    void paintEvent(QPaintEvent *) {
+        switch (m_view_mode) {
+        case RenderView: paintRenderView(); break;
+        case BaselineView: paintBaselineView(); break;
+        case DifferenceView: paintDifferenceView(); break;
+        }
+    }
+
+    void paintRenderView()
+    {
+        QPainter pt;
+        QPaintDevice *dev = this;
+        if (m_deviceType == ImageWidgetType) {
+            if (m_image.size() != T::size())
+                m_image = QImage(T::size(), QImage::Format_ARGB32_Premultiplied);
+            m_image.fill(0);
+            dev = &m_image;
+        }
+
+        pt.begin(dev);
+
+        PaintCommands paintCommands(m_commands, 800, 800);
+        paintCommands.setVerboseMode(m_verboseMode);
+        paintCommands.setCheckersBackground(m_checkersBackground);
+        paintCommands.setType(m_deviceType);
+        paintCommands.setPainter(&pt);
+        paintCommands.setControlPoints(m_controlPoints);
+        paintCommands.setFilePath(QFileInfo(m_filename).absolutePath());
+#ifdef DO_QWS_DEBUGGING
+        qt_show_painter_debug_output = true;
+#endif
+        pt.save();
+        paintCommands.runCommands();
+        pt.restore();
+#ifdef DO_QWS_DEBUGGING
+        qt_show_painter_debug_output = false;
+#endif
+
+        pt.end();
+
+        if (m_deviceType == ImageWidgetType) {
+            QPainter(this).drawImage(0, 0, m_image);
+        }
+
+        if (m_currentPoint >= 0 || m_showControlPoints) {
+            pt.begin(this);
+            pt.setRenderHint(QPainter::Antialiasing);
+            pt.setFont(this->font());
+            pt.resetMatrix();
+            pt.setPen(QColor(127, 127, 127, 191));
+            pt.setBrush(QColor(191, 191, 255, 63));
+            for (int i=0; i<m_controlPoints.size(); ++i) {
+                if (m_showControlPoints || m_currentPoint == i) {
+                    QPointF cp = m_controlPoints.at(i);
+                    QRectF rect(cp.x() - CP_RADIUS, cp.y() - CP_RADIUS,
+                                CP_RADIUS * 2, CP_RADIUS * 2);
+                    pt.drawEllipse(rect);
+                    pt.drawText(rect, Qt::AlignCenter, QString::number(i));
+                }
+            }
+        }
+
+        if (m_render_view.isNull()) {
+
+            if (T::window()->windowSurface())
+                m_render_view = T::window()->windowSurface()->grabWidget(this);
+            else
+                m_render_view = QPixmap::grabWidget(this);
+
+            m_render_view.save("renderView.png");
+        }
+    }
+
+    void paintBaselineView() {
+        QPainter p(this);
+
+        if (m_baseline.isNull()) {
+            p.drawText(T::rect(), Qt::AlignCenter,
+                       "No baseline found\n"
+                       "file '" + m_baseline_name + "' does not exist...");
+            return;
+        }
+
+        p.drawPixmap(0, 0, m_baseline);
+
+        p.setPen(QColor::fromRgb(0, 0, 0, 0.1));
+        p.setFont(QFont("Arial", 128));
+        p.rotate(45);
+        p.drawText(100, 0, "BASELINE");
+    }
+
+    QPixmap generateDifference()
+    {
+        QImage img(T::size(), QImage::Format_RGB32);
+        img.fill(0);
+
+        QPainter p(&img);
+        p.drawPixmap(0, 0, m_render_view);
+
+        p.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
+        p.drawPixmap(0, 0, m_baseline);
+
+        p.end();
+
+        return QPixmap::fromImage(img);
+    }
+
+    void paintDifferenceView() {
+        QPainter p(this);
+        if (m_baseline.isNull()) {
+            p.drawText(T::rect(), Qt::AlignCenter,
+                       "No baseline found\n"
+                       "file '" + m_baseline_name + "' does not exist...");
+            return;
+        }
+
+        p.fillRect(T::rect(), Qt::black);
+        p.drawPixmap(0, 0, generateDifference());
+    }
+
+
+    void mouseMoveEvent(QMouseEvent *e)
+    {
+        if (m_currentPoint == -1)
+            return;
+        if (T::rect().contains(e->pos()))
+            m_controlPoints[m_currentPoint] = e->pos();
+        T::update();
+    }
+
+    void mousePressEvent(QMouseEvent *e)
+    {
+        if (e->button() == Qt::RightButton) {
+            m_showControlPoints = true;
+        }
+
+        if (e->button() == Qt::LeftButton) {
+            for (int i=0; i<m_controlPoints.size(); ++i) {
+                if (QLineF(m_controlPoints.at(i), e->pos()).length() < CP_RADIUS) {
+                    m_currentPoint = i;
+                    break;
+                }
+            }
+        }
+        T::update();
+    }
+
+    void mouseReleaseEvent(QMouseEvent *e)
+    {
+        if (e->button() == Qt::LeftButton)
+            m_currentPoint = -1;
+        if (e->button() == Qt::RightButton)
+            m_showControlPoints = false;
+        T::update();
+    }
+
+    QSize sizeHint() const { return QSize(800, 800); }
+
+    QVector<QPointF> m_controlPoints;
+    int m_currentPoint;
+    bool m_showControlPoints;
+
+    QStringList m_commands;
+    QString m_filename;
+    QString m_baseline_name;
+
+    bool m_verboseMode;
+    bool m_checkersBackground;
+    DeviceType m_deviceType;
+
+    int m_view_mode;
+
+    QImage m_image;
+
+    QPixmap m_baseline;
+    QPixmap m_render_view;
+};
+
+#endif