<code C++>
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTreeWidgetItem>
#include <QToolButton>

#include <QGraphicsScene>
#include <QAbstractGraphicsShapeItem>
#include <QGraphicsRectItem>
#include <QGraphicsEllipseItem>

#include <QTableWidgetItem>

namespace Ui {
class MainWindow;
}

class ParamList : public QMap <QString, QString>
{
   public:
      int number (QString key, int default_value = 0);
};

class ColorButton : public QToolButton
{
private :
    QString name;
    QColor color;
public :
    ColorButton (QString s);
protected:
    void mousePressEvent(QMouseEvent *event);
};

class Common : private QObject
{
Q_OBJECT
public :
    ParamList params;
};

class Rectangle : public QGraphicsRectItem, public Common
{
protected:
    void dragEnterEvent (QGraphicsSceneDragDropEvent *event);
    void dropEvent (QGraphicsSceneDragDropEvent *event);
public:
    Rectangle ();
};

class Ellipse : public QGraphicsEllipseItem, public Common
{
protected:
    void dragEnterEvent (QGraphicsSceneDragDropEvent *event);
    void dropEvent (QGraphicsSceneDragDropEvent *event);
public:
    Ellipse ();
};


class TreeNode : public QTreeWidgetItem
{
public:
    Common * common;
    QAbstractGraphicsShapeItem * shape;
    TreeNode () : common (NULL), shape (NULL) { }
};

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

    void readFile(QString fileName);

    Rectangle * createRectangle (TreeNode * node,
                                 QGraphicsItem * target,
                                 ParamList param);

    Ellipse * createEllipse (TreeNode * node,
                             QGraphicsItem * target,
                             ParamList param);

    void modifyShape (QGraphicsItem * target,
                      QAbstractGraphicsShapeItem * shape,
                      ParamList param);

private slots:
    void on_treeWidget_itemClicked(QTreeWidgetItem *item, int column);

    void on_tableWidget_itemChanged(QTableWidgetItem *item);

private:
    Ui::MainWindow * ui;
    QGraphicsScene * scene;
    Common * current_element;
};

#endif // MAINWINDOW_H

</code>


<code C++>
#include "mainwindow.h"
#include "ui_mainwindow.h"

#include <QFile>
#include <QXmlStreamReader>
#include <QXmlStreamAttribute>

#include <QDrag>
#include <QMimeData>
#include <QIcon>
#include <QGraphicsSceneDragDropEvent>

int ParamList::number(QString key, int default_value)
{
    QString s = this->value (key);
    bool ok;
    int n = s.toInt (&ok);
    if (!ok)
        n = default_value;
    return n;
}

/* Color Button */

ColorButton::ColorButton(QString s)
  : name (s), color (QColor (s))
{
    setText (s);
    setToolTip (s);

    QPixmap p (24, 24);
    p.fill (QColor (0, 0, 0, 0));

    QPainter m (&p);
    m.setPen (color);
    m.setBrush (color);
    m.drawEllipse (2, 2, 20, 20);

    QIcon icon (p);
    setIcon (icon);
}

void ColorButton::mousePressEvent(QMouseEvent *event)
{
    QDrag * drag = new QDrag (this);
    QMimeData * data = new QMimeData ();
    data->setText (name);
    data->setColorData (color);
    drag->setMimeData(data);

    QPixmap p = this->icon().pixmap(12, 12);
    drag->setPixmap(p);

    drag->start(Qt::CopyAction | Qt::MoveAction);
};

/* Rectangle */

void Rectangle::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
{
    event->setAccepted(true);
}

void Rectangle::dropEvent(QGraphicsSceneDragDropEvent *event)
{
   const QMimeData * data =  event->mimeData();
   if (data->hasColor())
   {
       QColor c =  data->colorData().value <QColor> ();
       if (event->proposedAction() == Qt::MoveAction) /* shift */
          setPen (c);
       else
          setBrush (c);
   }
}

Rectangle::Rectangle()
{
    setAcceptDrops(true);
}

/* Ellipse */

void Ellipse::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
{
    event->setAccepted(true);
}

void Ellipse::dropEvent(QGraphicsSceneDragDropEvent *event)
{
   const QMimeData * data =  event->mimeData();
   if (data->hasColor())
   {
       QColor c =  data->colorData().value <QColor> ();
       if (event->proposedAction() == Qt::MoveAction) /* shift */
          setPen (c);
       else
          setBrush (c);
   }
}

Ellipse::Ellipse()
{
    setAcceptDrops(true);
}

/* MainWindow */

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    current_element (NULL)

{
    ui->setupUi(this);

    QList <QString> names;
    names << "red" << "blue" << "green" << "yellow" << "orange";

    for (auto name : names)
    {
       ColorButton * b = new ColorButton (name);
       ui->mainToolBar->addWidget (b);
    }

    scene = new QGraphicsScene;
    ui->graphicsView->setScene (scene);

    // scene->addLine (0, 0, 100, 100, QColor ("blue"));
    scene->setSceneRect (0, 0, 1024, 800);

    readFile ("../xml/data.xml");
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::readFile (QString fileName)
{
    QFile file (fileName);
    if (file.open (QFile::ReadOnly | QFile::Text ))
    {
        QTreeWidgetItem * branch =
                ui->treeWidget->invisibleRootItem();

        QGraphicsItem * target = NULL;

        QXmlStreamReader reader (&file);
        while (! reader.atEnd())
        {
            if (reader.isStartElement())
            {
                QString s = reader.name().toString();
                TreeNode * item = new TreeNode;
                item->setText (0, s);
                item->setForeground (0, QColor ("blue"));
                branch->addChild (item);
                branch = item;

                ParamList list;
                // for (QXmlStreamAttribute a : reader.attributes())
                for (auto a : reader.attributes())
                {
                   QString t = a.name().toString();
                   QString v = a.value().toString();
                   /*
                   auto node = new QTreeWidgetItem;
                   node->setText (0, t + " = " + v);
                   node->setForeground (0, QColor ("green"));
                   item->addChild (node);
                   */

                   // list.insert(t, v);
                   list [t] = v;
                }

                if (s == "rectangle")
                   target = createRectangle (item, target, list);
                else if (s == "ellipse")
                   target = createEllipse (item, target, list);
            }
            else if (reader.isCharacters())
            {
                QString s = reader.text().toString().simplified();
                if (s != "")
                {
                   QTreeWidgetItem * item = new QTreeWidgetItem;
                   item->setText (0, s);
                   item->setForeground (0, QColor ("orange"));
                   branch->addChild (item);
                }
            }
            else if (reader.isEndElement())
            {
                branch = branch->parent();

                QString s = reader.name().toString();
                if (s == "rectangle" || s == "ellipse")
                   target = target->parentItem ();
            }
            reader.readNext();
        }
        ui->treeWidget->expandAll();
    }
}

Rectangle * MainWindow::createRectangle
                        (TreeNode * node,
                         QGraphicsItem * target,
                         ParamList list)
{
    Rectangle * shape = new Rectangle;

    shape->params = list;

    node->common = shape;
    node->shape = shape;

    int w = list.number ("w", 100);
    int h = list.number ("h", 40);

    shape->setRect (0, 0, w, h);


    modifyShape (target, shape, list);

    return shape;
}

Ellipse * MainWindow::createEllipse
                      (TreeNode * node,
                       QGraphicsItem * target,
                       ParamList list)
{
    Ellipse * shape = new Ellipse;

    shape->params = list;

    node->common = shape;
    node->shape = shape;

    int w = list.number ("w", 10);
    int h = list.number ("h", 10);

    shape->setRect (0, 0, w, h);


    modifyShape (target, shape, list);

    return shape;
}

void MainWindow::modifyShape (QGraphicsItem * target,
                              QAbstractGraphicsShapeItem * shape,
                              ParamList list)
{
    int x = list.number ("x", 20);
    int y = list.number ("y", 20);
    shape->setPos (x, y);

    QString pen = list ["pen"];
    if (pen != "")
       shape->setPen (QColor (pen));

    QString brush = list ["brush"];
    if (brush != "")
       shape->setBrush (QColor (brush));

    shape->setFlag (QGraphicsItem::ItemIsMovable);
    shape->setFlag (QGraphicsItem::ItemIsSelectable);

    if (target == NULL)
       scene->addItem (shape);
    else
       shape->setParentItem (target);
}


void MainWindow::on_treeWidget_itemClicked(QTreeWidgetItem *item, int column)
{
    TreeNode * node = dynamic_cast <TreeNode*> (item);
    if (node != NULL && node->common != NULL )
    {
        current_element = NULL;

        ui->statusBar->showMessage ("click");

        ui->tableWidget->clear ();
        ui->tableWidget->setColumnCount (2);

        int cnt = 0;
        QMapIterator <QString, QString> iter (node->common->params);
        while (iter.hasNext())
        {
            iter.next();
            QString name = iter.key ();
            QString value = iter.value ();

            ui->tableWidget->setRowCount(cnt+1);

            QTableWidgetItem * field = new QTableWidgetItem;
            field->setText (name);
            ui->tableWidget->setItem (cnt, 0, field);

            field = new QTableWidgetItem;
            field->setText (value);
            ui->tableWidget->setItem (cnt, 1, field);
            if (name == "pen" or name == "brush")
                field->setData(Qt::DecorationRole, QColor (value));
            field->setData(Qt::UserRole, name);

            cnt ++;
        }

        current_element = node->common;
    }
}

int conv (QString s, int default_value)
{
    bool ok;
    int n = s.toInt (&ok);
    if (!ok)
        n = default_value;
    return n;
}

void MainWindow::on_tableWidget_itemChanged(QTableWidgetItem *item)
{
    QString name = item->data (Qt::UserRole).toString ();
    QString value = item->text ();
    if (name != "" && current_element != NULL)
    {
       ui->statusBar->showMessage ("update " + name + " = " + value);

       Common * common = current_element;
       QAbstractGraphicsShapeItem * shape =
               dynamic_cast <QAbstractGraphicsShapeItem *> (common);

       if (name == "pen" && shape != NULL)
           shape->setPen (QColor (value));

       if (name == "brush" && shape != NULL)
           shape->setBrush (QColor (value));

       if (name == "pen" || name == "brush")
           item->setData(Qt::DecorationRole, QColor (value));

       if (name == "x")
           shape->setX (conv (value, 0));

       if (name == "y")
           shape->setY (conv (value, 0));

       if (name == "w" || name == "h")
       {
           Rectangle * r = dynamic_cast <Rectangle*> (shape);
           Ellipse * e = dynamic_cast <Ellipse*> (shape);
           QRectF size;
           if (r != NULL) size = r->rect();
           if (e != NULL) size = e->rect();

           int v = conv (value, 20);
           if (name == "w")
              size.setWidth (v);
           else
              size.setHeight (v);

           if (r != NULL) r->setRect (size);
           if (e != NULL) e->setRect (size);
       }

       common->params[name] = value;
    }
}


</code>