graphicsScene.cc

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
*                                                                            *
\*===========================================================================*/
 
 
 
 
//== INCLUDES =================================================================
#include "graphicsScene.hh"
#include "graphicsView.hh"
#include "sceneElement.hh"
#include "sceneTools.hh"
#include "elementArea.hh"
 
#include "elementInput.hh"
#include "elementOutput.hh"
#include "elementFunction.hh"
#include "connection.hh"
#include "connectionPoint.hh"
#include "wayfind.hh"
 
#include "baseWidget.hh"
 
#include <QApplication>
#include <QPaintEngine>
#include <QMimeData>
 
#include "../parser/context.hh"
#include "../parser/output.hh"
#include "../parser/function.hh"
 
#define SELECTION_RED   0x00
#define SELECTION_GREEN 0x00
#define SELECTION_BLUE  0x7f
#define SELECTION_ALPHA 0x7f
 
//== NAMESPACES ===============================================================
namespace VSI {
 
//=============================================================================
//
//  CLASS VSI::GraphicsScene - IMPLEMENTATION
//
//=============================================================================
 
GraphicsScene::GraphicsScene (Context *_ctx, ElementFunction *_function) :
  QGraphicsScene (),
  ctx_ (_ctx),
  function_ (_function),
  dndElement_ (0),
  elementArea_ (0),
  selectionActive_ (false),
  blockChanges_ (false),
  activeConnection_ (0),
  currentZ_ (0)
{
  // tools area
  tools_ = new SceneTools (this);
  addItem (tools_);
  tools_->setZValue (10);
 
  // selecion item
  selection_ = new QGraphicsRectItem ();
  addItem (selection_);
  selection_->setZValue (1);
  selection_->hide ();
 
  selection_->setBrush(QBrush(QColor(SELECTION_RED,
                                     SELECTION_GREEN,
                                     SELECTION_BLUE,
                                     SELECTION_ALPHA / 2)));
 
  selection_->setPen(QColor(SELECTION_RED,
                            SELECTION_GREEN,
                            SELECTION_BLUE,
                            SELECTION_ALPHA));
 
  elementArea_ = new ElementArea (this);
  addItem (elementArea_);
  elementArea_->setZValue (0.0);
 
  // add start and end
  if (!function_)
  {
    SceneElement *end = new SceneElement (this, ctx_->element ("end"));
    addElement (end);
    SceneElement *start = new SceneElement (this, ctx_->element ("start"));
    addElement (start);
  }
  else
  {
    SceneElement *end = new SceneElement (this, function_->function ()->end ());
    addElement (end);
    SceneElement *start = new SceneElement (this, function_->function ()->start ());
    addElement (start);
  }
 
  // initalize wayfinding
  wayFind_ = new WayFind (this);
 
  view_ = new GraphicsView ();
  view_->setScene (this);
  view_->setRenderHint (QPainter::Antialiasing, true);
 
  if (BaseWidget::getBaseWidget ())
    BaseWidget::getBaseWidget ()->addScene (this);
 
  connect (this, SIGNAL(sceneRectChanged( const QRectF& )), this, SLOT(sceneResized(const QRectF&)));
  dontMoveStart_ = false;
}
 
//------------------------------------------------------------------------------
 
GraphicsScene::~GraphicsScene ()
{
  delete wayFind_;
 
  if (BaseWidget::getBaseWidget ())
    BaseWidget::getBaseWidget ()->removeScene (this);
  view_->deleteLater ();
}
 
//------------------------------------------------------------------------------
 
// draw background
void GraphicsScene::drawBackground(QPainter *_painter, const QRectF &_rect)
{
  QGraphicsScene::drawBackground (_painter, _rect);
}
 
//------------------------------------------------------------------------------
 
// drag enter
void GraphicsScene::dragEnterEvent (QGraphicsSceneDragDropEvent *_event)
{
  // create scene element if mimedata is valid
  if (validMimeData (_event->mimeData ()) && !dndElement_ && ctx_->element (mimeDataElementName (_event->mimeData ())))
  {
    dndElement_ = new SceneElement (this, ctx_->element (mimeDataElementName (_event->mimeData ())));
    dndElement_->setOpacity (0.5);
    addElement (dndElement_);
 
    QPoint off = mimeDataPoint (_event->mimeData ());
 
    QPointF p = elementArea_->mapFromScene (_event->scenePos ().x (), _event->scenePos ().y ());
    dndElement_->setPos (p.x () - (dndElement_->size ().width () / 2) - off.x(),
                         p.y () - (dndElement_->size ().height () / 2) - off.y());
 
  }
  else
    _event->ignore ();
 
}
 
//------------------------------------------------------------------------------
 
// drag leave
void GraphicsScene::dragLeaveEvent (QGraphicsSceneDragDropEvent *_event)
{
  // destroy created scene element
  if (validMimeData (_event->mimeData ()) && dndElement_)
  {
    tools_->mouseRelease (_event->scenePos (), dndElement_);
    removeElement (dndElement_);
    delete dndElement_;
    dndElement_ = NULL;
  }
  else
    _event->ignore ();
}
 
//------------------------------------------------------------------------------
 
// drag move
void GraphicsScene::dragMoveEvent (QGraphicsSceneDragDropEvent *_event)
{
  // update position of dragged element
  if (validMimeData (_event->mimeData ()) && dndElement_)
  {
    QPoint off = mimeDataPoint (_event->mimeData ());
    QPointF p = elementArea_->mapFromScene (_event->scenePos ().x (), _event->scenePos ().y ());
    dndElement_->setPos (p.x () - (dndElement_->size ().width () / 2) - off.x (),
                         p.y () - (dndElement_->size ().height () / 2) - off.y ());
 
    tools_->mouseMove (_event->scenePos ());
  }
  else
    _event->ignore ();
}
 
//------------------------------------------------------------------------------
 
// drop
void GraphicsScene::dropEvent (QGraphicsSceneDragDropEvent *_event)
{
  // leave dropped element in scene
  if (validMimeData (_event->mimeData ()) && dndElement_)
  {
    tools_->mouseRelease (_event->scenePos (), dndElement_);
    dndElement_->setOpacity (1.0);
    dndElement_ = NULL;
    contentChange ();
  }
  else
    _event->ignore ();
}
 
//------------------------------------------------------------------------------
 
qreal GraphicsScene::getNewZ ()
{
  currentZ_ += 0.01;
  return currentZ_;
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::moveElements (qreal _dx, qreal _dy, bool _selected)
{
  elementArea_->moveBy (_dx, _dy);
  if (_selected)
    return;
 
  contentChange ();
  foreach (QGraphicsItem *e, elementArea_->elements ())
    if (e->isSelected ())
    {
      QPointF p = elementArea_->mapFromScene (0, 0) -
                  elementArea_->mapFromScene (_dx, _dy);
      e->moveBy (p.x (), p.y ());
    }
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::scaleElements (qreal _delta)
{
  QRectF rect = sceneRect();
  scaleElements (_delta, QPointF (rect.x () + (rect.width () / 2.0),
                                  rect.y () + (rect.height () / 2.0)));
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::scaleElements (qreal _delta, QPointF _center)
{
  QPointF p(elementArea_->mapFromScene (_center.x (), _center.y ()));
  elementArea_->setTransform(QTransform().translate(p.x (), p.y ()).scale(_delta, _delta).translate(-p.x (), -p.y ()), true);
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::addElement (SceneElement *_element)
{
  contentChange ();
  addItem (_element);
  elementArea_->addElement (_element);
}
 
//------------------------------------------------------------------------------
 
bool GraphicsScene::removeElement (SceneElement *_element)
{
  contentChange ();
  bool rv = elementArea_->removeElement (_element); 
  if (rv)
    removeItem (_element);
 
  return rv;
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::mouseMove (QPointF _pos)
{
  tools_->mouseMove (_pos);
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::mouseRelease (QPointF _pos, QGraphicsItem *_item)
{
  tools_->mouseRelease (_pos, _item);
}
 
//------------------------------------------------------------------------------
 
QRectF GraphicsScene::elementsBoundingRect ()
{
  if (elementArea_)
    return elementArea_->mapToScene (elementArea_->childrenBoundingRect ()).boundingRect ();
  else
    return QRectF ();
}
 
//------------------------------------------------------------------------------
 
const QList<SceneElement *>& GraphicsScene::elements () const
{
  return elementArea_->elements ();
}
 
//------------------------------------------------------------------------------
 
// start selection rectangle if pressing on empty area of scene
void GraphicsScene::mousePressEvent (QGraphicsSceneMouseEvent *_event)
{
  QPainterPath p;
 
  foreach (QGraphicsItem *e, selectedItems ())
    p += e->mapToScene (e->shape ());
 
  QGraphicsScene::mousePressEvent (_event);
  selectionStart_ = _event->scenePos ();
 
  if (itemAt (selectionStart_,QTransform()) != elementArea_ && !_event->isAccepted ())
  {
    if (_event->modifiers () & (Qt::ControlModifier | Qt::ShiftModifier))
      setSelectionArea (p);
 
    selectionActive_ = true;
    selection_->setRect (QRectF (selectionStart_, QSizeF (0, 0)));
    selection_->show ();
    _event->accept ();
  }
 
  dontMoveStart_ = true;
}
 
//------------------------------------------------------------------------------
 
// update selection rectangle
void GraphicsScene::mouseMoveEvent (QGraphicsSceneMouseEvent *_event)
{
  if (selectionActive_)
  {
    selection_->setRect (QRectF (selectionStart_, _event->scenePos ()).normalized ());
    _event->accept ();
  }
  else if (activeConnection_)
  {
    activeConnection_->mouseMoveEvent (_event);
  }
  else
    QGraphicsScene::mouseMoveEvent (_event);
}
 
//------------------------------------------------------------------------------
 
// select all elements in selection rectangle
void GraphicsScene::mouseReleaseEvent (QGraphicsSceneMouseEvent *_event)
{
  if (selectionActive_)
  {
    selection_->hide ();
    QPainterPath p;
 
    p.addRect (QRectF (selectionStart_, _event->scenePos ()).normalized ());
 
    if (_event->modifiers () == Qt::ControlModifier)
    {
      p += selectionArea ();
      setSelectionArea (p);
    }
    else if (_event->modifiers () == Qt::ShiftModifier)
    {
      foreach (QGraphicsItem *e, items (QRectF (selectionStart_, _event->scenePos ()).normalized ()))
        if (e->isSelected ())
          e->setSelected (false);
    }
    else
      setSelectionArea (p);
 
    selectionActive_ = false;
 
    _event->accept ();
  }
  if (activeConnection_)
  {
    activeConnection_->mouseReleaseEvent (_event);
  }
 
  QGraphicsScene::mouseReleaseEvent (_event);
}
 
//------------------------------------------------------------------------------
 
// returns all scene elements. Also all elements of sub-functions
QList<SceneElement *> GraphicsScene::getAllElements()
{
  QList<SceneElement *> rv;
 
  foreach (SceneElement *e, elementArea_->elements ())
  {
    rv.append (e);
    foreach (ElementFunction *ef, e->functions ())
    {
      rv.append (ef->scene ()->getAllElements ());
    }
  }
 
  return rv;
}
 
//------------------------------------------------------------------------------
 
QString GraphicsScene::generateCode (QString &errors, bool _codeOnly)
{
  QString rv = "";
 
  // only code block for functions
  if (!_codeOnly)
  {
    // collect all elements and functions
    QSet<Element *> set;
    QList<ElementFunction *> functions;
 
    foreach (SceneElement *e, getAllElements ())
    {
      set.insert (e->element ());
      foreach (ElementFunction *ef, e->functions ())
        functions.append (ef);
    }
 
    // add precode block for each element only once
    foreach (Element *e, set)
      if (!e->precode ().isEmpty ())
      {
        rv += "# - ";
        rv += e->shortDescription ();
        rv += " -\n";
        rv += e->precode ();
        rv += "\n";
      }
 
    // add functiond
    if (!functions.isEmpty ())
    {
      rv += "# ------- FUNCTIONS -----------\n\n";
    }
 
    foreach (ElementFunction *ef, functions)
    {
      rv += "# - ";
      rv += ef->element ()->element ()->shortDescription ();
      rv += " - ";
      rv += ef->function ()->shortDescription ();
      rv += " -\n";
      rv += "def func_" + ef->element ()->variableId () + "_" + ef->function ()->name ();
 
      QString param;
      foreach (Output *o, ef->function ()->start ()->outputs ())
      {
        param += o->name () + ", ";
      }
 
      if (!param.isEmpty ())
        param.remove (param.length () - 2, 2);
 
      rv += " (" + param + "):\n";
 
      QString code = ef->scene ()->generateCode (errors, true);
 
      // Add identation
      QString ident("  ");
      QStringList lines = code.split("\n");
      for (int l=0;l<lines.length();l++) lines[l] = ident + lines[l];
      code = lines.join("\n");
 
      rv += code + "\n\n";
    }
 
    if (!functions.isEmpty ())
    {
      rv += "# ------- END FUNCTIONS -------\n\n";
    }
  }
 
 
  QList<SceneElement *> elements = elementArea_->elements ();
 
  SceneElement *start = 0;
  SceneElement *end = 0;
 
  // reset code block of all elements and find start element
  foreach (SceneElement *e, elements)
  {
    e->resetCodeGeneration ();
 
    if ((!function_ && e->element ()->name () == "start") ||
        (function_ && function_->function ()->start () == e->element ()))
      start = e;
    if ((!function_ && e->element ()->name () == "end") ||
        (function_ && function_->function ()->end () == e->element ()))
      end = e;
  }
 
  if (!start)
  {
    // should never happen
    errors += "No start element!";
    return "";
  }
 
  elements.removeAll (start);
  elements.removeAll (end);
 
  // Ignore empty scenes
  if (elements.isEmpty() && end->inputs().isEmpty ())
    end = NULL;
 
  rv += "# --- CODE BEGIN ---\n\n";
 
  updateConnections (start, true);
 
  SceneElement *found = (SceneElement*)1;
 
  // iterate over all elements
  while ((!elements.empty () || end) && found)
  {
    found = NULL;
 
    // pick element where all inputs are set
    foreach (SceneElement *e, elements)
    {
      bool set = true;
      foreach (ElementInput *i, e->inputs ())
        if (!i->valid ())
          set = false;
 
      if (e->dataIn () && !e->dataIn ()->valid ())
        set = false;
 
      if (set)
        found = e;
    }
 
    if (!found)
    {
      bool set = true;
      foreach (ElementInput *i, end->inputs ())
        if (!i->valid ())
          set = false;
 
      if (end->dataIn () && !end->dataIn ()->valid ())
        set = false;
 
      // Ignore end elements without inputs
      if (set)
      {
        if (!end->inputs ().isEmpty ())
          found = end;
        end = NULL;
      }
    }
 
    if (found)
    {
      elements.removeAll (found);
 
      rv += "# - ";
      rv += found->element ()->shortDescription ();
      rv += " -\n";
      rv += updateConnections (found, false);
 
      QString dName = "ask_user_output_" + found->variableId();
      QString dInputs = "";
 
      // replace all inputs that are not connected with user defined value or prepare for asking during execution
      foreach (ElementInput *i, found->inputs ()){
        if (i->isSet ())
        {
          found->replaceCodeBlock ("is_set", i->inOut ()->name (), "True");
          found->replaceCodeBlock ("input", i->inOut ()->name (), i->value ());
        }
        else if (!i->connections ().isEmpty ())
        {
          found->replaceCodeBlock ("is_set", i->inOut ()->name (), "rue");
        }
        else if (i->connections ().isEmpty ())
        {
          if (i->state () & Input::Optional && !i->isForceAskSet ())
          {
            found->replaceCodeBlock ("input", i->inOut ()->name (), "\"\"");
            found->replaceCodeBlock ("is_set", i->inOut ()->name (), "False");
          }
          else
          {
            found->replaceCodeBlock ("is_set", i->inOut ()->name (), "True");
            found->replaceCodeBlock ("input", i->inOut ()->name (), dName + "[\"" + i->inOut ()->name ()+"\"]");
            dInputs += i->inOut ()->name () + ",";
          }
        }
 
        // Replace the is_connected block for inputs as well.
        if (i->connections ().isEmpty ())
          found->replaceCodeBlock ("is_connected", i->inOut ()->name (), "False");
        else
          found->replaceCodeBlock ("is_connected", i->inOut ()->name (), "True");
      }
 
      foreach (ElementFunction *ef, found->functions ())
        found->replaceCodeBlock ("function", ef->function ()->name (), "func_" + found->variableId () + "_" + ef->function ()->name ());
 
      if (!dInputs.isEmpty ())
      {
        // remove last ,
        dInputs.remove (dInputs.length () - 1, 1);
        rv += "# Ask user for missing input values\n";
        rv += "" + dName + " = eval(visualscripting.askForInputs (\"" + found->element ()->name ();
        rv += "\", \"" + dInputs + "\"));\n";
      }
 
      rv += found->code ();
      rv += "\n";
    }
  }
 
  rv += "# --- CODE END ---\n";
 
  if (end)
    elements.append (end);
 
  if (!elements.isEmpty ())
  {
    // find all elements that have real missing inputs
    foreach (SceneElement *e, elements)
    {
      foreach (ElementOutput *o, e->outputs ())
      {
        foreach (Connection *c, o->connections ())
          if (c->input ())
          {
            c->input ()->setValid (true);
          }
      }
 
      if (e->dataOut ()) {
        foreach (Connection *c, e->dataOut ()->connections ())
          if (c->input ())
          {
            c->input ()->setValid (true);
            break;
          }
      }
    }
 
    QList<SceneElement *> fixE;
    foreach (SceneElement *e, elements)
    {
      bool set = true;
      foreach (ElementInput *i, e->inputs ())
        if (!i->valid ())
          set = false;
 
      if (e->dataIn () && !e->dataIn ()->valid ())
        set = false;
 
      if (!set)
        fixE.append (e);
    }
 
    errors += "<dl><dt>";
 
    if (!function_)
      errors += "<b>Function: </b>Main";
    else
      errors += "<b>Function: </b>" + function_->function ()->shortDescription();
 
    errors += "</dt><dd>";
 
    foreach (SceneElement *e, fixE)
    {
      errors += "<b>Element: </b>" + e->element ()->shortDescription () + " <i>(";
      foreach (ElementInput *i, e->inputs ())
        if (!i->valid ())
          errors += i->inOut ()->shortDescription () + ", ";
 
      if (e->dataIn () && !e->dataIn ()->valid ())
        errors += e->dataIn ()->inOut ()->shortDescription ();
 
      if (errors.endsWith (", "))
        errors.remove (errors.length () - 2, 2);
      errors += ")</i><br>";
    }
 
    if (errors.endsWith ("<br>"))
        errors.remove (errors.length () - 4, 4);
 
    errors += "<dd></dl>";
 
    return "";
  }
 
  return rv;
}
 
//------------------------------------------------------------------------------
 
// Mark all inputs that are connected to the outputs of _from as valid
QString GraphicsScene::updateConnections (SceneElement *_from, bool _isStart)
{
  QString rv;
  foreach (ElementOutput *o, _from->outputs ())
  {
    QString oName;
 
    if (!_isStart)
    {
      oName = "output_" + _from->variableId() + "_" + o->inOut ()->name ();
      rv += "" + oName + " = None;\n";
 
      _from->replaceCodeBlock ("output", o->inOut ()->name (), oName);
 
      if (o->connections ().isEmpty ())
        _from->replaceCodeBlock ("is_connected", o->inOut ()->name (), "False");
      else
        _from->replaceCodeBlock ("is_connected", o->inOut ()->name (), "True");
    }
    else
      oName = o->inOut ()->name ();
 
    foreach (Connection *c, o->connections ())
      if (c->input ())
      {
        c->input ()->setValid (true);
        c->input ()->element ()->replaceCodeBlock ("input", c->input ()->inOut ()->name (), oName);
      }
  }
 
  if (_from->dataOut ()) {
    foreach (Connection *c, _from->dataOut ()->connections ())
      if (c->input ())
      {
        c->input ()->setValid (true);
        break;
      }
  }
  return rv;
}
 
//------------------------------------------------------------------------------
 
// Checks for supported mimetype
bool GraphicsScene::validMimeData(const QMimeData *_m)
{
  return _m->hasFormat ("application/x-openflipper.vsi");
}
 
//------------------------------------------------------------------------------
 
// gets the element name from the mimetype data
QString GraphicsScene::mimeDataElementName(const QMimeData *_m)
{
  if (!validMimeData (_m))
    return "";
  QStringList sl = QString (_m->data ("application/x-openflipper.vsi")).split (";");
 
  if (sl.length() != 3)
    return "";
 
  return sl[2];
}
 
//------------------------------------------------------------------------------
 
// gets the mouse hotspot from the mimetype data
QPoint GraphicsScene::mimeDataPoint(const QMimeData *_m)
{
  if (! validMimeData (_m))
    return QPoint (0, 0);
 
  QStringList sl = QString (_m->data ("application/x-openflipper.vsi")).split (";");
 
  if (sl.length() != 3)
    return QPoint (0, 0);
 
  bool ok1, ok2;
  int x = sl[0].toInt (&ok1);
  int y = sl[1].toInt (&ok2);
 
  if (!ok1 || !ok2)
    return QPoint (0, 0);
 
  return QPoint (x, y);
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::saveToXml (QDomDocument &_doc, QDomElement &_root)
{
  QTransform t = elementArea_->transform ();
  QDomElement s = _doc.createElement("transform");
  _root.appendChild(s);
  QDomText txt = _doc.createTextNode(
    QString::number (t.m11 ()) + "|" + QString::number (t.m12 ()) + "|" + QString::number (t.m13 ()) + "|" +
    QString::number (t.m21 ()) + "|" + QString::number (t.m22 ()) + "|" + QString::number (t.m23 ()) + "|" +
    QString::number (t.m31 ()) + "|" + QString::number (t.m32 ()) + "|" + QString::number (t.m33 ())
  );
  s.appendChild(txt);
 
  s = _doc.createElement("x");
  _root.appendChild(s);
  txt = _doc.createTextNode (QString::number(elementArea_->pos ().x ()));
  s.appendChild(txt);
 
  s = _doc.createElement("y");
  _root.appendChild(s);
  txt = _doc.createTextNode (QString::number(elementArea_->pos ().y ()));
  s.appendChild(txt);
 
  QDomElement el = _doc.createElement("elements");
  _root.appendChild(el);
 
  foreach (SceneElement *e, elements ())
    e->saveToXml (_doc, el);
}
 
//------------------------------------------------------------------------------
 
void VSI::GraphicsScene::loadFromXml (QDomElement& _domElement)
{
  clearScene (true);
 
  QStringList sl = Context::getXmlString (_domElement, "transform").split ("|");
 
 
 
  if (sl.length () == 9)
  {
 
    qreal m[9];
 
    bool ok;
    for (unsigned int i = 0; i < 9; i++)
    {
      m[i] = sl[i].toDouble (&ok);
      if (!ok)
        break;
    }
    if (ok)
      elementArea_->setTransform (QTransform (m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]), false);
  }
 
  bool ok1, ok2;
  double x, y;
  QString val;
 
  val = Context::getXmlString (_domElement, "x");
  x = val.toDouble (&ok1);
 
  val = Context::getXmlString (_domElement, "y");
  y = val.toDouble (&ok2);
 
  if (ok1 && ok2)
    elementArea_->setPos (x, y);
 
 
  // To make parsing easier, we collect all connections, while we traverse the element.
  std::vector<QString> connections;
 
  // Search through all children of the current element if we have inputs, outputs or functions
  for(QDomElement n = _domElement.firstChildElement(); !n.isNull(); n = n.nextSiblingElement() )
  {
      // Found an input Tag!
      if (n.tagName() == "elements") {
 
          // Iterate over all elements inside it (e.g. this are the algorithm boxes.
          for(QDomElement sceneElement = n.firstChildElement(); !sceneElement.isNull(); sceneElement = sceneElement.nextSiblingElement() )
          {
              loadElement (sceneElement,connections);
          }
      }
  }
 
  for (auto connection : connections) {
      loadConnection(connection);
  }
 
  QTimer::singleShot(0, this, SLOT (updateConnections()));
}
 
//------------------------------------------------------------------------------
 
// load element from xml
void GraphicsScene::loadElement(QDomElement & _domElement,std::vector<QString>& _connections)
{
    QString name = _domElement.attribute("name");
    if (name.isEmpty () || !ctx_->element (name))
        return;
 
 
    SceneElement *e = new SceneElement (this, ctx_->element (name));
    addElement (e);
 
    e->loadFromXml (_domElement,_connections);
}
 
//------------------------------------------------------------------------------
 
// load connection from xml
void GraphicsScene::loadConnection(QString& _connection)
{
    bool ok;
    int inId, outId;
 
    QStringList connectionInfo = _connection.split(";");
 
    if (connectionInfo.size() != 6 ) {
        return;
    }
 
    QString inEl    = connectionInfo[0];
    QString inElId  = connectionInfo[1];
    QString inIn    = connectionInfo[2];
 
    QString outEl   = connectionInfo[3];
    QString outElId = connectionInfo[4];
    QString outOut  = connectionInfo[5];
 
    inId = inElId.toInt (&ok);
    if (!ok)
        return;
 
    outId = outElId.toInt (&ok);
    if (!ok)
        return;
 
    SceneElement *in = NULL, *out = NULL;
 
    foreach (SceneElement *e, elements ())
    {
        if (e->element ()->name () == inEl && e->id () == inId)
            in = e;
        else if (e->element ()->name () == outEl && e->id () == outId)
            out = e;
    }
 
    if (!in || !out)
        return;
 
    ConnectionPoint *p1 = NULL, *p2 = NULL;
 
    if (in->dataIn () && in->dataIn ()->inOut ()->name () == inIn &&
            out->dataOut () && out->dataOut ()->inOut ()->name () == outOut)
    {
        p1 = in->dataIn ()->connectionPointItem ();
        p2 = out->dataOut ()->connectionPointItem ();
    }
    else
    {
        foreach (ElementInput *i, in->inputs())
            if (i->inOut ()->name () == inIn)
            {
                p1 = i->connectionPointItem ();
                break;
            }
 
        foreach (ElementOutput *o, out->outputs())
            if (o->inOut ()->name () == outOut)
            {
                p2 = o->connectionPointItem ();
                break;
            }
    }
 
    if (p1 && p2)
        new Connection (p1, p2, this);
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::clearScene (bool _start)
{
  elementArea_->resetTransform ();
  elementArea_->setPos (0, 0);
  foreach (SceneElement *e, elements())
  {
    bool rv = elementArea_->removeElement (e, true);
    if (rv)
    {
      removeItem (e);
      delete e;
    }
  }
  if (!_start)
  {
  if (!function_)
    {
      SceneElement *start = new SceneElement (this, ctx_->element ("start"));
      addElement (start);
 
      start->setPos(5, (height () - start->size ().height ()) / 2);
 
      SceneElement *end = new SceneElement (this, ctx_->element ("end"));
      addElement (end);
 
      end->setPos(width () - end->size ().width () - 5, (height () - end->size ().height ()) / 2);
    }
    else
    {
      SceneElement *start = new SceneElement (this, function_->function ()->start ());
      addElement (start);
 
      start->setPos(5, (height () - start->size ().height ()) / 2);
 
      SceneElement *end = new SceneElement (this, function_->function ()->end ());
      addElement (end);
 
      end->setPos(width () - end->size ().width () - 5, (height () - end->size ().height ()) / 2);
    }
  }
  dontMoveStart_ = false;
}
 
//------------------------------------------------------------------------------
 
// update all connections in the scene
void GraphicsScene::updateConnections()
{
  foreach (SceneElement *e, elements ())
  {
    foreach (ElementInput *i, e->inputs ())
      foreach (Connection *c, i->connections ())
        c->updatePositions ();
 
    foreach (ElementOutput *o, e->outputs ())
      foreach (Connection *c, o->connections ())
        c->updatePositions ();
 
    if (e->dataIn ()) {
      foreach (Connection *c, e->dataIn ()->connections ())
        c->updatePositions ();
    }
 
    if (e->dataOut ()) {
      foreach (Connection *c, e->dataOut ()->connections ())
        c->updatePositions ();
    }
  }
}
 
//------------------------------------------------------------------------------
 
void GraphicsScene::contentChange ()
{
  if (blockChanges_)
    return;
 
  emit contentChanged ();
  dontMoveStart_ = true;
}
 
//------------------------------------------------------------------------------
 
void VSI::GraphicsScene::sceneResized(const QRectF & /*_rect*/)
{
  if (dontMoveStart_)
    return;
 
  blockChanges_ = true;
 
  QList<SceneElement *> elements = elementArea_->elements ();
 
  SceneElement *start = 0;
  SceneElement *end = 0;
 
  // reset code block of all elements and find start element
  foreach (SceneElement *e, elements)
  {
    e->resetCodeGeneration ();
 
    if ((!function_ && e->element ()->name () == "start") ||
        (function_ && function_->function ()->start () == e->element ()))
      start = e;
    if ((!function_ && e->element ()->name () == "end") ||
        (function_ && function_->function ()->end () == e->element ()))
      end = e;
  }
 
  if (start)
    start->setPos(5, (height () - start->size ().height ()) / 2);
  if (end)
    end->setPos(width () - end->size ().width () - 5, (height () - end->size ().height ()) / 2);
 
  blockChanges_ = false;
}
 
//=============================================================================
}
//=============================================================================