diff --git a/umbrello/umlscene.cpp b/umbrello/umlscene.cpp
index 9152e24d6..3683025f9 100644
--- a/umbrello/umlscene.cpp
+++ b/umbrello/umlscene.cpp
@@ -1,4391 +1,4368 @@
 /***************************************************************************
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   copyright (C) 2002-2014                                               *
  *   Umbrello UML Modeller Authors <umbrello-devel@kde.org>                *
  ***************************************************************************/
 
 // own header
 #include "umlscene.h"
 
 // application specific includes
 #include "activitywidget.h"
 #include "actorwidget.h"
 #include "artifactwidget.h"
 #include "association.h"
 #include "associationwidget.h"
 #include "assocrules.h"
 #include "attribute.h"
 #include "boxwidget.h"
 #include "classifier.h"
 #include "classifierwidget.h"
 #include "classoptionspage.h"
 #include "component.h"
 #include "cmds.h"
 #include "componentwidget.h"
 #include "datatype.h"
 #include "diagram_utils.h"
 #include "pinportbase.h"
 #include "datatypewidget.h"
 #include "debug_utils.h"
 #include "dialog_utils.h"
 #include "docwindow.h"
 #include "entity.h"
 #include "entitywidget.h"
 #include "enumwidget.h"
 #include "floatingtextwidget.h"
 #include "folder.h"
 #include "foreignkeyconstraint.h"
 #include "forkjoinwidget.h"
 #include "idchangelog.h"
 #include "interfacewidget.h"
 #include "import_utils.h"
 #include "layoutgenerator.h"
 #include "layoutgrid.h"
 #include "messagewidget.h"
 #include "model_utils.h"
 #include "notewidget.h"
 #include "object_factory.h"
 #include "objectnodewidget.h"
 #include "objectwidget.h"
 #include "package.h"
 #include "packagewidget.h"
 #include "pinwidget.h"
 #include "portwidget.h"
 #include "seqlinewidget.h"
 #include "signalwidget.h"
 #include "statewidget.h"
 #include "toolbarstate.h"
 #include "toolbarstatefactory.h"
 #include "uml.h"
 #include "umldoc.h"
 #include "umldragdata.h"
 #include "umlfiledialog.h"
 #include "umllistview.h"
 #include "umllistviewitem.h"
 #include "umlobject.h"
 #include "umlobjectlist.h"
 #include "umlrole.h"
 #include "umlscenepopupmenu.h"
 #include "umlview.h"
 #include "umlviewimageexporter.h"
 #include "umlwidget.h"
 #include "uniqueid.h"
 #include "widget_factory.h"
 #include "widget_utils.h"
 #include "widgetlist_utils.h"
 
 //kde include files
 #if QT_VERSION < 0x050000
 #include <kfiledialog.h>
 #include <kio/netaccess.h>
 #endif
 #include <KMessageBox>
 #include <kcursor.h>
 #include <KLocalizedString>
 
 // include files for Qt
 #include <QColor>
 #include <QLineF>
 #include <QPainter>
 #include <QPixmap>
 #include <QPrinter>
 #include <QString>
 #include <QStringList>
 
 // system includes
 #include <cmath>  // for ceil
 
 // static members
 const qreal UMLScene::defaultCanvasSize = 5000;
 bool UMLScene::m_showDocumentationIndicator = false;
 
 using namespace Uml;
 
 DEBUG_REGISTER_DISABLED(UMLScene)
 
 /**
  * The class UMLScenePrivate is intended to hold private
  * members/classes to reduce the size of the public class
  * and to speed up recompiling.
  * The migration to this class is not complete yet.
  */
 class UMLScenePrivate {
 public:
     UMLScenePrivate(UMLScene *parent)
       : p(parent),
         toolBarState(nullptr)
     {
         toolBarStateFactory = new ToolBarStateFactory;
     }
 
     ~UMLScenePrivate()
     {
         delete toolBarState;
         delete toolBarStateFactory;
     }
     /**
      * Check if there is a corresponding port widget
      * for all UMLPort instances and add if not.
      */
     void addMissingPorts()
     {
         UMLWidgetList ports;
         UMLWidgetList components;
 
         foreach(UMLWidget *w, p->widgetList()) {
             if (w->isPortWidget())
                 ports.append(w);
             else if (w->isComponentWidget())
                 components.append(w);
         }
 
         foreach(UMLWidget *cw, components) {
             UMLComponent *c = cw->umlObject()->asUMLComponent();
             if (!c)
                 continue;
             // iterate through related ports for this component widget
             foreach(UMLObject *o, c->containedObjects()) {
                 UMLPort *up = o->asUMLPort();
                 if (!up)
                     continue;
                 Uml::ID::Type id = o->id();
                 bool found = false;
                 foreach(UMLWidget *p, ports) {
                     if (p->id() == id) {
                         found = true;
                         break;
                     }
                 }
                 if (!found)
                     new PortWidget(p, up, cw);
             }
         }
     }
 
     /**
      * Check if port are located equally on the border of a component
      * and fix position if not.
      */
     void fixPortPositions()
     {
         foreach(UMLWidget *w, p->widgetList()) {
             if (w->isPortWidget()) {
                 QGraphicsItem *g = w->parentItem();
                 ComponentWidget *c = dynamic_cast<ComponentWidget*>(g);
                 Q_ASSERT(c);
                 qreal w2 = w->width()/2;
                 qreal h2 = w->height()/2;
                 if (w->x() <= -w2 || w->y() <= -h2
                         || w->x() >= c->width() - w2
                         || w->y() >= c->height() - h2)
                     continue;
                 if (w->x() >= c->width() - 3 * w2) { // right
                     w->setX(c->width() - w2);
                 } else if (w->y() >= c->height() - 3 * h2) { // bottom
                     w->setY(c->height() - h2);
                 } else if (w->x() < 3 * w2) { // left
                     w->setX(-w2);
                 } else if (w->y() < 3 * h2) { // top
                     w->setY(-h2);
                 } else
                     uWarning() << "uncatched widget position of" << w->name();
             }
         }
     }
 
     /**
      * Check if duplicated floating text labels are in the scene and remove them
      */
     void removeDuplicatedFloatingTextInstances()
     {
         UMLWidgetList labelsWithoutParents;
         UMLWidgetList labelsWithParent;
         uDebug() << "checking diagram" << p->name() << "id" << Uml::ID::toString(p->ID());
 
         foreach(UMLWidget *w, p->widgetList()) {
             if (!w->isTextWidget())
                 continue;
             if (w->parentItem())
                 labelsWithParent.append(w);
             else
                 labelsWithoutParents.append(w);
         }
         foreach(UMLWidget *w, labelsWithoutParents) {
             foreach(UMLWidget *wp, labelsWithParent) {
                 if (w->id() == wp->id() &&
                         w->localID() == wp->localID() &&
                         w->name() == wp->name()) {
                     p->removeWidgetCmd(w);
                     uDebug() << "removed duplicated text label" << w->name() << "id:" << Uml::ID::toString(w->id());
                     break;
                 }
             }
         }
     }
 
     void setToolBarChanged(WorkToolBar::ToolBar_Buttons button)
     {
         if (toolBarState)
             toolBarState->cleanBeforeChange();
         toolBarState = toolBarStateFactory->getState(button, p);
         toolBarState->init();
         p->setPaste(false);
     }
 
     void triggerToolBarButton(WorkToolBar::ToolBar_Buttons button)
     {
         UMLApp::app()->workToolBar()->buttonChanged(button);
         setToolBarChanged(button);
         QGraphicsSceneMouseEvent event;
         event.setScenePos(p->pos());
         event.setButton(Qt::LeftButton);
         toolBarState->mousePress(&event);
         toolBarState->mouseRelease(&event);
         p->connect(toolBarState, SIGNAL(finished()), UMLApp::app()->workToolBar(), SLOT(slotResetToolBar()));
     }
 
     UMLScene *p;
     ToolBarStateFactory *toolBarStateFactory;
     ToolBarState *toolBarState;
     QPointer<WidgetBase> widgetLink;
 };
 
 /**
  * Constructor.
  */
 UMLScene::UMLScene(UMLFolder *parentFolder, UMLView *view)
   : QGraphicsScene(0, 0, defaultCanvasSize, defaultCanvasSize),
     m_nLocalID(Uml::ID::None),
     m_nID(Uml::ID::None),
     m_Type(Uml::DiagramType::Undefined),
     m_Name(QString()),
     m_Documentation(QString()),
     m_Options(Settings::optionState()),
     m_bUseSnapToGrid(false),
     m_bUseSnapComponentSizeToGrid(false),
     m_isOpen(true),
     m_nCollaborationId(0),
     m_bCreateObject(false),
     m_bDrawSelectedOnly(false),
     m_bPaste(false),
     m_bStartedCut(false),
     m_d(new UMLScenePrivate(this)),
     m_view(view),
     m_pFolder(parentFolder),
     m_pIDChangesLog(0),
     m_isActivated(false),
     m_bPopupShowing(false),
     m_autoIncrementSequence(false)
 {
     m_PastePoint = QPointF(0, 0);
 
     m_pImageExporter = new UMLViewImageExporter(this);
 
     // setup signals
     connect(UMLApp::app(), SIGNAL(sigCutSuccessful()),
             this, SLOT(slotCutSuccessful()));
     m_d->setToolBarChanged(WorkToolBar::tbb_Arrow);
 
     m_doc = UMLApp::app()->document();
 
 //    // settings for background
 //    setBackgroundBrush(QColor(195, 195, 195));
     m_layoutGrid = new LayoutGrid(this);
 
     // fix crash caused by Qt stale item issue see https://bugs.kde.org/show_bug.cgi?id=383592
     setItemIndexMethod(NoIndex);
 }
 
 /**
  * Destructor.
  */
 UMLScene::~UMLScene()
 {
     delete m_pImageExporter;
     m_pImageExporter = 0;
     delete m_pIDChangesLog;
     m_pIDChangesLog = 0;
 
     // before we can delete the QCanvas, all widgets must be explicitly
     // removed
     // otherwise the implicit remove of the contained widgets will cause
     // events which would demand a valid connected QCanvas
     // ==> this causes umbrello to crash for some - larger?? - projects
     // first avoid all events, which would cause some update actions
     // on deletion of each removed widget
     blockSignals(true);
     removeAllWidgets();
 
     delete m_layoutGrid;
     delete m_d;
 }
 
 /**
  * Return the UMLFolder in which this diagram lives.
  */
 UMLFolder* UMLScene::folder() const
 {
     return m_pFolder;
 }
 
 /**
  * Set the UMLFolder in which this diagram lives.
  */
 void UMLScene::setFolder(UMLFolder *folder)
 {
     m_pFolder = folder;
 }
 
 /**
  * Returns the active view associated with this scene.
  */
 UMLView* UMLScene::activeView() const
 {
     return m_view;
 }
 
 /**
  * Return the documentation of the diagram.
  */
 QString UMLScene::documentation() const
 {
     return m_Documentation;
 }
 
 /**
  * Set the documentation of the diagram.
  */
 void UMLScene::setDocumentation(const QString &doc)
 {
     m_Documentation = doc;
 }
 
 /**
  * Return the state of the auto increment sequence
  */
 bool UMLScene::autoIncrementSequence() const
 {
     return m_autoIncrementSequence;
 }
 
 void UMLScene::setAutoIncrementSequence(bool state)
 {
     m_autoIncrementSequence = state;
 }
 
 /**
  * Return the next auto increment sequence value
  */
 QString UMLScene::autoIncrementSequenceValue()
 {
     int sequenceNumber = 0;
     if (isSequenceDiagram()) {
         foreach (MessageWidget* message, messageList()) {
             bool ok;
             int value = message->sequenceNumber().toInt(&ok);
             if (ok && value > sequenceNumber)
                sequenceNumber = value;
         }
     }
     else if (isCollaborationDiagram()) {
         foreach (AssociationWidget* assoc, associationList()) {
             bool ok;
             int value = assoc->sequenceNumber().toInt(&ok);
             if (ok && value > sequenceNumber)
                sequenceNumber = value;
         }
     }
     return QString::number(sequenceNumber + 1);
 }
 
 /**
  * Return the name of the diagram.
  */
 QString UMLScene::name() const
 {
     return m_Name;
 }
 
 /**
  * Set the name of the diagram.
  */
 void UMLScene::setName(const QString &name)
 {
     m_Name = name;
 }
 
 /**
  * Returns the type of the diagram.
  */
 DiagramType::Enum UMLScene::type() const
 {
     return m_Type;
 }
 
 /**
  * Set the type of diagram.
  */
 void UMLScene::setType(DiagramType::Enum type)
 {
     m_Type = type;
 }
 
 /**
  * Returns the ID of the diagram.
  */
 Uml::ID::Type UMLScene::ID() const
 {
     return m_nID;
 }
 
 /**
  * Sets the ID of the diagram.
  */
 void UMLScene::setID(Uml::ID::Type id)
 {
     m_nID = id;
 }
 
 /**
  * Returns the position of the diagram.
  */
 QPointF UMLScene::pos() const
 {
     return m_pos;
 }
 
 /**
  * Sets the position of the diagram.
  */
 void UMLScene::setPos(const QPointF &pos)
 {
     m_pos = pos;
 }
 
 /**
  * Returns the fill color to use.
  */
 const QColor& UMLScene::fillColor() const
 {
     return m_Options.uiState.fillColor;
 }
 
 /**
  * Set the background color.
  *
  * @param color  The color to use.
  */
 void UMLScene::setFillColor(const QColor &color)
 {
     m_Options.uiState.fillColor = color;
     emit sigFillColorChanged(ID());
 }
 
 /**
  * Returns the line color to use.
  */
 const QColor& UMLScene::lineColor() const
 {
     return m_Options.uiState.lineColor;
 }
 
 /**
  * Sets the line color.
  *
  * @param color  The color to use.
  */
 void UMLScene::setLineColor(const QColor &color)
 {
     m_Options.uiState.lineColor = color;
     emit sigLineColorChanged(ID());
 }
 
 /**
  * Returns the line width to use.
  */
 uint UMLScene::lineWidth() const
 {
     return m_Options.uiState.lineWidth;
 }
 
 /**
  * Sets the line width.
  *
  * @param width  The width to use.
  */
 void UMLScene::setLineWidth(uint width)
 {
     m_Options.uiState.lineWidth = width;
     emit sigLineWidthChanged(ID());
 }
 
 /**
  * Returns the text color to use.
  */
 const QColor& UMLScene::textColor() const
 {
     return m_Options.uiState.textColor;
 }
 
 /**
  * Sets the text color.
  *
  * @param color  The color to use.
  */
 void UMLScene::setTextColor(const QColor& color)
 {
     m_Options.uiState.textColor = color;
     emit sigTextColorChanged(ID());
 }
 
 /**
  * return grid dot color
  *
  * @return Color
  */
 const QColor& UMLScene::gridDotColor() const
 {
     return m_layoutGrid->gridDotColor();
 }
 
 /**
  * set grid dot color
  *
  * @param color grid dot color
  */
 void UMLScene::setGridDotColor(const QColor& color)
 {
     m_Options.uiState.gridDotColor = color;
     m_layoutGrid->setGridDotColor(color);
 }
 
 /**
  * Returns the options being used.
  */
 Settings::OptionState& UMLScene::optionState()
 {
     return m_Options;
 }
 
 /**
  * Sets the options to be used.
  */
 void UMLScene::setOptionState(const Settings::OptionState& options)
 {
     m_Options = options;
     setBackgroundBrush(options.uiState.backgroundColor);
     setGridDotColor(options.uiState.gridDotColor);
 }
 
 /**
  * Returns a reference to the association list.
  */
 const AssociationWidgetList UMLScene::associationList() const
 {
     AssociationWidgetList result;
     foreach(QGraphicsItem *item, items()) {
         AssociationWidget *w = dynamic_cast<AssociationWidget*>(item);
         if (w)
             result.append(w);
     }
     return result;
 }
 
 /**
  * Returns a reference to the widget list.
  */
 const UMLWidgetList UMLScene::widgetList() const
 {
     UMLWidgetList result;
     foreach(QGraphicsItem *item, items()) {
         UMLWidget *w = dynamic_cast<UMLWidget*>(item);
         if (w && !w->isMessageWidget() && !w->isAssociationWidget())
             result.append(w);
     }
     return result;
 }
 
 void UMLScene::addWidgetCmd(UMLWidget* widget)
 {
     Q_ASSERT(0 != widget);
     addItem(widget);
 }
 
 void UMLScene::addWidgetCmd(AssociationWidget* widget)
 {
     Q_ASSERT(0 != widget);
     addItem(widget);
 }
 
 /**
  * Returns a reference to the message list.
  */
 const MessageWidgetList UMLScene::messageList() const
 {
     MessageWidgetList result;
     foreach(QGraphicsItem *item, items()) {
         MessageWidget *w = dynamic_cast<MessageWidget*>(item);
         if (w)
             result.append(w);
     }
     return result;
 }
 
 /**
  * Used for creating unique name of collaboration messages.
  */
 int UMLScene::generateCollaborationId()
 {
     return ++m_nCollaborationId;
 }
 
 /**
  * Returns the open state.
  * @return   when true diagram is shown to the user
  */
 bool UMLScene::isOpen() const
 {
     return m_isOpen;
 }
 
 /**
  * Sets the flag 'isOpen'.
  * @param isOpen   flag indicating that the diagram is shown to the user
  */
 void UMLScene::setIsOpen(bool isOpen)
 {
     m_isOpen = isOpen;
 }
 
 /**
  * Contains the implementation for printing functionality.
  */
 void UMLScene::print(QPrinter *pPrinter, QPainter & pPainter)
 {
     bool isFooter = optionState().generalState.footerPrinting;
 
     // The printer will probably use a different font with different font metrics,
     // force the widgets to update accordingly on paint
     forceUpdateWidgetFontMetrics(&pPainter);
 
     QRectF source = diagramRect();
     QRect paper = pPrinter->paperRect();
     QRect page = pPrinter->pageRect();
 
     // use the painter font metrics, not the screen fm!
     QFontMetrics fm = pPainter.fontMetrics(); 
     int fontHeight  = fm.lineSpacing();
 
     if (paper == page) {
         QSize margin = page.size() * 0.025;
         page.adjust(margin.width(), margin.height(), -margin.width(), -margin.height());
     }
 
     if (isFooter) {
         int margin = 3 + 3 * fontHeight;
         page.adjust(0, 0, 0, -margin);
     }
 
     getDiagram(pPainter, QRectF(source), QRectF(page));
 
     //draw foot note
     if (isFooter) {
         page.adjust(0, 0, 0, fontHeight);
         QString string = i18n("Diagram: %2 Page %1", 1, name());
         QColor textColor(50, 50, 50);
         pPainter.setPen(textColor);
         pPainter.drawLine(page.left(), page.bottom()    , page.right(), page.bottom());
         pPainter.drawText(page.left(), page.bottom() + 3, page.right(), 2*fontHeight, Qt::AlignLeft, string);
     }
 
     // next painting will most probably be to a different device (i.e. the screen)
     forceUpdateWidgetFontMetrics(0);
 }
 
 /**
  * Initialize and announce a newly created widget.
  * Auxiliary to contentsMouseReleaseEvent().
  */
 void UMLScene::setupNewWidget(UMLWidget *w, bool setPosition)
 {
     if (setPosition &&
         (!w->isPinWidget()) &&
         (!w->isPortWidget()) &&
         (!w->isObjectWidget())) {
         // ObjectWidget's position is handled by the widget
         w->setX(m_pos.x());
         w->setY(m_pos.y());
     }
     w->setVisible(true);
     w->activate();
     w->setFontCmd(font());
     w->slotFillColorChanged(ID());
     w->slotTextColorChanged(ID());
     w->slotLineWidthChanged(ID());
     resizeSceneToItems();
     m_doc->setModified();
 
     if (m_doc->loading()) {  // do not emit signals while loading
         addWidgetCmd(w);
         // w->activate();  // will be done by UMLDoc::activateAllViews() after loading
     } else {
         UMLApp::app()->executeCommand(new CmdCreateWidget(w));
     }
 }
 
 /**
  * Return whether we are currently creating an object.
  */
 bool UMLScene::getCreateObject() const
 {
     return m_bCreateObject;
 }
 
 /**
  * Set whether we are currently creating an object.
  */
 void UMLScene::setCreateObject(bool bCreate)
 {
     m_bCreateObject = bCreate;
 }
 
 /**
  * Overrides the standard operation.
  */
 void UMLScene::showEvent(QShowEvent* /*se*/)
 {
     connect(m_doc, SIGNAL(sigObjectCreated(UMLObject*)),
             this, SLOT(slotObjectCreated(UMLObject*)));
     connect(this, SIGNAL(sigAssociationRemoved(AssociationWidget*)),
             UMLApp::app()->docWindow(), SLOT(slotAssociationRemoved(AssociationWidget*)));
     connect(this, SIGNAL(sigWidgetRemoved(UMLWidget*)),
             UMLApp::app()->docWindow(), SLOT(slotWidgetRemoved(UMLWidget*)));
 }
 
 /**
  * Overrides the standard operation.
  */
 void UMLScene::hideEvent(QHideEvent* /*he*/)
 {
     disconnect(m_doc, SIGNAL(sigObjectCreated(UMLObject*)), this, SLOT(slotObjectCreated(UMLObject*)));
     disconnect(this, SIGNAL(sigAssociationRemoved(AssociationWidget*)),
                UMLApp::app()->docWindow(), SLOT(slotAssociationRemoved(AssociationWidget*)));
     disconnect(this, SIGNAL(sigWidgetRemoved(UMLWidget*)),
                UMLApp::app()->docWindow(), SLOT(slotWidgetRemoved(UMLWidget*)));
 }
 
 /**
  * Changes the current tool to the selected tool.
  * The current tool is cleaned and the selected tool initialized.
  */
 void UMLScene::slotToolBarChanged(int c)
 {
     m_d->setToolBarChanged((WorkToolBar::ToolBar_Buttons)c);
 }
 
 /**
  * Slot called when an object is created.
  * @param o   created UML object
  */
 void UMLScene::slotObjectCreated(UMLObject* o)
 {
     DEBUG(DBG_SRC) << "scene=" << name() << " / object=" << o->name();
     m_bPaste = false;
     //check to see if we want the message
     //may be wanted by someone else e.g. list view
 
     if (!m_bCreateObject) {
         return;
     }
 
     UMLWidget* newWidget = Widget_Factory::createWidget(this, o);
 
     if (!newWidget) {
         return;
     }
 
     setupNewWidget(newWidget);
 
     m_bCreateObject = false;
 
     if (Model_Utils::hasAssociations(o->baseType()))
     {
         createAutoAssociations(newWidget);
         // We need to invoke createAutoAttributeAssociations()
         // on all other widgets again because the newly created
         // widget might saturate some latent attribute assocs.
         createAutoAttributeAssociations2(newWidget);
     }
     resizeSceneToItems();
 }
 
 /**
  * Slot called when an object is removed.
  * @param o   removed UML object
  */
 void UMLScene::slotObjectRemoved(UMLObject * o)
 {
     m_bPaste = false;
     Uml::ID::Type id = o->id();
 
     foreach(UMLWidget* obj, widgetList()) {
         if (obj->id() != id)
             continue;
         removeWidget(obj);
         break;
     }
 }
 
 /**
  * Override standard method.
  */
 void UMLScene::dragEnterEvent(QGraphicsSceneDragDropEvent *e)
 {
     UMLDragData::LvTypeAndID_List tidList;
     if (!UMLDragData::getClip3TypeAndID(e->mimeData(), tidList)) {
         DEBUG(DBG_SRC) << "UMLDragData::getClip3TypeAndID returned false";
         return;
     }
     for(UMLDragData::LvTypeAndID_List::const_iterator it = tidList.begin(); it != tidList.end(); it++) {
         UMLListViewItem::ListViewType lvtype = (*it)->type;
         Uml::ID::Type id = (*it)->id;
 
         DiagramType::Enum diagramType = type();
 
         UMLObject* temp = 0;
         //if dragging diagram - might be a drag-to-note
         if (Model_Utils::typeIsDiagram(lvtype)) {
             e->accept();
             continue;
         }
         //can't drag anything onto state/activity diagrams
         if (diagramType == DiagramType::State || diagramType == DiagramType::Activity) {
             e->ignore();
             continue;
         }
         //make sure can find UMLObject
         if (!(temp = m_doc->findObjectById(id))) {
             DEBUG(DBG_SRC) << "object " << Uml::ID::toString(id) << " not found";
             e->ignore();
             continue;
         }
         bool bAccept = Model_Utils::typeIsAllowedInDiagram(temp, this);
         if (bAccept) {
             e->accept();
         } else {
             e->ignore();
         }
     }
 }
 
 /**
  * Override standard method.
  */
 void UMLScene::dragMoveEvent(QGraphicsSceneDragDropEvent* e)
 {
     e->accept();
 }
 
 /**
  * Override standard method.
  */
 void UMLScene::dropEvent(QGraphicsSceneDragDropEvent *e)
 {
     UMLDragData::LvTypeAndID_List tidList;
     if (!UMLDragData::getClip3TypeAndID(e->mimeData(), tidList)) {
         DEBUG(DBG_SRC) << "UMLDragData::getClip3TypeAndID returned error";
         return;
     }
     m_pos = e->scenePos();
 
     for(UMLDragData::LvTypeAndID_List::const_iterator it = tidList.begin(); it != tidList.end(); it++) {
         UMLListViewItem::ListViewType lvtype = (*it)->type;
         Uml::ID::Type id = (*it)->id;
 
         if (Model_Utils::typeIsDiagram(lvtype)) {
             bool breakFlag = false;
             UMLWidget* w = 0;
             foreach(w, widgetList()) {
                 if (w->isNoteWidget() && w->onWidget(e->scenePos())) {
                     breakFlag = true;
                     break;
                 }
             }
             if (breakFlag) {
                 NoteWidget *note = static_cast<NoteWidget*>(w);
                 note->setDiagramLink(id);
             }
             continue;
         }
         UMLObject* o = m_doc->findObjectById(id);
         if (!o) {
             DEBUG(DBG_SRC) << "object id=" << Uml::ID::toString(id) << " not found";
             continue;
         }
 
         UMLWidget* newWidget = Widget_Factory::createWidget(this, o);
         if (!newWidget) {
             uWarning() << "could not create widget for uml object" << o->name();
             continue;
         }
 
         setupNewWidget(newWidget);
         m_pos += QPointF(UMLWidget::DefaultMinimumSize.width(), UMLWidget::DefaultMinimumSize.height());
         createAutoAssociations(newWidget);
         createAutoAttributeAssociations2(newWidget);
     }
 }
 
 /**
  * Overrides the standard operation.
  * Calls the same method in the current tool bar state.
  */
 void UMLScene::mouseMoveEvent(QGraphicsSceneMouseEvent* ome)
 {
     m_d->toolBarState->mouseMove(ome);
 }
 
 /**
  * Override standard method.
  * Calls the same method in the current tool bar state.
  */
 void UMLScene::mousePressEvent(QGraphicsSceneMouseEvent* event)
 {
     if (event->button() != Qt::LeftButton) {
         event->ignore();
         return;
     }
 
     m_d->toolBarState->mousePress(event);
 
-    //TODO should be managed by widgets when are selected. Right now also has some
-    //problems, such as clicking on a widget, and clicking to move that widget shows
-    //documentation of the diagram instead of keeping the widget documentation.
-    //When should diagram documentation be shown? When clicking on an empty
-    //space in the diagram with arrow tool?
-    UMLWidget* widget = widgetAt(event->scenePos());
-    if (widget) {
-        DEBUG(DBG_SRC) << "widget = " << widget->name() << " / type = " << widget->baseTypeStr();
-        UMLApp::app()->docWindow()->showDocumentation(widget);
-        event->accept();
-    }
-    else {
-        AssociationWidget* association = associationAt(event->scenePos());
-        if (association) {
-            DEBUG(DBG_SRC) << "association widget = " << association->name() << " / type = " << association->baseTypeStr();
-            // the following is done in AssociationWidget::setSelected()
-            // UMLApp::app()->docWindow()->showDocumentation(association, true);
-            // event->accept();
-        }
-        //:TODO: else if (clicking on other elements with documentation) {
-        //:TODO: UMLApp::app()->docWindow()->showDocumentation(umlObject, true);
-        else {
-            // clicking on an empty space in the diagram with arrow tool
-            UMLApp::app()->docWindow()->showDocumentation(this);
-            event->accept();
-        }
-    }
+    // setup document
+    if (selectedItems().count() == 0)
+        UMLApp::app()->docWindow()->showDocumentation(this);
+    event->accept();
 }
 
 /**
  * Override standard method.
  * Calls the same method in the current tool bar state.
  */
 void UMLScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
 {
     if (!m_doc->loading())
         m_d->toolBarState->mouseDoubleClick(event);
     if (!event->isAccepted()) {
         // show properties dialog of the scene
         if (m_view->showPropertiesDialog() == true) {
             m_doc->setModified();
         }
         event->accept();
     }
 }
 
 /**
  * Overrides the standard operation.
  * Calls the same method in the current tool bar state.
  */
 void UMLScene::mouseReleaseEvent(QGraphicsSceneMouseEvent* ome)
 {
     m_d->toolBarState->mouseRelease(ome);
 }
 
 /**
  * Determine whether on a sequence diagram we have clicked on a line
  * of an Object.
  *
  * @return The widget owning the line which was clicked.
  *  Returns 0 if no line was clicked on.
  */
 ObjectWidget * UMLScene::onWidgetLine(const QPointF &point) const
 {
     foreach(UMLWidget* obj, widgetList()) {
         ObjectWidget *ow = obj->asObjectWidget();
         if (ow == 0)
             continue;
         SeqLineWidget *pLine = ow->sequentialLine();
         if (pLine == 0) {
             uError() << "SeqLineWidget of " << ow->name()
             << " (id=" << Uml::ID::toString(ow->localID()) << ") is NULL";
             continue;
         }
         if (pLine->onWidget(point))
             return ow;
     }
     return 0;
 }
 
 /**
  * Determine whether on a sequence diagram we have clicked on
  * the destruction box of an Object.
  *
  * @return The widget owning the destruction box which was clicked.
  *  Returns 0 if no destruction box was clicked on.
  */
 ObjectWidget * UMLScene::onWidgetDestructionBox(const QPointF &point) const
 {
     foreach(UMLWidget* obj, widgetList()) {
         ObjectWidget *ow = obj->asObjectWidget();
         if (ow == 0)
             continue;
         SeqLineWidget *pLine = ow->sequentialLine();
         if (pLine == 0) {
             uError() << "SeqLineWidget of " << ow->name()
                      << " (id=" << Uml::ID::toString(ow->localID()) << ") is NULL";
             continue;
         }
         if (pLine->onDestructionBox(point))
             return ow;
     }
     return 0;
 }
 
 /**
  * Return pointer to the first selected widget (for multi-selection)
  */
 UMLWidget* UMLScene::getFirstMultiSelectedWidget() const
 {
     if (selectedWidgets().size() == 0)
         return 0;
     return selectedWidgets().first();
 }
 
 /**
  * Tests the given point against all widgets and returns the
  * widget for which the point is within its bounding rectangle.
  * In case of multiple matches, returns the smallest widget.
  * Returns NULL if the point is not inside any widget.
  * TODO: What about using QGraphicsScene::items(...)?
  */
 UMLWidget* UMLScene::widgetAt(const QPointF& p)
 {
     return dynamic_cast<UMLWidget*>(itemAt(p));
 }
 
 /**
  * Tests the given point against all associations and returns the
  * association widget for which the point is on the line.
  * Returns NULL if the point is not inside any association.
  * CHECK: This is the same method as in ToolBarState.
  */
 AssociationWidget* UMLScene::associationAt(const QPointF& p)
 {
     foreach (AssociationWidget* association, associationList()) {
         if (association->onAssociation(p)) {
             return association;
         }
     }
     return 0;
 }
 
 /**
  * Tests the given point against all associations and returns the
  * association widget for which the point is on the line.
  * Returns NULL if the point is not inside any association.
  */
 MessageWidget* UMLScene::messageAt(const QPointF& p)
 {
     foreach(MessageWidget *message, messageList()) {
         if (message->onWidget(p)) {
             return message;
         }
     }
     return 0;
 }
 
 /**
  * Sees if a message is relevant to the given widget.  If it does delete it.
  * @param w The widget to check messages against.
  */
 void UMLScene::checkMessages(ObjectWidget * w)
 {
     if (type() != DiagramType::Sequence) {
         return;
     }
 
     foreach(MessageWidget *obj, messageList()) {
         if (obj->hasObjectWidget(w)) {
             removeWidgetCmd(obj);
         }
     }
 }
 
 /**
  * Returns whether a widget is already on the diagram.
  *
  * @param id The id of the widget to check for.
  *
  * @return Returns pointer to the widget if it is on the diagram, NULL if not.
  */
 UMLWidget* UMLScene::widgetOnDiagram(Uml::ID::Type id)
 {
     foreach(UMLWidget *obj, widgetList()) {
         if (!obj)
             continue;
         UMLWidget* w = obj->widgetWithID(id);
         if (w)
             return w;
     }
 
     foreach(UMLWidget *obj, messageList()) {
         // CHECK: Should MessageWidget reimplement widgetWithID() ?
         //       If yes then we should use obj->widgetWithID(id) here too.
         if (id == obj->id())
             return obj;
     }
 
     return 0;
 }
 
 /**
  * Returns whether a widget is already on the diagram.
  *
  * @param type The type of the widget to check for.
  *
  * @return Returns pointer to the widget if it is on the diagram, NULL if not.
  */
 UMLWidget* UMLScene::widgetOnDiagram(WidgetBase::WidgetType type)
 {
     foreach(UMLWidget *widget, widgetList()) {
         if (!widget)
             continue;
         if (widget->baseType() == type)
             return widget;
     }
     return nullptr;
 }
 
 /**
  * Finds a widget with the given ID.
  * Search both our UMLWidget AND MessageWidget lists.
  * @param id The ID of the widget to find.
  *
  * @return Returns the widget found, returns 0 if no widget found.
  */
 UMLWidget * UMLScene::findWidget(Uml::ID::Type id)
 {
     foreach(UMLWidget* obj, widgetList()) {
         if (!obj)
             continue;
         UMLWidget* w = obj->widgetWithID(id);
         if (w) {
             return w;
         }
     }
 
     foreach(UMLWidget* obj, messageList()) {
         // CHECK: Should MessageWidget reimplement widgetWithID() ?
         //       If yes then we should use obj->widgetWithID(id) here too.
         if (obj->localID() == id ||
             obj->id() == id)
             return obj;
     }
 
     return 0;
 }
 
 /**
  * Finds an association widget with the given ID.
  *
  * @param id The ID of the widget to find.
  *
  * @return Returns the widget found, returns 0 if no widget found.
  */
 AssociationWidget * UMLScene::findAssocWidget(Uml::ID::Type id)
 {
     foreach(AssociationWidget* obj, associationList()) {
         UMLAssociation* umlassoc = obj->association();
         if (umlassoc && umlassoc->id() == id) {
             return obj;
         }
     }
     return 0;
 }
 
 /**
  * Finds an association widget with the given widgets and the given role B name.
  * Considers the following association types:
  *  at_Association, at_UniAssociation, at_Composition, at_Aggregation
  * This is used for seeking an attribute association.
  *
  * @param pWidgetA  Pointer to the UMLWidget of role A.
  * @param pWidgetB  Pointer to the UMLWidget of role B.
  * @param roleNameB Name at the B side of the association (the attribute name)
  *
  * @return Returns the widget found, returns 0 if no widget found.
  */
 AssociationWidget * UMLScene::findAssocWidget(UMLWidget *pWidgetA,
                                               UMLWidget *pWidgetB, const QString& roleNameB)
 {
     foreach(AssociationWidget* assoc, associationList()) {
         const Uml::AssociationType::Enum testType = assoc->associationType();
         if (testType != Uml::AssociationType::Association &&
                 testType != Uml::AssociationType::UniAssociation &&
                 testType != Uml::AssociationType::Composition &&
                 testType != Uml::AssociationType::Aggregation &&
                 testType != Uml::AssociationType::Relationship) {
             continue;
         }
 
         if (pWidgetA->id() == assoc->widgetIDForRole(Uml::RoleType::A) &&
                 pWidgetB->id() == assoc->widgetIDForRole(Uml::RoleType::B) &&
                 assoc->roleName(Uml::RoleType::B) == roleNameB) {
             return assoc;
         }
     }
     return 0;
 }
 
 /**
  * Finds an association widget with the given type and widgets.
  *
  * @param at  The AssociationType of the widget to find.
  * @param pWidgetA Pointer to the UMLWidget of role A.
  * @param pWidgetB Pointer to the UMLWidget of role B.
  *
  * @return Returns the widget found, returns 0 if no widget found.
  */
 AssociationWidget * UMLScene::findAssocWidget(AssociationType::Enum at,
                                               UMLWidget *pWidgetA, UMLWidget *pWidgetB)
 {
     foreach(AssociationWidget* assoc, associationList()) {
         Uml::AssociationType::Enum testType = assoc->associationType();
         if (testType != at) {
             continue;
         }
 
         if (pWidgetA->id() == assoc->widgetIDForRole(Uml::RoleType::A) &&
                 pWidgetB->id() == assoc->widgetIDForRole(Uml::RoleType::B)) {
             return assoc;
         }
     }
     return 0;
 }
 
 /**
  * Remove a widget from view (undo command)
  *
  * @param o  The widget to remove.
  */
 void UMLScene::removeWidget(UMLWidget * o)
 {
     UMLApp::app()->executeCommand(new CmdRemoveWidget(o));
 }
 
 /**
  * Remove a widget from view (undo command)
  *
  * @param o  The widget to remove.
  */
 void UMLScene::removeWidget(AssociationWidget* w)
 {
     UMLApp::app()->executeCommand(new CmdRemoveWidget(w));
 }
 
 /**
  * Remove a widget from view.
  *
  * @param o  The widget to remove.
  */
 void UMLScene::removeWidgetCmd(UMLWidget * o)
 {
     if (!o)
         return;
 
     emit sigWidgetRemoved(o);
 
     removeAssociations(o);
 
     removeOwnedWidgets(o);
 
     WidgetBase::WidgetType t = o->baseType();
     if (type() == DiagramType::Sequence && t == WidgetBase::wt_Object) {
         checkMessages(static_cast<ObjectWidget*>(o));
     }
 
     o->cleanup();
     o->setSelectedFlag(false);
     disconnect(this, SIGNAL(sigFillColorChanged(Uml::ID::Type)), o, SLOT(slotFillColorChanged(Uml::ID::Type)));
     disconnect(this, SIGNAL(sigLineColorChanged(Uml::ID::Type)), o, SLOT(slotLineColorChanged(Uml::ID::Type)));
     disconnect(this, SIGNAL(sigTextColorChanged(Uml::ID::Type)), o, SLOT(slotTextColorChanged(Uml::ID::Type)));
     removeItem(o);
     o->deleteLater();
     m_doc->setModified(true);
 }
 
 /**
  * Remove all widgets that have given widget as owner.
  *
  * @param o The owner widget that will be removed.
  */
 void UMLScene::removeOwnedWidgets(UMLWidget* o)
 {
     foreach(QGraphicsItem* item, o->childItems()) {
         UMLWidget* widget = dynamic_cast<UMLWidget*>(item);
         if ((widget != 0) &&
             (widget->isPinWidget() ||
              widget->isPortWidget())) {
             removeWidgetCmd(widget);
         }
     }
 }
 
 /**
  * Returns background color
  */
 const QColor& UMLScene::backgroundColor() const
 {
     return backgroundBrush().color();
 }
 
 /**
  * Returns whether to use the fill/background color
  */
 bool UMLScene::useFillColor() const
 {
     return m_Options.uiState.useFillColor;
 }
 
 /**
  * Sets whether to use the fill/background color
  */
 void UMLScene::setUseFillColor(bool ufc)
 {
     m_Options.uiState.useFillColor = ufc;
 }
 
 /**
  * Gets the smallest area to print.
  *
  * @return Returns the smallest area to print.
  */
 QRectF UMLScene::diagramRect()
 {
     return itemsBoundingRect();
 }
 
 /**
  * Returns a list of selected widgets
  * @return list of selected widgets based on class UMLWidget
  * @note This method returns widgets including message widgets, but no association widgets
  */
 UMLWidgetList UMLScene::selectedWidgets() const
 {
     QList<QGraphicsItem *> items = selectedItems();
 
     UMLWidgetList widgets;
     foreach(QGraphicsItem *item, items) {
         UMLWidget *w = dynamic_cast<UMLWidget*>(item);
         if (w)
             widgets.append(w);
     }
     return widgets;
 }
 
 /**
  * Returns a list of selected association widgets
  * @return list of selected widgets based on class AssociationWidget
  */
 AssociationWidgetList UMLScene::selectedAssociationWidgets() const
 {
     QList<QGraphicsItem *> items = selectedItems();
 
     AssociationWidgetList widgets;
     foreach(QGraphicsItem *item, items) {
         AssociationWidget *w = dynamic_cast<AssociationWidget*>(item);
         if (w)
             widgets.append(w);
     }
     return widgets;
 }
 
 /**
  * Returns a list of selected message widgets
  * @return list of selected widgets based on class MessageWidget
  */
 UMLWidgetList UMLScene::selectedMessageWidgets() const
 {
     QList<QGraphicsItem *> items = selectedItems();
 
     UMLWidgetList widgets;
     foreach(QGraphicsItem *item, items) {
         MessageWidget *w = dynamic_cast<MessageWidget*>(item);
         if (w)
             widgets.append(w);
     }
     return widgets;
 }
 
 /**
  *  Clear the selected widgets list.
  */
 void UMLScene::clearSelected()
 {
     clearSelection();
     //m_doc->enableCutCopy(false);
 }
 
 /**
  * Move all the selected widgets by a relative X and Y offset.
  * TODO: Only used in UMLApp::handleCursorKeyReleaseEvent
  *
  * @param dX The distance to move horizontally.
  * @param dY The distance to move vertically.
  */
 void UMLScene::moveSelectedBy(qreal dX, qreal dY)
 {
     // DEBUG(DBG_SRC) << "********** m_selectedList count=" << m_selectedList.count();
     foreach(UMLWidget *w, selectedWidgets()) {
         w->moveByLocal(dX, dY);
     }
 }
 
 /**
  * Set the useFillColor variable to all selected widgets
  *
  * @param useFC The state to set the widget to.
  */
 void UMLScene::selectionUseFillColor(bool useFC)
 {
     if (useFC) {
         UMLApp::app()->beginMacro(i18n("Use fill color"));
     } else {
         UMLApp::app()->beginMacro(i18n("No fill color"));
     }
 
     foreach(UMLWidget* widget, selectedWidgets()) {
         widget->setUseFillColor(useFC);
     }
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * Set the font for all the currently selected items.
  */
 void UMLScene::selectionSetFont(const QFont &font)
 {
     UMLApp::app()->beginMacro(i18n("Change font"));
 
     foreach(UMLWidget* temp, selectedWidgets()) {
         temp->setFont(font);
     }
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * Set the line color for all the currently selected items.
  */
 void UMLScene::selectionSetLineColor(const QColor &color)
 {
     UMLApp::app()->beginMacro(i18n("Change line color"));
 
     foreach(UMLWidget *temp, selectedWidgets()) {
         temp->setLineColor(color);
     }
     AssociationWidgetList assoclist = selectedAssocs();
     foreach(AssociationWidget *aw, assoclist) {
         aw->setLineColor(color);
     }
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * Set the line width for all the currently selected items.
  */
 void UMLScene::selectionSetLineWidth(uint width)
 {
     UMLApp::app()->beginMacro(i18n("Change line width"));
 
     foreach(UMLWidget* temp, selectedWidgets()) {
         temp->setLineWidth(width);
         temp->setUsesDiagramLineWidth(false);
     }
     AssociationWidgetList assoclist = selectedAssocs();
     foreach(AssociationWidget *aw, assoclist) {
         aw->setLineWidth(width);
         aw->setUsesDiagramLineWidth(false);
     }
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * Set the fill color for all the currently selected items.
  */
 void UMLScene::selectionSetFillColor(const QColor &color)
 {
     UMLApp::app()->beginMacro(i18n("Change fill color"));
 
     foreach(UMLWidget* widget, selectedWidgets()) {
         widget->setFillColor(color);
         widget->setUsesDiagramFillColor(false);
     }
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * Set or unset the visual property (show ..) setting of all selected items.
  */
 void UMLScene::selectionSetVisualProperty(ClassifierWidget::VisualProperty property, bool value)
 {
     UMLApp::app()->beginMacro(i18n("Change visual property"));
 
     foreach(UMLWidget *temp, selectedWidgets()) {
         ClassifierWidget *cw = temp->asClassifierWidget();
         cw->setVisualProperty(property, value);
     }
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * Unselect child widgets when their owner is already selected.
  */
 void UMLScene::unselectChildrenOfSelectedWidgets()
 {
     foreach(UMLWidget* widget, selectedWidgets()) {
         if (widget->isPinWidget() ||
             widget->isPortWidget()) {
             foreach(UMLWidget* potentialParentWidget, selectedWidgets()) {
                 if (widget->parentItem() == potentialParentWidget) {
                     widget->setSelectedFlag(false);
                 }
             }
         }
     }
 }
 
 /**
  * Delete the selected widgets list and the widgets in it.
  */
 void UMLScene::deleteSelection()
 {
     AssociationWidgetList selectedAssociations = selectedAssociationWidgets();
     int selectionCount = selectedWidgets().count() + selectedAssociations.count();
 
     if (selectionCount == 0)
         return;
 
     // check related associations
     bool hasAssociations = false;
     foreach(UMLWidget* widget, selectedWidgets()) {
         if (widget->isTextWidget() && widget->asFloatingTextWidget()->textRole() != Uml::TextRole::Floating) {
             continue;
         }
         if (widget->isMessageWidget() || widget->associationWidgetList().size() > 0)
             hasAssociations = true;
     }
 
     if (hasAssociations && !Dialog_Utils::askDeleteAssociation())
         return;
 
     UMLApp::app()->beginMacro(i18n("Delete widgets"));
 
     unselectChildrenOfSelectedWidgets();
 
     foreach(UMLWidget* widget, selectedWidgets()) {
         //  Don't delete text widget that are connect to associations as these will
         //  be cleaned up by the associations.
         if (widget->isTextWidget() &&
                 widget->asFloatingTextWidget()->textRole() != Uml::TextRole::Floating) {
             widget->setSelectedFlag(false);
             widget->hide();
         } else if (widget->isPortWidget()) {
             UMLObject *o = widget->umlObject();
             removeWidget(widget);
             if (o)
                 UMLApp::app()->executeCommand(new CmdRemoveUMLObject(o));
             // message widgets are handled later
         } else if (!widget->isMessageWidget()){
             removeWidget(widget);
         }
     }
 
     // Delete any selected associations.
     foreach(AssociationWidget* assocwidget, selectedAssociations) {
         removeWidget(assocwidget);
     }
 
     // we also have to remove selected messages from sequence diagrams
     foreach(UMLWidget* cur_msgWgt, selectedMessageWidgets()) {
         removeWidget(cur_msgWgt);
     }
 
     //make sure list empty - it should be anyway, just a check.
     clearSelected();
 
     UMLApp::app()->endMacro();
 }
 
 /**
  * resize selected widgets
  */
 void UMLScene::resizeSelection()
 {
     int selectionCount = selectedWidgets().count();
 
     if (selectionCount > 1) {
         UMLApp::app()->beginMacro(i18n("Resize widgets"));
     }
 
     if (selectedCount() == 0)
         return;
     foreach(UMLWidget *w, selectedWidgets()) {
         w->resize();
     }
     m_doc->setModified();
 
     if (selectionCount > 1) {
         UMLApp::app()->endMacro();
     }
 }
 
 /**
  * Selects all widgets
  */
 void UMLScene::selectAll()
 {
     selectWidgets(sceneRect().left(), sceneRect().top(), sceneRect().right(), sceneRect().bottom());
 }
 
 /**
  * Returns true if this diagram resides in an externalized folder.
  * CHECK: It is probably cleaner to move this to the UMLListViewItem.
  */
 bool UMLScene::isSavedInSeparateFile()
 {
     if (optionState().generalState.tabdiagrams) {
         // Umbrello currently does not support external folders
         // when tabbed diagrams are enabled.
         return false;
     }
     const QString msgPrefix(QLatin1String("UMLScene::isSavedInSeparateFile(") + name() + QLatin1String("): "));
     UMLListView *listView = UMLApp::app()->listView();
     UMLListViewItem *lvItem = listView->findItem(m_nID);
     if (lvItem == 0) {
         uError() << msgPrefix
                  << "listView->findUMLObject(this) returns false";
         return false;
     }
     UMLListViewItem *parentItem = dynamic_cast<UMLListViewItem*>(lvItem->parent());
     if (parentItem == 0) {
         uError() << msgPrefix
                  << "parent item in listview is not a UMLListViewItem (?)";
         return false;
     }
     const UMLListViewItem::ListViewType lvt = parentItem->type();
     if (! Model_Utils::typeIsFolder(lvt))
         return false;
     UMLFolder *modelFolder = parentItem->umlObject()->asUMLFolder();
     if (modelFolder == 0) {
         uError() << msgPrefix
                  << "parent model object is not a UMLFolder (?)";
         return false;
     }
     QString folderFile = modelFolder->folderFile();
     return !folderFile.isEmpty();
 }
 
 UMLSceneItemList UMLScene::collisions(const QPointF &p, int delta)
 {
     QPointF a = p-QPointF(delta, delta);
     QPointF b = p+QPointF(delta, delta);
     QList<QGraphicsItem *> list = items(QRectF(a, b));
     return list;
 }
 
 /**
  * Calls setSelected on the given UMLWidget and enters
  * it into the m_selectedList while making sure it is
  * there only once.
  */
 void UMLScene::makeSelected(UMLWidget* uw)
 {
     if (uw) {
         uw->setSelected(true);
     }
 }
 
 /**
  * Selects all the widgets of the given association widget.
  */
 void UMLScene::selectWidgetsOfAssoc(AssociationWidget * a)
 {
     if (a) {
         a->setSelected(true);
         //select the two widgets
         makeSelected(a->widgetForRole(Uml::RoleType::A));
         makeSelected(a->widgetForRole(Uml::RoleType::B));
         //select all the text
         makeSelected(a->multiplicityWidget(Uml::RoleType::A));
         makeSelected(a->multiplicityWidget(Uml::RoleType::B));
         makeSelected(a->roleWidget(Uml::RoleType::A));
         makeSelected(a->roleWidget(Uml::RoleType::B));
         makeSelected(a->changeabilityWidget(Uml::RoleType::A));
         makeSelected(a->changeabilityWidget(Uml::RoleType::B));
     }
 }
 
 /**
  * Selects all the widgets within an internally kept rectangle.
  */
 void UMLScene::selectWidgets(qreal px, qreal py, qreal qx, qreal qy)
 {
     clearSelected();
 
     QRectF  rect;
     if (px <= qx) {
         rect.setLeft(px);
         rect.setRight(qx);
     } else {
         rect.setLeft(qx);
         rect.setRight(px);
     }
     if (py <= qy) {
         rect.setTop(py);
         rect.setBottom(qy);
     } else {
         rect.setTop(qy);
         rect.setBottom(py);
     }
 
     // Select UMLWidgets that fall within the selection rectangle
     foreach(UMLWidget* temp, widgetList()) {
         uIgnoreZeroPointer(temp);
         selectWidget(temp, &rect);
     }
 
     // Select messages that fall within the selection rectangle
     foreach(MessageWidget* temp, messageList()) {
         selectWidget(temp->asUMLWidget(), &rect);
     }
 
     // Select associations of selected widgets
     selectAssociations(true);
 
     // Automatically select all messages if two object widgets are selected
     foreach(MessageWidget *w, messageList()) {
         if (w->objectWidget(Uml::RoleType::A) &&
             w->objectWidget(Uml::RoleType::B) &&
             w->objectWidget(Uml::RoleType::A)->isSelected() &&
             w->objectWidget(Uml::RoleType::B)->isSelected()) {
             makeSelected(w);
         }
     }
 }
 
 /**
  * Select a single widget
  *
  * If QRectF* rect is provided, the selection is only made if the widget is
  * visible within the rectangle.
  */
 void UMLScene::selectWidget(UMLWidget* widget, QRectF* rect)
 {
     if (rect == 0) {
         makeSelected(widget);
         return;
     }
 
     int x = widget->x();
     int y = widget->y();
     int w = widget->width();
     int h = widget->height();
     QRectF  rect2(x, y, w, h);
 
     //see if any part of widget is in the rectangle
     if (!rect->intersects(rect2)) {
         return;
     }
 
     //if it is text that is part of an association then select the association
     //and the objects that are connected to it.
     if (widget->isTextWidget()) {
         FloatingTextWidget *ft = widget->asFloatingTextWidget();
         Uml::TextRole::Enum t = ft->textRole();
         LinkWidget *lw = ft->link();
         MessageWidget * mw = dynamic_cast<MessageWidget*>(lw);
         if (mw) {
             makeSelected(mw);
         } else if (t != Uml::TextRole::Floating) {
             AssociationWidget * a = dynamic_cast<AssociationWidget*>(lw);
             if (a)
                 selectWidgetsOfAssoc(a);
         }
     } else if (widget->isMessageWidget()) {
         MessageWidget *mw = widget->asMessageWidget();
         makeSelected(mw);
     }
     if (widget->isVisible()) {
         makeSelected(widget);
     }
 }
 
 /**
  * Selects all the widgets from a list.
  */
 void UMLScene::selectWidgets(UMLWidgetList &widgets)
 {
     foreach (UMLWidget* widget, widgets)
         makeSelected(widget);
 }
 
 /**
  * Returns the PNG picture of the paste operation.
  * @param diagram the class to store PNG picture of the paste operation.
  * @param rect the area of the diagram to copy
  */
 void  UMLScene::getDiagram(QPixmap &diagram, const QRectF &rect)
 {
     DEBUG(DBG_SRC) << "rect=" << rect << ", pixmap=" << diagram.rect();
     QPainter painter(&diagram);
     painter.fillRect(0, 0, rect.width(), rect.height(), Qt::white);
     getDiagram(painter, rect);
 }
 
 /**
  * Paint diagram to the paint device
  * @param painter the QPainter to which the diagram is painted
  * @param source the area of the diagram to copy
  * @param target the rect where to paint into
  */
 void  UMLScene::getDiagram(QPainter &painter, const QRectF &source, const QRectF &target)
 {
     DEBUG(DBG_SRC) << "painter=" << painter.window() << ", source=" << source << ", target=" << target;
     //TODO unselecting and selecting later doesn't work now as the selection is
     //cleared in UMLSceneImageExporter. Check if the anything else than the
     //following is needed and, if it works, remove the clearSelected in
     //UMLSceneImageExporter and UMLSceneImageExporterModel
 
     UMLWidgetList selected = selectedWidgets();
     foreach(UMLWidget* widget, selected) {
         widget->setSelected(false);
     }
     AssociationWidgetList selectedAssociationsList = selectedAssocs();
 
     foreach(AssociationWidget* association, selectedAssociationsList) {
         association->setSelected(false);
     }
 
     // we don't want to get the grid
     bool showSnapGrid = isSnapGridVisible();
     setSnapGridVisible(false);
 
     const int sourceMargin = 1;
     QRectF alignedSource(source);
     alignedSource.adjust(-sourceMargin, -sourceMargin, sourceMargin, sourceMargin);
 
     uDebug() << "TODO: Check if this render method is identical to cavnas()->drawArea()";
     // [PORT]
     render(&painter, target, alignedSource, Qt::KeepAspectRatio);
 
     setSnapGridVisible(showSnapGrid);
 
     //select again
     foreach(UMLWidget* widget, selected) {
         widget->setSelected(true);
     }
     foreach(AssociationWidget* association, selectedAssociationsList) {
         association->setSelected(true);
     }
 }
 
 /**
  * Returns the imageExporter used to export the view.
  *
  * @return The imageExporter used to export the view.
  */
 UMLViewImageExporter* UMLScene::getImageExporter()
 {
     return m_pImageExporter;
 }
 
 /**
  * makes this view the active view by asking the document to show us
  */
 void UMLScene::slotActivate()
 {
     m_doc->changeCurrentView(ID());
 }
 
 /**
  * Activate all the objects and associations after a load from the clipboard
  */
 void UMLScene::activate()
 {
     //Activate Regular widgets then activate  messages
     foreach(UMLWidget* obj, widgetList()) {
         uIgnoreZeroPointer(obj);
         //If this UMLWidget is already activated or is a MessageWidget then skip it
         if (obj->isActivated() || obj->isMessageWidget()) {
             continue;
         }
 
        if (obj->activate()) {
            obj->setVisible(true);
        } else {
            removeItem(obj);
            delete obj;
        }
     }//end foreach
 
     //Activate Message widgets
     foreach(UMLWidget* obj, messageList()) {
         //If this MessageWidget is already activated then skip it
         if (obj->isActivated())
             continue;
 
         obj->activate(m_doc->changeLog());
         obj->setVisible(true);
 
     }//end foreach
 
     // Activate all association widgets
 
     foreach(AssociationWidget* aw, associationList()) {
         if (aw->activate()) {
             if (m_PastePoint.x() != 0) {
                 int x = m_PastePoint.x() - m_pos.x();
                 int y = m_PastePoint.y() - m_pos.y();
                 aw->moveEntireAssoc(x, y);
             }
         } else {
             removeWidgetCmd(aw);
             delete aw;
         }
     }
 }
 
 /**
  * Return the amount of widgets selected.
  *
  * @param filterText  When true, do NOT count floating text widgets that
  *                    belong to other widgets (i.e. only count TextRole::Floating.)
  *                    Default: Count all widgets.
  * @return  Number of widgets selected.
  */
 int UMLScene::selectedCount(bool filterText) const
 {
     if (!filterText)
         return selectedWidgets().count();
     int counter = 0;
     foreach(UMLWidget* temp, selectedWidgets()) {
         if (temp->isTextWidget()) {
             const FloatingTextWidget *ft = static_cast<const FloatingTextWidget*>(temp);
             if (ft->textRole() == TextRole::Floating)
                 counter++;
         } else {
             counter++;
         }
     }
     return counter;
 }
 
 /**
  * Fills the List with all the selected widgets from the diagram
  * The list can be filled with all the selected widgets, or be filtered to prevent
  * text widgets other than tr_Floating to be append.
  *
  * @param filterText Don't append the text, unless their role is tr_Floating
  * @return           The UMLWidgetList to fill.
  */
 UMLWidgetList UMLScene::selectedWidgetsExt(bool filterText /*= true*/)
 {
     UMLWidgetList widgetList;
 
     foreach(UMLWidget* widgt, selectedWidgets()) {
         if (filterText && widgt->isTextWidget()) {
             FloatingTextWidget *ft = widgt->asFloatingTextWidget();
             if (ft->textRole() == Uml::TextRole::Floating)
                 widgetList.append(widgt);
         } else {
             widgetList.append(widgt);
         }
     }
     return widgetList;
 }
 
 /**
  * Returns a list with all the selected associations from the diagram
  */
 AssociationWidgetList UMLScene::selectedAssocs()
 {
     AssociationWidgetList assocWidgetList;
 
     foreach(AssociationWidget* assocwidget, associationList()) {
         if (assocwidget->isSelected())
             assocWidgetList.append(assocwidget);
     }
     return assocWidgetList;
 }
 
 /**
  * Adds a floating text widget to the view
  */
 void UMLScene::addFloatingTextWidget(FloatingTextWidget* pWidget)
 {
     int wX = pWidget->x();
     int wY = pWidget->y();
     bool xIsOutOfRange = (wX < sceneRect().left() || wX > sceneRect().right());
     bool yIsOutOfRange = (wY < sceneRect().top() || wY > sceneRect().bottom());
     if (xIsOutOfRange || yIsOutOfRange) {
         QString name = pWidget->name();
         if (name.isEmpty()) {
             FloatingTextWidget *ft = pWidget->asFloatingTextWidget();
             if (ft)
                 name = ft->displayText();
         }
         DEBUG(DBG_SRC) << name << " type=" << pWidget->baseTypeStr() << ": position ("
                        << wX << "," << wY << ") is out of range";
         if (xIsOutOfRange) {
             pWidget->setX(0);
             wX = 0;
         }
         if (yIsOutOfRange) {
             pWidget->setY(0);
             wY = 0;
         }
     }
 
     addWidgetCmd(pWidget);
 }
 
 /**
  * Adds an association to the view from the given data.
  * Use this method when pasting.
  */
 bool UMLScene::addAssociation(AssociationWidget* pAssoc, bool isPasteOperation)
 {
     if (!pAssoc) {
         return false;
     }
     const Uml::AssociationType::Enum assocType = pAssoc->associationType();
 
     if (isPasteOperation) {
         IDChangeLog * log = m_doc->changeLog();
 
         if (!log) {
             return false;
         }
 
         Uml::ID::Type ida = Uml::ID::None, idb = Uml::ID::None;
         if (type() == DiagramType::Collaboration || type() == DiagramType::Sequence) {
             //check local log first
             ida = m_pIDChangesLog->findNewID(pAssoc->widgetIDForRole(Uml::RoleType::A));
             idb = m_pIDChangesLog->findNewID(pAssoc->widgetIDForRole(Uml::RoleType::B));
             //if either is still not found and assoc type is anchor
             //we are probably linking to a notewidet - else an error
             if (ida == Uml::ID::None && assocType == Uml::AssociationType::Anchor)
                 ida = log->findNewID(pAssoc->widgetIDForRole(Uml::RoleType::A));
             if (idb == Uml::ID::None && assocType == Uml::AssociationType::Anchor)
                 idb = log->findNewID(pAssoc->widgetIDForRole(Uml::RoleType::B));
         } else {
             Uml::ID::Type oldIdA = pAssoc->widgetIDForRole(Uml::RoleType::A);
             Uml::ID::Type oldIdB = pAssoc->widgetIDForRole(Uml::RoleType::B);
             ida = log->findNewID(oldIdA);
             if (ida == Uml::ID::None) {  // happens after a cut
                 if (oldIdA == Uml::ID::None) {
                     return false;
                 }
                 ida = oldIdA;
             }
             idb = log->findNewID(oldIdB);
             if (idb == Uml::ID::None) {  // happens after a cut
                 if (oldIdB == Uml::ID::None) {
                     return false;
                 }
                 idb = oldIdB;
             }
         }
         if (ida == Uml::ID::None || idb == Uml::ID::None) {
             return false;
         }
         // cant do this anymore.. may cause problem for pasting
         //      pAssoc->setWidgetID(ida, A);
         //      pAssoc->setWidgetID(idb, B);
         pAssoc->setWidgetForRole(findWidget(ida), Uml::RoleType::A);
         pAssoc->setWidgetForRole(findWidget(idb), Uml::RoleType::B);
     }
 
     UMLWidget * pWidgetA = findWidget(pAssoc->widgetIDForRole(Uml::RoleType::A));
     UMLWidget * pWidgetB = findWidget(pAssoc->widgetIDForRole(Uml::RoleType::B));
     //make sure valid widget ids
     if (!pWidgetA || !pWidgetB) {
         return false;
     }
 
     //make sure there isn't already the same assoc
 
     foreach(AssociationWidget* assocwidget, associationList()) {
         if (*pAssoc == *assocwidget)
             // this is nuts. Paste operation wants to know if 'true'
             // for duplicate, but loadFromXMI1 needs 'false' value
             return (isPasteOperation ? true : false);
     }
 
     addWidgetCmd(pAssoc);
 
     FloatingTextWidget *ft[5] = { pAssoc->nameWidget(),
                                   pAssoc->roleWidget(Uml::RoleType::A),
                                   pAssoc->roleWidget(Uml::RoleType::B),
                                   pAssoc->multiplicityWidget(Uml::RoleType::A),
                                   pAssoc->multiplicityWidget(Uml::RoleType::B)
     };
     for (int i = 0; i < 5; i++) {
         FloatingTextWidget *flotxt = ft[i];
         if (flotxt) {
             flotxt->updateGeometry();
             addFloatingTextWidget(flotxt);
         }
     }
 
     return true;
 }
 
 /**
  * Activate the view after a load a new file
  */
 void UMLScene::activateAfterLoad(bool bUseLog)
 {
     if (m_isActivated) {
         return;
     }
     if (bUseLog) {
         beginPartialWidgetPaste();
     }
 
     //now activate them all
     activate();
 
     if (bUseLog) {
         endPartialWidgetPaste();
     }
     m_view->centerOn(0, 0);
     m_isActivated = true;
 }
 
 void UMLScene::beginPartialWidgetPaste()
 {
     delete m_pIDChangesLog;
     m_pIDChangesLog = 0;
 
     m_pIDChangesLog = new IDChangeLog();
     m_bPaste = true;
 }
 
 void UMLScene::endPartialWidgetPaste()
 {
     delete m_pIDChangesLog;
     m_pIDChangesLog = 0;
 
     m_bPaste = false;
 }
 
 /**
  * Removes a AssociationWidget from a diagram
  * Physically deletes the AssociationWidget passed in.
  *
  * @param pAssoc  Pointer to the AssociationWidget.
  */
 void UMLScene::removeWidgetCmd(AssociationWidget* pAssoc)
 {
     if (!pAssoc)
         return;
 
     emit sigAssociationRemoved(pAssoc);
 
     pAssoc->cleanup();
     removeItem(pAssoc);
     pAssoc->deleteLater();
     m_doc->setModified();
 }
 
 /**
  * Removes an AssociationWidget from the association list
  * and removes the corresponding UMLAssociation from the current UMLDoc.
  */
 void UMLScene::removeAssocInViewAndDoc(AssociationWidget* a)
 {
     // For umbrello 1.2, UMLAssociations can only be removed in two ways:
     // 1. Right click on the assocwidget in the view and select Delete
     // 2. Go to the Class Properties page, select Associations, right click
     //    on the association and select Delete
     if (!a)
         return;
     if (a->associationType() == Uml::AssociationType::Containment) {
         UMLObject *objToBeMoved = a->widgetForRole(Uml::RoleType::B)->umlObject();
         if (objToBeMoved != 0) {
             UMLListView *lv = UMLApp::app()->listView();
             lv->moveObject(objToBeMoved->id(),
                            Model_Utils::convert_OT_LVT(objToBeMoved),
                            lv->theLogicalView());
             // UMLListView::moveObject() will delete the containment
             // AssociationWidget via UMLScene::updateContainment().
         } else {
             DEBUG(DBG_SRC) << "removeAssocInViewAndDoc(containment): "
                            << "objB is NULL";
         }
     } else {
         // Remove assoc in doc.
         m_doc->removeAssociation(a->association());
         // Remove assoc in view.
         removeWidgetCmd(a);
     }
 }
 
 /**
  * Removes all the associations related to Widget.
  *
  * @param widget  Pointer to the widget to remove.
  */
 void UMLScene::removeAssociations(UMLWidget* widget)
 {
     foreach(AssociationWidget* assocwidget, associationList()) {
         if (assocwidget->containsAsEndpoint(widget)) {
             removeWidgetCmd(assocwidget);
         }
     }
 }
 
 /**
  * Sets each association as selected if the widgets it associates are selected
  *
  * @param bSelect  True to select, false for unselect
  */
 void UMLScene::selectAssociations(bool bSelect)
 {
     foreach(AssociationWidget* assocwidget, associationList()) {
         UMLWidget *widA = assocwidget->widgetForRole(Uml::RoleType::A);
         UMLWidget *widB = assocwidget->widgetForRole(Uml::RoleType::B);
         if (bSelect &&
                 widA && widA->isSelected() &&
                 widB && widB->isSelected()) {
             assocwidget->setSelected(true);
         } else {
             assocwidget->setSelected(false);
         }
     }
 }
 
 /**
  * Fills Associations with all the associations that includes a widget related to object
  */
 void UMLScene::getWidgetAssocs(UMLObject* Obj, AssociationWidgetList & Associations)
 {
     if (! Obj)
         return;
 
     foreach(AssociationWidget* assocwidget, associationList()) {
         if (assocwidget->widgetForRole(Uml::RoleType::A)->umlObject() == Obj ||
             assocwidget->widgetForRole(Uml::RoleType::B)->umlObject() == Obj)
             Associations.append(assocwidget);
     }
 
 }
 
 /**
  * Removes All the associations of the diagram
  */
 void UMLScene::removeAllAssociations()
 {
     //Remove All association widgets
     foreach(AssociationWidget* assocwidget, associationList()) {
         removeWidgetCmd(assocwidget);
     }
 }
 
 /**
  * Removes All the widgets of the diagram
  */
 void UMLScene::removeAllWidgets()
 {
     // Remove widgets.
     foreach(UMLWidget* temp, widgetList()) {
         uIgnoreZeroPointer(temp);
         // I had to take this condition back in, else umbrello
         // crashes on exit. Still to be analyzed.  --okellogg
         if (!(temp->isTextWidget() &&
               temp->asFloatingTextWidget()->textRole() != TextRole::Floating)) {
             removeWidgetCmd(temp);
         }
     }
 }
 
 /**
  * Refreshes containment association, i.e. removes possible old
  * containment and adds new containment association if applicable.
  *
  * @param self  Pointer to the contained object for which
  *   the association to the containing object is
  *   recomputed.
  */
 void UMLScene::updateContainment(UMLCanvasObject *self)
 {
     if (self == 0)
         return;
     // See if the object has a widget representation in this view.
     // While we're at it, also see if the new parent has a widget here.
     UMLWidget *selfWidget = 0, *newParentWidget = 0;
     UMLPackage *newParent = self->umlPackage();
     foreach(UMLWidget* w, widgetList()) {
         UMLObject *o = w->umlObject();
         if (o == self)
             selfWidget = w;
         else if (newParent != 0 && o == newParent)
             newParentWidget = w;
     }
     if (selfWidget == 0)
         return;
     // Remove possibly obsoleted containment association.
     foreach(AssociationWidget* a, associationList()) {
         if (a->associationType() != Uml::AssociationType::Containment)
             continue;
         // Container is at role A, containee at B.
         // We only look at association for which we are B.
         UMLWidget *wB = a->widgetForRole(Uml::RoleType::B);
         UMLObject *roleBObj = wB->umlObject();
         if (roleBObj != self)
             continue;
         UMLWidget *wA = a->widgetForRole(Uml::RoleType::A);
         UMLObject *roleAObj = wA->umlObject();
         if (roleAObj == newParent) {
             // Wow, all done. Great!
             return;
         }
         removeWidgetCmd(a);
         // It's okay to break out because there can only be a single
         // containing object.
         break;
     }
     if (newParentWidget == 0)
         return;
     // Create the new containment association.
     AssociationWidget *a = AssociationWidget::create
                              (this, newParentWidget,
                               Uml::AssociationType::Containment, selfWidget);
     addWidgetCmd(a);
 }
 
 /**
  * Creates automatically any Associations that the given @ref UMLWidget
  * may have on any diagram.  This method is used when you just add the UMLWidget
  * to a diagram.
  */
 void UMLScene::createAutoAssociations(UMLWidget * widget)
 {
     if (widget == 0 ||
         (m_Type != Uml::DiagramType::Class &&
          m_Type != Uml::DiagramType::Object &&
          m_Type != Uml::DiagramType::Component &&
          m_Type != Uml::DiagramType::Deployment
          && m_Type != Uml::DiagramType::EntityRelationship))
         return;
     // Recipe:
     // If this widget has an underlying UMLCanvasObject then
     //   for each of the UMLCanvasObject's UMLAssociations
     //     if umlassoc's "other" role has a widget representation on this view then
     //       if the AssocWidget does not already exist then
     //         if the assoc type is permitted in the current diagram type then
     //           create the AssocWidget
     //         end if
     //       end if
     //     end if
     //   end loop
     //   Do createAutoAttributeAssociations()
     //   if this object is capable of containing nested objects then
     //     for each of the object's containedObjects
     //       if the containedObject has a widget representation on this view then
     //         if the containedWidget is not physically located inside this widget
     //           create the containment AssocWidget
     //         end if
     //       end if
     //     end loop
     //   end if
     //   if the UMLCanvasObject has a parentPackage then
     //     if the parentPackage has a widget representation on this view then
     //       create the containment AssocWidget
     //     end if
     //   end if
     // end if
     UMLObject *tmpUmlObj = widget->umlObject();
     if (tmpUmlObj == 0)
         return;
     UMLCanvasObject *umlObj = tmpUmlObj->asUMLCanvasObject();
     if (umlObj == 0)
         return;
     const UMLAssociationList& umlAssocs = umlObj->getAssociations();
 
     Uml::ID::Type myID = umlObj->id();
     foreach(UMLAssociation* assoc, umlAssocs) {
         UMLCanvasObject *other = 0;
         UMLObject *roleAObj = assoc->getObject(Uml::RoleType::A);
         if (roleAObj == 0) {
             DEBUG(DBG_SRC) << "roleA object is NULL at UMLAssoc "
                            << Uml::ID::toString(assoc->id());
             continue;
         }
         UMLObject *roleBObj = assoc->getObject(Uml::RoleType::B);
         if (roleBObj == 0) {
             DEBUG(DBG_SRC) << "roleB object is NULL at UMLAssoc "
                            << Uml::ID::toString(assoc->id());
             continue;
         }
         if (roleAObj->id() == myID) {
             other = roleBObj->asUMLCanvasObject();
         } else if (roleBObj->id() == myID) {
             other = roleAObj->asUMLCanvasObject();
         } else {
             DEBUG(DBG_SRC) << "Cannot find own object "
                            << Uml::ID::toString(myID) << " in UMLAssoc "
                            << Uml::ID::toString(assoc->id());
             continue;
         }
         // Now that we have determined the "other" UMLObject, seek it in
         // this view's UMLWidgets.
         if (!other) {
             continue;
         }
         Uml::ID::Type otherID = other->id();
 
         bool breakFlag = false;
         UMLWidget* pOtherWidget = 0;
         foreach(pOtherWidget, widgetList()) {
             if (pOtherWidget->id() == otherID) {
                 breakFlag = true;
                 break;
             }
         }
         if (!breakFlag)
             continue;
         // Both objects are represented in this view:
         // Assign widget roles as indicated by the UMLAssociation.
         UMLWidget *widgetA, *widgetB;
         if (myID == roleAObj->id()) {
             widgetA = widget;
             widgetB = pOtherWidget;
         } else {
             widgetA = pOtherWidget;
             widgetB = widget;
         }
         // Check that the assocwidget does not already exist.
         Uml::AssociationType::Enum assocType = assoc->getAssocType();
         AssociationWidget * assocwidget = findAssocWidget(assocType, widgetA, widgetB);
         if (assocwidget) {
             assocwidget->calculateEndingPoints();  // recompute assoc lines
             continue;
         }
         // Check that the assoc is allowed.
         if (!AssocRules::allowAssociation(assocType, widgetA, widgetB)) {
             DEBUG(DBG_SRC) << "not transferring assoc "
                            << "of type " << assocType;
             continue;
         }
 
         // Create the AssociationWidget.
         assocwidget = AssociationWidget::create(this);
         assocwidget->setWidgetForRole(widgetA, Uml::RoleType::A);
         assocwidget->setWidgetForRole(widgetB, Uml::RoleType::B);
         assocwidget->setAssociationType(assocType);
         assocwidget->setUMLObject(assoc);
         // Call calculateEndingPoints() before setting the FloatingTexts
         // because their positions are computed according to the
         // assocwidget line positions.
         assocwidget->calculateEndingPoints();
         assocwidget->syncToModel();
         assocwidget->setActivated(true);
         if (! addAssociation(assocwidget))
             delete assocwidget;
     }
 
     createAutoAttributeAssociations(widget);
 
     if (m_Type == Uml::DiagramType::EntityRelationship) {
         createAutoConstraintAssociations(widget);
     }
 
     // if this object is capable of containing nested objects then
     UMLObject::ObjectType t = umlObj->baseType();
     if (t == UMLObject::ot_Package || t == UMLObject::ot_Class ||
         t == UMLObject::ot_Interface || t == UMLObject::ot_Component) {
         // for each of the object's containedObjects
         UMLPackage *umlPkg = umlObj->asUMLPackage();
         UMLObjectList lst = umlPkg->containedObjects();
         foreach(UMLObject* obj,  lst) {
             uIgnoreZeroPointer(obj);
             // if the containedObject has a widget representation on this view then
             Uml::ID::Type id = obj->id();
             foreach(UMLWidget *w, widgetList()) {
                 uIgnoreZeroPointer(w);
                 if (w->id() != id)
                     continue;
                 // if the containedWidget is not physically located inside this widget
                 if (widget->rect().contains(w->rect()))
                     continue;
                 // create the containment AssocWidget
                 AssociationWidget *a = AssociationWidget::create(this, widget,
                         Uml::AssociationType::Containment, w);
                 a->calculateEndingPoints();
                 a->setActivated(true);
                 if (! addAssociation(a))
                     delete a;
             }
         }
     }
     // if the UMLCanvasObject has a parentPackage then
     UMLPackage *parent = umlObj->umlPackage();
     if (parent == 0)
         return;
     // if the parentPackage has a widget representation on this view then
     Uml::ID::Type pkgID = parent->id();
 
     bool breakFlag = false;
     UMLWidget* pWidget = 0;
     foreach(pWidget, widgetList()) {
         uIgnoreZeroPointer(pWidget);
         if (pWidget->id() == pkgID) {
             breakFlag = true;
             break;
         }
     }
     if (!breakFlag || pWidget->rect().contains(widget->rect()))
         return;
     // create the containment AssocWidget
     AssociationWidget *a = AssociationWidget::create(this, pWidget, Uml::AssociationType::Containment, widget);
     if (! addAssociation(a))
         delete a;
 }
 
 /**
  * If the m_Type of the given widget is WidgetBase::wt_Class then
  * iterate through the class' attributes and create an
  * association to each attribute type widget that is present
  * on the current diagram.
  */
 void UMLScene::createAutoAttributeAssociations(UMLWidget *widget)
 {
     if (widget == 0 || m_Type != Uml::DiagramType::Class || !m_Options.classState.showAttribAssocs)
         return;
 
     // Pseudocode:
     //   if the underlying model object is really a UMLClassifier then
     //     for each of the UMLClassifier's UMLAttributes
     //       if the attribute type has a widget representation on this view then
     //         if the AssocWidget does not already exist then
     //           if the current diagram type permits compositions then
     //             create a composition AssocWidget
     //           end if
     //         end if
     //       end if
     //       if the attribute type is a Datatype then
     //         if the Datatype is a reference (pointer) type then
     //           if the referenced type has a widget representation on this view then
     //             if the AssocWidget does not already exist then
     //               if the current diagram type permits aggregations then
     //                 create an aggregation AssocWidget from the ClassifierWidget to the
     //                                                 widget of the referenced type
     //               end if
     //             end if
     //           end if
     //         end if
     //       end if
     //     end loop
     //   end if
     //
     // Implementation:
     UMLObject *tmpUmlObj = widget->umlObject();
     if (tmpUmlObj == 0)
         return;
     // if the underlying model object is really a UMLClassifier then
     if (tmpUmlObj->isUMLDatatype()) {
         UMLDatatype *dt = tmpUmlObj->asUMLDatatype();
         while (dt && dt->originType() != 0) {
             tmpUmlObj = dt->originType();
             if (!tmpUmlObj->isUMLDatatype())
                 break;
             dt = tmpUmlObj->asUMLDatatype();
         }
     }
     if (tmpUmlObj->baseType() != UMLObject::ot_Class)
         return;
     UMLClassifier * klass = tmpUmlObj->asUMLClassifier();
     // for each of the UMLClassifier's UMLAttributes
     UMLAttributeList attrList = klass->getAttributeList();
     foreach(UMLAttribute* attr, attrList) {
         createAutoAttributeAssociation(attr->getType(), attr, widget);
         /*
          * The following code from attachment 19935 of http://bugs.kde.org/140669
          * creates Aggregation/Composition to the template parameters.
          * The current solution uses Dependency instead, see handling of template
          * instantiation at Import_Utils::createUMLObject().
         UMLClassifierList templateList = attr->getTemplateParams();
         for (UMLClassifierListIt it(templateList); it.current(); ++it) {
             createAutoAttributeAssociation(it, attr, widget);
         }
          */
     }
 }
 
 /**
  * Create an association with the attribute attr associated with the UMLWidget
  * widget if the UMLClassifier type is present on the current diagram.
  */
 void UMLScene::createAutoAttributeAssociation(UMLClassifier *type, UMLAttribute *attr,
                                               UMLWidget *widget /*, UMLClassifier * klass*/)
 {
     if (type == 0) {
         // DEBUG(DBG_SRC) << klass->getName() << ": type is NULL for "
         //                << "attribute " << attr->getName();
         return;
     }
     Uml::AssociationType::Enum assocType = Uml::AssociationType::Composition;
     UMLWidget *w = findWidget(type->id());
     // if the attribute type has a widget representation on this view
     if (w) {
         AssociationWidget *a = findAssocWidget(widget, w, attr->name());
         if (a == 0 &&
             // if the current diagram type permits compositions
             AssocRules::allowAssociation(assocType, widget, w)) {
             // Create a composition AssocWidget, or, if the attribute type is
             // stereotyped <<CORBAInterface>>, create a UniAssociation widget.
             if (type->stereotype() == QLatin1String("CORBAInterface"))
                 assocType = Uml::AssociationType::UniAssociation;
             a = AssociationWidget::create(this, widget, assocType, w, attr);
             a->setVisibility(attr->visibility(), Uml::RoleType::B);
             /*
             if (assocType == Uml::AssociationType::Aggregation || assocType == Uml::AssociationType::UniAssociation)
             a->setMulti("0..1", Uml::RoleType::B);
             */
             a->setRoleName(attr->name(), Uml::RoleType::B);
             a->setActivated(true);
             if (! addAssociation(a))
                 delete a;
         }
     }
     // if the attribute type is a Datatype then
     if (type->isUMLDatatype()) {
         UMLDatatype *dt = type->asUMLDatatype();
         // if the Datatype is a reference (pointer) type
         if (dt && dt->isReference()) {
             //Uml::AssociationType::Enum assocType = Uml::AssociationType::Composition;
             UMLClassifier *c = dt->originType();
             UMLWidget *w = c ? findWidget(c->id()) : 0;
             // if the referenced type has a widget representation on this view
             if (w) {
                 AssociationWidget *a = findAssocWidget(widget, w, attr->name());
                 if (a == 0 &&
                         // if the current diagram type permits aggregations
                         AssocRules::allowAssociation(Uml::AssociationType::Aggregation, widget, w)) {
                     // create an aggregation AssocWidget from the ClassifierWidget
                     // to the widget of the referenced type
                     a = AssociationWidget::create (this, widget,
                                                    Uml::AssociationType::Aggregation, w, attr);
                     a->setVisibility(attr->visibility(), Uml::RoleType::B);
                     //a->setChangeability(true, Uml::RoleType::B);
                     a->setMultiplicity(QLatin1String("0..1"), Uml::RoleType::B);
                     a->setRoleName(attr->name(), Uml::RoleType::B);
                     a->setActivated(true);
                     if (! addAssociation(a))
                         delete a;
                 }
             }
         }
     }
 }
 
 void UMLScene::createAutoConstraintAssociations(UMLWidget *widget)
 {
     if (widget == 0 || m_Type != Uml::DiagramType::EntityRelationship)
         return;
 
     // Pseudocode:
     //   if the underlying model object is really a UMLEntity then
     //     for each of the UMLEntity's UMLForeignKeyConstraint's
     //       if the attribute type has a widget representation on this view then
     //         if the AssocWidget does not already exist then
     //           if the current diagram type permits relationships then
     //             create a relationship AssocWidget
     //           end if
     //         end if
     //       end if
 
     UMLObject *tmpUmlObj = widget->umlObject();
     if (tmpUmlObj == 0)
         return;
     // check if the underlying model object is really a UMLEntity
     UMLCanvasObject *umlObj = tmpUmlObj->asUMLCanvasObject();
     if (umlObj == 0)
         return;
     // finished checking whether this widget has a UMLCanvas Object
 
     if (tmpUmlObj->baseType() != UMLObject::ot_Entity)
         return;
     UMLEntity *entity = tmpUmlObj->asUMLEntity();
 
     // for each of the UMLEntity's UMLForeignKeyConstraints
     UMLClassifierListItemList constrList = entity->getFilteredList(UMLObject::ot_ForeignKeyConstraint);
 
     foreach(UMLClassifierListItem* cli, constrList) {
         UMLEntityConstraint *eConstr = cli->asUMLEntityConstraint();
 
         UMLForeignKeyConstraint* fkc = eConstr->asUMLForeignKeyConstraint();
         if (fkc == 0) {
             return;
         }
 
         UMLEntity* refEntity = fkc->getReferencedEntity();
         if (refEntity == 0) {
             return;
         }
 
         createAutoConstraintAssociation(refEntity, fkc, widget);
     }
 }
 
 void UMLScene::createAutoConstraintAssociation(UMLEntity* refEntity, UMLForeignKeyConstraint* fkConstraint, UMLWidget* widget)
 {
     if (refEntity == 0) {
         return;
     }
 
     Uml::AssociationType::Enum assocType = Uml::AssociationType::Relationship;
     UMLWidget *w = findWidget(refEntity->id());
     AssociationWidget *aw = 0;
 
     if (w) {
         aw = findAssocWidget(w, widget, fkConstraint->name());
         if (aw == 0 &&
             // if the current diagram type permits relationships
             AssocRules::allowAssociation(assocType, w, widget)) {
 
             // for foreign key contstraint, we need to create the association type Uml::AssociationType::Relationship.
             // The referenced entity is the "1" part (Role A) and the entity holding the relationship is the "many" part. (Role B)
             AssociationWidget *a = AssociationWidget::create(this, w, assocType, widget);
             a->setUMLObject(fkConstraint);
             //a->setVisibility(attr->getVisibility(), Uml::RoleType::B);
             a->setRoleName(fkConstraint->name(), Uml::RoleType::B);
             a->setActivated(true);
             if (! addAssociation(a))
                 delete a;
         }
     }
 
 }
 
 void UMLScene::createAutoAttributeAssociations2(UMLWidget *widget)
 {
     foreach(UMLWidget* w, widgetList()) {
         uIgnoreZeroPointer(w);
         if (w != widget) {
             createAutoAttributeAssociations(w);
 
             if (widget->umlObject() && widget->umlObject()->baseType() == UMLObject::ot_Entity)
                 createAutoConstraintAssociations(w);
         }
     }
 }
 
 /**
  * Find the maximum bounding rectangle of FloatingTextWidget widgets.
  * Auxiliary to copyAsImage().
  *
  * @param ft Pointer to the FloatingTextWidget widget to consider.
  * @param px  X coordinate of lower left corner. This value will be
  *            updated if the X coordinate of the lower left corner
  *            of ft is smaller than the px value passed in.
  * @param py  Y coordinate of lower left corner. This value will be
  *            updated if the Y coordinate of the lower left corner
  *            of ft is smaller than the py value passed in.
  * @param qx  X coordinate of upper right corner. This value will be
  *            updated if the X coordinate of the upper right corner
  *            of ft is larger than the qx value passed in.
  * @param qy  Y coordinate of upper right corner. This value will be
  *            updated if the Y coordinate of the upper right corner
  *            of ft is larger than the qy value passed in.
  */
 void UMLScene::findMaxBoundingRectangle(const FloatingTextWidget* ft, qreal& px, qreal& py, qreal& qx, qreal& qy)
 {
     if (ft == 0 || !ft->isVisible())
         return;
 
     qreal x = ft->x();
     qreal y = ft->y();
     qreal x1 = x + ft->width() - 1;
     qreal y1 = y + ft->height() - 1;
 
     if (px == -1 || x < px)
         px = x;
     if (py == -1 || y < py)
         py = y;
     if (qx == -1 || x1 > qx)
         qx = x1;
     if (qy == -1 || y1 > qy)
         qy = y1;
 }
 
 /**
  * Returns the PNG picture of the paste operation.
  */
 void UMLScene::copyAsImage(QPixmap*& pix)
 {
     //get the smallest rect holding the diagram
     QRectF rect = diagramRect();
     QPixmap diagram(rect.width(), rect.height());
 
     //only draw what is selected
     m_bDrawSelectedOnly = true;
     selectAssociations(true);
     getDiagram(diagram, rect);
 
     //now get the selection cut
     qreal px = -1, py = -1, qx = -1, qy = -1;
 
     //first get the smallest rect holding the widgets
     foreach(UMLWidget* temp, selectedWidgets()) {
         qreal x = temp->x();
         qreal y = temp->y();
         qreal x1 = x + temp->width() - 1;
         qreal y1 = y + temp->height() - 1;
         if (px == -1 || x < px) {
             px = x;
         }
         if (py == -1 || y < py) {
             py = y;
         }
         if (qx == -1 || x1 > qx) {
             qx = x1;
         }
         if (qy == -1 || y1 > qy) {
             qy = y1;
         }
     }
 
     //also take into account any text lines in assocs or messages
 
     //get each type of associations
     //This needs to be reimplemented to increase the rectangle
     //if a part of any association is not included
     foreach(AssociationWidget *a, associationList()) {
         if (! a->isSelected())
             continue;
         const FloatingTextWidget* multiA = a->multiplicityWidget(Uml::RoleType::A);
         const FloatingTextWidget* multiB = a->multiplicityWidget(Uml::RoleType::B);
         const FloatingTextWidget* roleA = a->roleWidget(Uml::RoleType::A);
         const FloatingTextWidget* roleB = a->roleWidget(Uml::RoleType::B);
         const FloatingTextWidget* changeA = a->changeabilityWidget(Uml::RoleType::A);
         const FloatingTextWidget* changeB = a->changeabilityWidget(Uml::RoleType::B);
         findMaxBoundingRectangle(multiA, px, py, qx, qy);
         findMaxBoundingRectangle(multiB, px, py, qx, qy);
         findMaxBoundingRectangle(roleA, px, py, qx, qy);
         findMaxBoundingRectangle(roleB, px, py, qx, qy);
         findMaxBoundingRectangle(changeA, px, py, qx, qy);
         findMaxBoundingRectangle(changeB, px, py, qx, qy);
     }//end foreach
 
     QRectF imageRect;  //area with respect to diagramRect()
     //i.e. all widgets on the scene.  Was previously with
     //respect to whole scene
 
     imageRect.setLeft(px - rect.left());
     imageRect.setTop(py - rect.top());
     imageRect.setRight(qx - rect.left());
     imageRect.setBottom(qy - rect.top());
 
     pix = new QPixmap(imageRect.width(), imageRect.height());
     QPainter output(pix);
     output.drawPixmap(QPoint(0, 0), diagram, imageRect);
     m_bDrawSelectedOnly = false;
 }
 
 /**
  * Reset the toolbar.
  */
 void UMLScene::resetToolbar()
 {
     emit sigResetToolBar();
 }
 
 void UMLScene::triggerToolbarButton(WorkToolBar::ToolBar_Buttons button)
 {
     m_d->triggerToolBarButton(button);
 }
 
 /**
  * Event handler for context menu events.
  */
 void UMLScene::contextMenuEvent(QGraphicsSceneContextMenuEvent* event)
 {
     QGraphicsScene::contextMenuEvent(event);
     if (!event->isAccepted()) {
         setPos(event->scenePos());
         UMLScenePopupMenu popup(m_view, this);
         QAction *triggered = popup.exec(event->screenPos());
         slotMenuSelection(triggered);
         event->accept();
     }
 }
 
 /**
  * Returns the status on whether in a paste state.
  *
  * @return Returns the status on whether in a paste state.
  */
 bool UMLScene::getPaste() const
 {
     return m_bPaste;
 }
 
 /**
  * Sets the status on whether in a paste state.
  */
 void UMLScene::setPaste(bool paste)
 {
     m_bPaste = paste;
 }
 
 /**
  * When a menu selection has been made on the menu
  * that this view created, this method gets called.
  */
 void UMLScene::slotMenuSelection(QAction* action)
 {
     ListPopupMenu::MenuType sel = ListPopupMenu::typeFromAction(action);
     switch (sel) {
     case ListPopupMenu::mt_Undo:
         UMLApp::app()->undo();
         break;
 
     case ListPopupMenu::mt_Redo:
         UMLApp::app()->redo();
         break;
 
     case ListPopupMenu::mt_Clear:
         clearDiagram();
         break;
 
     case ListPopupMenu::mt_Export_Image:
         m_pImageExporter->exportView();
         break;
 
     case ListPopupMenu::mt_Apply_Layout:
     case ListPopupMenu::mt_Apply_Layout1:
     case ListPopupMenu::mt_Apply_Layout2:
     case ListPopupMenu::mt_Apply_Layout3:
     case ListPopupMenu::mt_Apply_Layout4:
     case ListPopupMenu::mt_Apply_Layout5:
     case ListPopupMenu::mt_Apply_Layout6:
     case ListPopupMenu::mt_Apply_Layout7:
     case ListPopupMenu::mt_Apply_Layout8:
     case ListPopupMenu::mt_Apply_Layout9:
         {
             QVariant value = ListPopupMenu::dataFromAction(ListPopupMenu::dt_ApplyLayout, action);
             applyLayout(value.toString());
         }
         break;
 
     case ListPopupMenu::mt_FloatText:
         {
             FloatingTextWidget* ft = new FloatingTextWidget(this);
             ft->showChangeTextDialog();
             //if no text entered delete
             if (!FloatingTextWidget::isTextValid(ft->text())) {
                 delete ft;
             } else {
                 ft->setID(UniqueID::gen());
                 setupNewWidget(ft);
             }
         }
         break;
 
     case ListPopupMenu::mt_UseCase:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_UseCase);
         break;
 
     case ListPopupMenu::mt_Actor:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Actor);
         break;
 
     case ListPopupMenu::mt_Class:
     case ListPopupMenu::mt_Object:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Class);
         break;
 
     case ListPopupMenu::mt_Package:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Package);
         break;
 
     case ListPopupMenu::mt_Subsystem:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_SubSystem);
        break;
 
     case ListPopupMenu::mt_Component:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Component);
         break;
 
     case ListPopupMenu::mt_Node:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Node);
         break;
 
     case ListPopupMenu::mt_Artifact:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Artifact);
         break;
 
     case ListPopupMenu::mt_Interface:
     case ListPopupMenu::mt_InterfaceComponent:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Interface);
         break;
 
     case ListPopupMenu::mt_Enum:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Enum);
         break;
 
     case ListPopupMenu::mt_Entity:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Entity);
         break;
 
     case ListPopupMenu::mt_Category:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Category);
         break;
 
     case ListPopupMenu::mt_Datatype:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Datatype);
         break;
 
     case ListPopupMenu::mt_Instance:
         m_bCreateObject = true;
         Object_Factory::createUMLObject(UMLObject::ot_Instance);
         break;
 
     case ListPopupMenu::mt_Note: {
         m_bCreateObject = true;
         UMLWidget* widget = new NoteWidget(this);
         addItem(widget);
         widget->setPos(pos());
         widget->setSize(100, 40);
         widget->showPropertiesDialog();
         QSizeF size = widget->minimumSize();
         widget->setSize(size);
         break;
     }
 
     case ListPopupMenu::mt_Cut:
         //FIXME make this work for diagram's right click menu
         if (selectedWidgets().count() &&
             UMLApp::app()->editCutCopy(true)) {
             deleteSelection();
             m_doc->setModified(true);
         }
         break;
 
     case ListPopupMenu::mt_Copy:
         //FIXME make this work for diagram's right click menu
         selectedWidgets().count() && UMLApp::app()->editCutCopy(true);
         break;
 
     case ListPopupMenu::mt_Paste:
         m_PastePoint = m_pos;
         m_pos.setX(2000);
         m_pos.setY(2000);
         UMLApp::app()->slotEditPaste();
 
         m_PastePoint.setX(0);
         m_PastePoint.setY(0);
         break;
 
     case ListPopupMenu::mt_Initial_State:
         {
             StateWidget* state = new StateWidget(this, StateWidget::Initial);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_End_State:
         {
             StateWidget* state = new StateWidget(this, StateWidget::End);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_Junction:
         {
             StateWidget* state = new StateWidget(this, StateWidget::Junction);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_DeepHistory:
         {
             StateWidget* state = new StateWidget(this, StateWidget::DeepHistory);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_ShallowHistory:
         {
             StateWidget* state = new StateWidget(this, StateWidget::ShallowHistory);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_Choice:
         {
             StateWidget* state = new StateWidget(this, StateWidget::Choice);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_StateFork:
         {
             StateWidget* state = new StateWidget(this, StateWidget::Fork);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_StateJoin:
         {
             StateWidget* state = new StateWidget(this, StateWidget::Join);
             setupNewWidget(state);
         }
         break;
 
     case ListPopupMenu::mt_State:
         {
             QString name = Widget_Utils::defaultWidgetName(WidgetBase::WidgetType::wt_State);
             bool ok = Dialog_Utils::askNewName(WidgetBase::WidgetType::wt_State, name);
             if (ok) {
                 StateWidget* state = new StateWidget(this);
                 state->setName(name);
                 setupNewWidget(state);
             }
         }
         break;
 
     case ListPopupMenu::mt_CombinedState:
         {
             QString name = Widget_Utils::defaultWidgetName(WidgetBase::WidgetType::wt_State);
             bool ok;
             do {
                 if (!Diagram_Utils::isUniqueDiagramName(Uml::DiagramType::State, name))
                     name.append(QLatin1String("_1"));
                 ok = Dialog_Utils::askNewName(WidgetBase::WidgetType::wt_State, name);
             } while(ok && !Diagram_Utils::isUniqueDiagramName(Uml::DiagramType::State, name));
             if (ok) {
                 StateWidget* state = new StateWidget(this);
                 state->setName(name);
                 setupNewWidget(state);
                 Uml::CmdCreateDiagram* d = new Uml::CmdCreateDiagram(m_doc, Uml::DiagramType::State, name);
                 UMLApp::app()->executeCommand(d);
                 state->setDiagramLink(d->view()->umlScene()->ID());
                 d->view()->umlScene()->setWidgetLink(state);
                 state->setStateType(StateWidget::Combined);
             }
         }
         break;
 
     case ListPopupMenu::mt_ReturnToCombinedState:
         if (widgetLink()) {
             UMLApp::app()->document()->changeCurrentView(widgetLink()->umlScene()->ID());
             widgetLink()->update();
             widgetLink()->umlScene()->update();
             setWidgetLink(nullptr);
         }
         break;
 
     case ListPopupMenu::mt_Initial_Activity:
         {
             ActivityWidget* activity = new ActivityWidget(this, ActivityWidget::Initial);
             setupNewWidget(activity);
         }
         break;
 
     case ListPopupMenu::mt_End_Activity:
         {
             ActivityWidget* activity = new ActivityWidget(this, ActivityWidget::End);
             setupNewWidget(activity);
         }
         break;
 
     case ListPopupMenu::mt_Branch:
         {
             ActivityWidget* activity = new ActivityWidget(this, ActivityWidget::Branch);
             setupNewWidget(activity);
         }
         break;
 
     case ListPopupMenu::mt_Activity:
         {
             QString name;
             bool ok = Dialog_Utils::askDefaultNewName(WidgetBase::wt_Activity, name);
             if (ok) {
                 ActivityWidget* activity = new ActivityWidget(this, ActivityWidget::Normal);
                 activity->setName(name);
                 setupNewWidget(activity);
             }
         }
         break;
 
     case ListPopupMenu::mt_SnapToGrid:
         toggleSnapToGrid();
         m_doc->setModified();
         break;
 
     case ListPopupMenu::mt_SnapComponentSizeToGrid:
         toggleSnapComponentSizeToGrid();
         m_doc->setModified();
         break;
 
     case ListPopupMenu::mt_ShowSnapGrid:
         toggleShowGrid();
         m_doc->setModified();
         break;
 
     case ListPopupMenu::mt_ShowDocumentationIndicator:
         setShowDocumentationIndicator(!isShowDocumentationIndicator());
         update();
         break;
 
     case ListPopupMenu::mt_Properties:
         if (m_view->showPropertiesDialog() == true)
             m_doc->setModified();
         break;
 
     case ListPopupMenu::mt_Delete:
         m_doc->removeDiagram(ID());
         break;
 
     case ListPopupMenu::mt_Rename:
         {
             QString newName = name();
             bool ok = Dialog_Utils::askName(i18n("Enter Diagram Name"),
                                             i18n("Enter the new name of the diagram:"),
                                             newName);
             if (ok) {
                 setName(newName);
                 m_doc->signalDiagramRenamed(activeView());
             }
         }
         break;
 
     case ListPopupMenu::mt_Import_from_File:
     {
         QPointer<UMLFileDialog> dialog = new UMLFileDialog(QUrl(), QString(), UMLApp::app());
         dialog->exec();
         QUrl url = dialog->selectedUrl();
         if (!url.isEmpty())
             if (!Diagram_Utils::importGraph(url.toLocalFile(), this))
                 UMLApp::app()->slotStatusMsg(i18n("Failed to import from file."));
         break;
     }
 
     case ListPopupMenu::mt_MessageSynchronous:
         m_d->triggerToolBarButton(WorkToolBar::tbb_Seq_Message_Synchronous);
         break;
 
     case ListPopupMenu::mt_MessageAsynchronous:
         m_d->triggerToolBarButton(WorkToolBar::tbb_Seq_Message_Asynchronous);
         break;
 
     case ListPopupMenu::mt_MessageFound:
         m_d->triggerToolBarButton(WorkToolBar::tbb_Seq_Message_Found);
         break;
 
     case ListPopupMenu::mt_MessageLost:
         m_d->triggerToolBarButton(WorkToolBar::tbb_Seq_Message_Lost);
         break;
 
     default:
         uWarning() << "unknown ListPopupMenu::MenuType " << ListPopupMenu::toString(sel);
         break;
     }
 }
 
 /**
  * Connects to the signal that @ref UMLApp emits when a cut operation
  * is successful.
  * If the view or a child started the operation the flag m_bStartedCut will
  * be set and we can carry out any operation that is needed, like deleting the selected
  * widgets for the cut operation.
  */
 void UMLScene::slotCutSuccessful()
 {
     if (m_bStartedCut) {
         deleteSelection();
         m_bStartedCut = false;
     }
 }
 
 /**
  * Called by menu when to show the instance of the view.
  */
 void UMLScene::slotShowView()
 {
     m_doc->changeCurrentView(ID());
 }
 
 /**
  * Returns the offset point at which to place the paste from clipboard.
  * Just add the amount to your co-ords.
  * Only call this straight after the event, the value won't stay valid.
  * Should only be called by Assoc widgets at the moment. no one else needs it.
  */
 QPointF UMLScene::getPastePoint()
 {
     QPointF point = m_PastePoint;
     point.setX(point.x() - m_pos.x());
     point.setY(point.y() - m_pos.y());
     return point;
 }
 
 /**
  * Reset the paste point.
  */
 void UMLScene::resetPastePoint()
 {
     m_PastePoint = m_pos;
 }
 
 /**
  * Called by the view or any of its children when they start a cut
  * operation.
  */
 void UMLScene::setStartedCut()
 {
     m_bStartedCut = true;
 }
 
 /**
  * Returns the font to use
  */
 QFont UMLScene::font() const
 {
     return m_Options.uiState.font;
 }
 
 /**
  * Sets the font for the view and optionally all the widgets on the view.
  */
 void UMLScene::setFont(QFont font, bool changeAllWidgets /* = false */)
 {
     m_Options.uiState.font = font;
     if (!changeAllWidgets)
         return;
     foreach(UMLWidget* w, widgetList()) {
         uIgnoreZeroPointer(w);
         w->setFont(font);
     }
 }
 
 /**
  * Sets some options for all the @ref ClassifierWidget on the view.
  */
 void UMLScene::setClassWidgetOptions(ClassOptionsPage * page)
 {
     foreach(UMLWidget* pWidget, widgetList()) {
         uIgnoreZeroPointer(pWidget);
         WidgetBase::WidgetType wt = pWidget->baseType();
         if (wt == WidgetBase::wt_Class) {
             page->setWidget(pWidget->asClassifierWidget());
             page->apply();
         } else if (wt == WidgetBase::wt_Interface) {
             page->setWidget(pWidget->asInterfaceWidget());
             page->apply();
         }
     }
 }
 
 /**
  * Returns the type of the selected widget or widgets.
  *
  * If multiple widgets of different types are selected. WidgetType::UMLWidget
  * is returned.
  */
 WidgetBase::WidgetType UMLScene::getUniqueSelectionType()
 {
     if (selectedWidgets().isEmpty()) {
         return WidgetBase::wt_UMLWidget;
     }
 
     // Get the first item and its base type
     UMLWidget * pTemp = (UMLWidget *) selectedWidgets().first();
     WidgetBase::WidgetType tmpType = pTemp->baseType();
 
     // Check all selected items, if they have the same BaseType
     foreach(pTemp, selectedWidgets()) {
         if (pTemp->baseType() != tmpType) {
             return WidgetBase::wt_UMLWidget;
         }
     }
 
     return tmpType;
 }
 
 /**
  * Asks for confirmation and clears everything on the diagram.
  * Called from menus.
  */
 void UMLScene::clearDiagram()
 {
     if (Dialog_Utils::askDeleteDiagram()) {
         removeAllWidgets();
     }
 }
 
 /**
  * Apply an automatic layout.
  */
 void UMLScene::applyLayout(const QString &variant)
 {
     DEBUG(DBG_SRC) << "layout = " << variant;
     LayoutGenerator r;
     r.generate(this, variant);
     r.apply(this);
     resizeSceneToItems();
     UMLApp::app()->slotZoomFit();
 }
 
 /**
  * Changes snap to grid boolean.
  * Called from menus.
  */
 void UMLScene::toggleSnapToGrid()
 {
     setSnapToGrid(!snapToGrid());
 }
 
 /**
  * Changes snap to grid for component size boolean.
  * Called from menus.
  */
 void UMLScene::toggleSnapComponentSizeToGrid()
 {
     setSnapComponentSizeToGrid(!snapComponentSizeToGrid());
 }
 
 /**
  * Changes show grid boolean.
  * Called from menus.
  */
 void UMLScene::toggleShowGrid()
 {
     setSnapGridVisible(!isSnapGridVisible());
 }
 
 /**
  * Return whether to use snap to grid.
  */
 bool UMLScene::snapToGrid() const
 {
     return m_bUseSnapToGrid;
 }
 
 /**
  *  Sets whether to snap to grid.
  */
 void UMLScene::setSnapToGrid(bool bSnap)
 {
     m_bUseSnapToGrid = bSnap;
     emit sigSnapToGridToggled(snapToGrid());
 }
 
 /**
  * Return whether to use snap to grid for component size.
  */
 bool UMLScene::snapComponentSizeToGrid() const
 {
     return m_bUseSnapComponentSizeToGrid;
 }
 
 /**
  * Sets whether to snap to grid for component size.
  */
 void UMLScene::setSnapComponentSizeToGrid(bool bSnap)
 {
     m_bUseSnapComponentSizeToGrid = bSnap;
     updateComponentSizes();
     emit sigSnapComponentSizeToGridToggled(snapComponentSizeToGrid());
 }
 
 /**
  * Returns the x grid size.
  */
 int UMLScene::snapX() const
 {
     return m_layoutGrid->gridSpacingX();
 }
 
 /**
  * Returns the y grid size.
  */
 int UMLScene::snapY() const
 {
     return m_layoutGrid->gridSpacingY();
 }
 
 /**
  * Sets the grid size in x and y.
  */
 void UMLScene::setSnapSpacing(int x, int y)
 {
     m_layoutGrid->setGridSpacing(x, y);
 }
 
 /**
  * Returns the input coordinate with possible grid-snap applied.
  */
 qreal UMLScene::snappedX(qreal _x)
 {
     if (snapToGrid()) {
         int x = (int)_x;
         int gridX = snapX();
         int modX = x % gridX;
         x -= modX;
         if (modX >= gridX / 2)
             x += gridX;
         return x;
     }
     else
         return _x;
 }
 
 /**
  * Returns the input coordinate with possible grid-snap applied.
  */
 qreal UMLScene::snappedY(qreal _y)
 {
     if (snapToGrid()) {
         int y = (int)_y;
         int gridY = snapY();
         int modY = y % gridY;
         y -= modY;
         if (modY >= gridY / 2)
             y += gridY;
         return y;
     }
     else
         return _y;
 }
 
 /**
  *  Returns whether to show snap grid or not.
  */
 bool UMLScene::isSnapGridVisible() const
 {
     return m_layoutGrid->isVisible();
 }
 
 /**
  * Sets whether to show snap grid.
  */
 void UMLScene::setSnapGridVisible(bool bShow)
 {
     m_layoutGrid->setVisible(bShow);
     emit sigShowGridToggled(bShow);
 }
 
 /**
  *  Returns whether to show documentation indicator.
  */
 bool UMLScene::isShowDocumentationIndicator() const
 {
     return m_showDocumentationIndicator;
 }
 
 /**
  *  sets whether to show documentation indicator.
  */
 void UMLScene::setShowDocumentationIndicator(bool bShow)
 {
     m_showDocumentationIndicator = bShow;
 }
 
 /**
  * Returns whether to show operation signatures.
  */
 bool UMLScene::showOpSig() const
 {
     return m_Options.classState.showOpSig;
 }
 
 /**
  * Sets whether to show operation signatures.
  */
 void UMLScene::setShowOpSig(bool bShowOpSig)
 {
     m_Options.classState.showOpSig = bShowOpSig;
 }
 
 /**
  * Changes the zoom to the currently set level (now loaded from file)
  * Called from UMLApp::slotUpdateViews()
  */
 void UMLScene::fileLoaded()
 {
     m_view->setZoom(m_view->zoom());
     resizeSceneToItems();
 }
 
 /**
  * Sets the size of the scene to just fit on all the items
  */
 void UMLScene::resizeSceneToItems()
 {
     // let QGraphicsScene handle scene size by itself
     setSceneRect(itemsBoundingRect());
 }
 
 /**
  * Updates the size of all components in this view.
  */
 void UMLScene::updateComponentSizes()
 {
     // update sizes of all components
     foreach(UMLWidget *obj, widgetList()) {
         uIgnoreZeroPointer(obj);
         obj->updateGeometry();
     }
 }
 
 /**
  * Force the widget font metrics to be updated next time
  * the widgets are drawn.
  * This is necessary because the widget size might depend on the
  * font metrics and the font metrics might change for different
  * QPainter, i.e. font metrics for Display font and Printer font are
  * usually different.
  * Call this when you change the QPainter.
  */
 void UMLScene::forceUpdateWidgetFontMetrics(QPainter * painter)
 {
     foreach(UMLWidget *obj, widgetList()) {
         uIgnoreZeroPointer(obj);
         obj->forceUpdateFontMetrics(painter);
     }
 }
 
 /**
  * Overrides standard method from QGraphicsScene drawing the background.
  */
 void UMLScene::drawBackground(QPainter *painter, const QRectF &rect)
 {
     QGraphicsScene::drawBackground(painter, rect);
     m_layoutGrid->paint(painter, rect);
     // debug info
     if (Tracer::instance()->isEnabled(QLatin1String(metaObject()->className()))) {
         painter->setPen(Qt::green);
         painter->drawRect(sceneRect());
         painter->setPen(Qt::blue);
         painter->drawRect(itemsBoundingRect());
         QVector<QLineF> lines;
         lines << QLineF(m_pos + QPointF(-5,0), m_pos + QPointF(5,0))
               << QLineF(m_pos + QPointF(0,-5), m_pos + QPointF(0,5));
         painter->setPen(Qt::gray);
         painter->drawLines(lines);
     }
 }
 
 /**
  * Creates the "diagram" tag and fills it with the contents of the diagram.
  */
 void UMLScene::saveToXMI1(QDomDocument & qDoc, QDomElement & qElement)
 {
     resizeSceneToItems();
     QDomElement viewElement = qDoc.createElement(QLatin1String("diagram"));
     viewElement.setAttribute(QLatin1String("xmi.id"), Uml::ID::toString(m_nID));
     viewElement.setAttribute(QLatin1String("name"), name());
     viewElement.setAttribute(QLatin1String("type"), m_Type);
     viewElement.setAttribute(QLatin1String("documentation"), m_Documentation);
     //option state
     m_Options.saveToXMI1(viewElement);
     //misc
     viewElement.setAttribute(QLatin1String("localid"), Uml::ID::toString(m_nLocalID));
     viewElement.setAttribute(QLatin1String("showgrid"), m_layoutGrid->isVisible());
     viewElement.setAttribute(QLatin1String("snapgrid"), m_bUseSnapToGrid);
     viewElement.setAttribute(QLatin1String("snapcsgrid"), m_bUseSnapComponentSizeToGrid);
     viewElement.setAttribute(QLatin1String("snapx"), m_layoutGrid->gridSpacingX());
     viewElement.setAttribute(QLatin1String("snapy"), m_layoutGrid->gridSpacingY());
     // FIXME: move to UMLView
     viewElement.setAttribute(QLatin1String("zoom"), activeView()->zoom());
     viewElement.setAttribute(QLatin1String("canvasheight"), QString::number(height()));
     viewElement.setAttribute(QLatin1String("canvaswidth"), QString::number(width()));
     viewElement.setAttribute(QLatin1String("isopen"), isOpen());
     if (isSequenceDiagram() || isCollaborationDiagram())
         viewElement.setAttribute(QLatin1String("autoincrementsequence"), autoIncrementSequence());
 
     //now save all the widgets
     QDomElement widgetElement = qDoc.createElement(QLatin1String("widgets"));
     foreach(UMLWidget *widget, widgetList()) {
         uIgnoreZeroPointer(widget);
         // do not save floating text widgets having a parent widget; they are saved as part of the parent
         if (widget->isTextWidget() && widget->parentItem())
             continue;
         // Having an exception is bad I know, but gotta work with
         // system we are given.
         // We DON'T want to record any text widgets which are belonging
         // to associations as they are recorded later in the "associations"
         // section when each owning association is dumped. -b.t.
         if ((!widget->isTextWidget() &&
              !widget->isFloatingDashLineWidget()) ||
              (widget->asFloatingTextWidget() && widget->asFloatingTextWidget()->link() == 0))
             widget->saveToXMI1(qDoc, widgetElement);
     }
     viewElement.appendChild(widgetElement);
     //now save the message widgets
     QDomElement messageElement = qDoc.createElement(QLatin1String("messages"));
     foreach(UMLWidget* widget, messageList()) {
         widget->saveToXMI1(qDoc, messageElement);
     }
     viewElement.appendChild(messageElement);
     //now save the associations
     QDomElement assocElement = qDoc.createElement(QLatin1String("associations"));
     if (associationList().count()) {
         // We guard against (associationList().count() == 0) because
         // this code could be reached as follows:
         //  ^  UMLScene::saveToXMI1()
         //  ^  UMLDoc::saveToXMI1()
         //  ^  UMLDoc::addToUndoStack()
         //  ^  UMLDoc::setModified()
         //  ^  UMLDoc::createDiagram()
         //  ^  UMLDoc::newDocument()
         //  ^  UMLApp::newDocument()
         //  ^  main()
         //
         AssociationWidget * assoc = 0;
         foreach(assoc, associationList()) {
             assoc->saveToXMI1(qDoc, assocElement);
         }
     }
     viewElement.appendChild(assocElement);
     qElement.appendChild(viewElement);
 }
 
 /**
  * Loads the "diagram" tag.
  */
 bool UMLScene::loadFromXMI1(QDomElement & qElement)
 {
     QString id = qElement.attribute(QLatin1String("xmi.id"), QLatin1String("-1"));
     m_nID = Uml::ID::fromString(id);
     if (m_nID == Uml::ID::None)
         return false;
     setName(qElement.attribute(QLatin1String("name")));
     QString type = qElement.attribute(QLatin1String("type"), QLatin1String("0"));
     m_Documentation = qElement.attribute(QLatin1String("documentation"));
     QString localid = qElement.attribute(QLatin1String("localid"), QLatin1String("0"));
     // option state
     m_Options.loadFromXMI1(qElement);
     setBackgroundBrush(m_Options.uiState.backgroundColor);
     setGridDotColor(m_Options.uiState.gridDotColor);
     //misc
     QString showgrid = qElement.attribute(QLatin1String("showgrid"), QLatin1String("0"));
     m_layoutGrid->setVisible((bool)showgrid.toInt());
 
     QString snapgrid = qElement.attribute(QLatin1String("snapgrid"), QLatin1String("0"));
     m_bUseSnapToGrid = (bool)snapgrid.toInt();
 
     QString snapcsgrid = qElement.attribute(QLatin1String("snapcsgrid"), QLatin1String("0"));
     m_bUseSnapComponentSizeToGrid = (bool)snapcsgrid.toInt();
 
     QString snapx = qElement.attribute(QLatin1String("snapx"), QLatin1String("10"));
     QString snapy = qElement.attribute(QLatin1String("snapy"), QLatin1String("10"));
     m_layoutGrid->setGridSpacing(snapx.toInt(), snapy.toInt());
 
     QString zoom = qElement.attribute(QLatin1String("zoom"), QLatin1String("100"));
     activeView()->setZoom(zoom.toInt());
     resizeSceneToItems();
 
     QString isOpen = qElement.attribute(QLatin1String("isopen"), QLatin1String("1"));
     m_isOpen = (bool)isOpen.toInt();
 
     int nType = type.toInt();
     if (nType == -1 || nType >= 400) {
         // Pre 1.5.5 numeric values
         // Values of "type" were changed in 1.5.5 to merge with Settings::Diagram
         switch (nType) {
         case 400:
             m_Type = Uml::DiagramType::UseCase;
             break;
         case 401:
             m_Type = Uml::DiagramType::Collaboration;
             break;
         case 402:
             m_Type = Uml::DiagramType::Class;
             break;
         case 403:
             m_Type = Uml::DiagramType::Sequence;
             break;
         case 404:
             m_Type = Uml::DiagramType::State;
             break;
         case 405:
             m_Type = Uml::DiagramType::Activity;
             break;
         case 406:
             m_Type = Uml::DiagramType::Component;
             break;
         case 407:
             m_Type = Uml::DiagramType::Deployment;
             break;
         case 408:
             m_Type = Uml::DiagramType::EntityRelationship;
             break;
         case 409:
             m_Type = Uml::DiagramType::Object;
             break;
         default:
             m_Type = Uml::DiagramType::Undefined;
             break;
         }
     } else {
         m_Type = Uml::DiagramType::fromInt(nType);
     }
     m_nLocalID = Uml::ID::fromString(localid);
 
     if (m_Type == Uml::DiagramType::Sequence ||
         m_Type == Uml::DiagramType::Collaboration) {
         QString autoIncrementSequence = qElement.attribute(QLatin1String("autoincrementsequence"),
                                                            QLatin1String("0"));
         m_autoIncrementSequence = (bool)autoIncrementSequence.toInt();
     }
 
     QDomNode node = qElement.firstChild();
     bool widgetsLoaded = false, messagesLoaded = false, associationsLoaded = false;
     while (!node.isNull()) {
         QDomElement element = node.toElement();
         if (!element.isNull()) {
             if (element.tagName() == QLatin1String("widgets"))
                 widgetsLoaded = loadWidgetsFromXMI(element);
             else if (element.tagName() == QLatin1String("messages"))
                 messagesLoaded = loadMessagesFromXMI(element);
             else if (element.tagName() == QLatin1String("associations"))
                 associationsLoaded = loadAssociationsFromXMI(element);
         }
         node = node.nextSibling();
     }
 
     if (!widgetsLoaded) {
         uWarning() << "failed UMLScene load on widgets";
         return false;
     }
     if (!messagesLoaded) {
         uWarning() << "failed UMLScene load on messages";
         return false;
     }
     if (!associationsLoaded) {
         uWarning() << "failed UMLScene load on associations";
         return false;
     }
 
     if (this->isComponentDiagram()) {
         m_d->addMissingPorts();
         m_d->fixPortPositions();
     }
     m_d->removeDuplicatedFloatingTextInstances();
     return true;
 }
 
 bool UMLScene::loadWidgetsFromXMI(QDomElement & qElement)
 {
     UMLWidget* widget = 0;
     QDomNode node = qElement.firstChild();
     QDomElement widgetElement = node.toElement();
     while (!widgetElement.isNull()) {
         widget = loadWidgetFromXMI(widgetElement);
         if (widget) {
             addWidgetCmd(widget);
             widget->clipSize();
             // In the interest of best-effort loading, in case of a
             // (widget == 0) we still go on.
             // The individual widget's loadFromXMI1 method should
             // already have generated an error message to tell the
             // user that something went wrong.
         }
         node = widgetElement.nextSibling();
         widgetElement = node.toElement();
     }
 
     return true;
 }
 
 /**
  * Loads a "widget" element from XMI, used by loadFromXMI1() and the clipboard.
  */
 UMLWidget* UMLScene::loadWidgetFromXMI(QDomElement& widgetElement)
 {
     if (!m_doc) {
         uWarning() << "m_doc is NULL";
         return 0L;
     }
 
     QString tag  = widgetElement.tagName();
     QString idstr  = widgetElement.attribute(QLatin1String("xmi.id"), QLatin1String("-1"));
     UMLWidget* widget = Widget_Factory::makeWidgetFromXMI(tag, idstr, this);
 
     if (widget == 0)
         return 0;
     if (!widget->loadFromXMI1(widgetElement)) {
         widget->cleanup();
         delete widget;
         return 0;
     }
     return widget;
 }
 
 bool UMLScene::loadMessagesFromXMI(QDomElement & qElement)
 {
     MessageWidget * message = 0;
     QDomNode node = qElement.firstChild();
     QDomElement messageElement = node.toElement();
     while (!messageElement.isNull()) {
         QString tag = messageElement.tagName();
         DEBUG(DBG_SRC) << "tag = " << tag;
         if (tag == QLatin1String("messagewidget") ||
             tag == QLatin1String("UML:MessageWidget")) {   // for bkwd compatibility
             message = new MessageWidget(this, SequenceMessage::Asynchronous,
                                         Uml::ID::Reserved);
             if (!message->loadFromXMI1(messageElement)) {
                 delete message;
                 return false;
             }
             addWidgetCmd(message);
             FloatingTextWidget *ft = message->floatingTextWidget();
             if (!ft && message->sequenceMessageType() != SequenceMessage::Creation)
                 DEBUG(DBG_SRC) << "floating text is NULL for message " << Uml::ID::toString(message->id());
         }
         node = messageElement.nextSibling();
         messageElement = node.toElement();
     }
     return true;
 }
 
 bool UMLScene::loadAssociationsFromXMI(QDomElement & qElement)
 {
     QDomNode node = qElement.firstChild();
     QDomElement assocElement = node.toElement();
     int countr = 0;
     while (!assocElement.isNull()) {
         QString tag = assocElement.tagName();
         if (tag == QLatin1String("assocwidget") ||
             tag == QLatin1String("UML:AssocWidget")) {  // for bkwd compatibility
             countr++;
             AssociationWidget *assoc = AssociationWidget::create(this);
             if (!assoc->loadFromXMI1(assocElement)) {
                 uError() << "could not loadFromXMI1 association widget:"
                          << assoc << ", bad XMI file? Deleting from UMLScene.";
                 delete assoc;
                 /* return false;
                    Returning false here is a little harsh when the
                    rest of the diagram might load okay.
                  */
             } else {
                 assoc->clipSize();
                 if (!addAssociation(assoc, false)) {
                     uError() << "Could not addAssociation(" << assoc << ") to UMLScene, deleting.";
                     delete assoc;
                     //return false; // soften error.. may not be that bad
                 }
             }
         }
         node = assocElement.nextSibling();
         assocElement = node.toElement();
     }
     return true;
 }
 
 /**
  * Add an object to the application, and update the view.
  */
 void UMLScene::addObject(UMLObject *object)
 {
     m_bCreateObject = true;
     if (m_doc->addUMLObject(object))
         m_doc->signalUMLObjectCreated(object);  // m_bCreateObject is reset by slotObjectCreated()
     else
         m_bCreateObject = false;
 }
 
 bool UMLScene::loadUisDiagramPresentation(QDomElement & qElement)
 {
     for (QDomNode node = qElement.firstChild(); !node.isNull(); node = node.nextSibling()) {
         QDomElement elem = node.toElement();
         QString tag = elem.tagName();
         if (! UMLDoc::tagEq(tag, QLatin1String("Presentation"))) {
             uError() << "ignoring unknown UisDiagramPresentation tag " << tag;
             continue;
         }
         QDomNode n = elem.firstChild();
         QDomElement e = n.toElement();
         QString idStr;
         int x = 0, y = 0, w = 0, h = 0;
         while (!e.isNull()) {
             tag = e.tagName();
             DEBUG(DBG_SRC) << "Presentation: tag = " << tag;
             if (UMLDoc::tagEq(tag, QLatin1String("Presentation.geometry"))) {
                 QDomNode gnode = e.firstChild();
                 QDomElement gelem = gnode.toElement();
                 QString csv = gelem.text();
                 QStringList dim = csv.split(QLatin1Char(','));
                 x = dim[0].toInt();
                 y = dim[1].toInt();
                 w = dim[2].toInt();
                 h = dim[3].toInt();
             } else if (UMLDoc::tagEq(tag, QLatin1String("Presentation.style"))) {
                 // TBD
             } else if (UMLDoc::tagEq(tag, QLatin1String("Presentation.model"))) {
                 QDomNode mnode = e.firstChild();
                 QDomElement melem = mnode.toElement();
                 idStr = melem.attribute(QLatin1String("xmi.idref"));
             } else {
                 DEBUG(DBG_SRC) << "ignoring tag " << tag;
             }
             n = n.nextSibling();
             e = n.toElement();
         }
         Uml::ID::Type id = Uml::ID::fromString(idStr);
         UMLObject *o = m_doc->findObjectById(id);
         if (o == 0) {
             uError() << "Cannot find object for id " << idStr;
         } else {
             UMLObject::ObjectType ot = o->baseType();
             DEBUG(DBG_SRC) << "Create widget for model object of type " << UMLObject::toString(ot);
             UMLWidget *widget = 0;
             switch (ot) {
             case UMLObject::ot_Class:
                 widget = new ClassifierWidget(this, o->asUMLClassifier());
                 break;
             case UMLObject::ot_Association: {
                 UMLAssociation *umla = o->asUMLAssociation();
                 Uml::AssociationType::Enum at = umla->getAssocType();
                 UMLObject* objA = umla->getObject(Uml::RoleType::A);
                 UMLObject* objB = umla->getObject(Uml::RoleType::B);
                 if (objA == 0 || objB == 0) {
                     uError() << "intern err 1";
                     return false;
                 }
                 UMLWidget *wA = findWidget(objA->id());
                 UMLWidget *wB = findWidget(objB->id());
                 if (wA != 0 && wB != 0) {
                     AssociationWidget *aw =
                         AssociationWidget::create(this, wA, at, wB, umla);
                     aw->syncToModel();
                     addWidgetCmd(aw);
                 } else {
                     uError() << "cannot create assocwidget from (" ; //<< wA << ", " << wB << ")";
                 }
                 break;
             }
             case UMLObject::ot_Role: {
                 //UMLRole *robj = o->asUMLRole();
                 //UMLAssociation *umla = robj->getParentAssociation();
                 // @todo properly display role names.
                 //       For now, in order to get the role names displayed
                 //       simply delete the participating diagram objects
                 //       and drag them from the list view to the diagram.
                 break;
             }
             default:
                 uError() << "Cannot create widget of type " << ot;
             }
             if (widget) {
                 DEBUG(DBG_SRC) << "Widget: x=" << x << ", y=" << y
                                << ", w=" << w << ", h=" << h;
                 widget->setX(x);
                 widget->setY(y);
                 widget->setSize(w, h);
                 addWidgetCmd(widget);
             }
         }
     }
     return true;
 }
 
 /**
  * Loads the "UISDiagram" tag of Unisys.IntegratePlus.2 generated files.
  */
 bool UMLScene::loadUISDiagram(QDomElement & qElement)
 {
     QString idStr = qElement.attribute(QLatin1String("xmi.id"));
     if (idStr.isEmpty())
         return false;
     m_nID = Uml::ID::fromString(idStr);
     UMLListViewItem *ulvi = 0;
     for (QDomNode node = qElement.firstChild(); !node.isNull(); node = node.nextSibling()) {
         if (node.isComment())
             continue;
         QDomElement elem = node.toElement();
         QString tag = elem.tagName();
         if (tag == QLatin1String("uisDiagramName")) {
             setName(elem.text());
             if (ulvi)
                 ulvi->setText(name());
         } else if (tag == QLatin1String("uisDiagramStyle")) {
             QString diagramStyle = elem.text();
             if (diagramStyle != QLatin1String("ClassDiagram")) {
                 uError() << "diagram style " << diagramStyle << " is not yet implemented";
                 continue;
             }
             m_doc->setMainViewID(m_nID);
             m_Type = Uml::DiagramType::Class;
             UMLListView *lv = UMLApp::app()->listView();
             ulvi = new UMLListViewItem(lv->theLogicalView(), name(),
                                        UMLListViewItem::lvt_Class_Diagram, m_nID);
         } else if (tag == QLatin1String("uisDiagramPresentation")) {
             loadUisDiagramPresentation(elem);
         } else if (tag != QLatin1String("uisToolName")) {
             DEBUG(DBG_SRC) << "ignoring tag " << tag;
         }
     }
     return true;
 }
 
 /**
  * Left Alignment
  */
 void UMLScene::alignLeft()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
 
     qreal smallestX = WidgetList_Utils::getSmallestX(widgetList);
 
     foreach(UMLWidget *widget, widgetList) {
         widget->setX(smallestX);
         widget->adjustAssocs(widget->x(), widget->y());
     }
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Right Alignment
  */
 void UMLScene::alignRight()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
     qreal biggestX = WidgetList_Utils::getBiggestX(widgetList);
 
     foreach(UMLWidget *widget, widgetList) {
         widget->setX(biggestX - widget->width());
         widget->adjustAssocs(widget->x(), widget->y());
     }
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Top Alignment
  */
 void UMLScene::alignTop()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
 
     qreal smallestY = WidgetList_Utils::getSmallestY(widgetList);
 
     foreach(UMLWidget *widget, widgetList) {
         widget->setY(smallestY);
         widget->adjustAssocs(widget->x(), widget->y());
     }
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Bottom Alignment
  */
 void UMLScene::alignBottom()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
     qreal biggestY = WidgetList_Utils::getBiggestY(widgetList);
 
     foreach(UMLWidget *widget, widgetList) {
         widget->setY(biggestY - widget->height());
         widget->adjustAssocs(widget->x(), widget->y());
     }
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Vertical Middle Alignment
  */
 void UMLScene::alignVerticalMiddle()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
 
     qreal smallestY = WidgetList_Utils::getSmallestY(widgetList);
     qreal biggestY = WidgetList_Utils::getBiggestY(widgetList);
     qreal middle = int((biggestY - smallestY) / 2) + smallestY;
 
     foreach(UMLWidget *widget, widgetList) {
         widget->setY(middle - widget->height() / 2);
         widget->adjustAssocs(widget->x(), widget->y());
     }
 
     AssociationWidgetList assocList = selectedAssocs();
     if (!assocList.isEmpty()) {
         foreach (AssociationWidget *widget, assocList) {
             widget->setYEntireAssoc(middle);
         }
     }
 
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Horizontal Middle Alignment
  */
 void UMLScene::alignHorizontalMiddle()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
 
     qreal smallestX = WidgetList_Utils::getSmallestX(widgetList);
     qreal biggestX = WidgetList_Utils::getBiggestX(widgetList);
     qreal middle = int((biggestX - smallestX) / 2) + smallestX;
 
     foreach(UMLWidget *widget, widgetList) {
         widget->setX(middle - widget->width() / 2);
         widget->adjustAssocs(widget->x(), widget->y());
     }
 
     AssociationWidgetList assocList = selectedAssocs();
     if (!assocList.isEmpty()) {
         foreach (AssociationWidget *widget, assocList) {
             widget->setXEntireAssoc(middle);
         }
     }
 
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Vertical Distribute Alignment
  */
 void UMLScene::alignVerticalDistribute()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
 
     qreal smallestY = WidgetList_Utils::getSmallestY(widgetList);
     qreal biggestY = WidgetList_Utils::getBiggestY(widgetList);
     qreal heightsSum = WidgetList_Utils::getHeightsSum(widgetList);
     qreal distance = int(((biggestY - smallestY) - heightsSum) / (widgetList.count() - 1.0) + 0.5);
 
     qSort(widgetList.begin(), widgetList.end(), Widget_Utils::hasSmallerY);
 
     int i = 1;
     UMLWidget* widgetPrev = 0;
     foreach(UMLWidget *widget, widgetList) {
         if (i == 1) {
             widgetPrev = widget;
         } else {
             widget->setY(widgetPrev->y() + widgetPrev->height() + distance);
             widget->adjustAssocs(widget->x(), widget->y());
             widgetPrev = widget;
         }
         i++;
     }
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Horizontal Distribute Alignment
  */
 void UMLScene::alignHorizontalDistribute()
 {
     UMLWidgetList widgetList = selectedWidgetsExt();
     if (widgetList.isEmpty())
         return;
 
     qreal smallestX = WidgetList_Utils::getSmallestX(widgetList);
     qreal biggestX = WidgetList_Utils::getBiggestX(widgetList);
     qreal widthsSum = WidgetList_Utils::getWidthsSum(widgetList);
     qreal distance = int(((biggestX - smallestX) - widthsSum) / (widgetList.count() - 1.0) + 0.5);
 
     qSort(widgetList.begin(), widgetList.end(), Widget_Utils::hasSmallerX);
 
     int i = 1;
     UMLWidget* widgetPrev = 0;
     foreach(UMLWidget *widget,  widgetList) {
         if (i == 1) {
             widgetPrev = widget;
         } else {
             widget->setX(widgetPrev->x() + widgetPrev->width() + distance);
             widget->adjustAssocs(widget->x(), widget->y());
             widgetPrev = widget;
         }
         i++;
     }
     //TODO: Push stored cmds to stack.
 }
 
 /**
  * Overloading operator for debugging output.
  */
 QDebug operator<<(QDebug dbg, UMLScene *item)
 {
     dbg.nospace() << "UMLScene: " << item->name()
                   << " / type=" << DiagramType::toString(item->type())
                   << " / id=" << Uml::ID::toString(item->ID())
                   << " / isOpen=" << item->isOpen();
     return dbg.space();
 }
 
 void UMLScene::setWidgetLink(WidgetBase *w)
 {
     m_d->widgetLink = w;
 }
 
 WidgetBase *UMLScene::widgetLink()
 {
     return m_d->widgetLink;
 }
diff --git a/umbrello/umlwidgets/umlwidget.cpp b/umbrello/umlwidgets/umlwidget.cpp
index 12e48c7cd..c7a0eb6d9 100644
--- a/umbrello/umlwidgets/umlwidget.cpp
+++ b/umbrello/umlwidgets/umlwidget.cpp
@@ -1,2188 +1,2189 @@
 /***************************************************************************
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   copyright (C) 2002-2014                                               *
  *   Umbrello UML Modeller Authors <umbrello-devel@kde.org>                *
  ***************************************************************************/
 
 #include "umlwidget.h"
 
 // local includes
 #include "artifact.h"
 #include "artifactwidget.h"
 #include "activitywidget.h"
 #include "actor.h"
 #include "actorwidget.h"
 #include "associationwidget.h"
 #include "classifier.h"
 #include "classpropertiesdialog.h"
 #include "cmds.h"
 #include "component.h"
 #include "componentwidget.h"
 #include "debug_utils.h"
 #include "dialog_utils.h"
 #include "docwindow.h"
 #include "floatingtextwidget.h"
 #include "forkjoinwidget.h"
 #include "interfacewidget.h"
 #include "notewidget.h"
 #include "messagewidget.h"
 #include "object_factory.h"
 #include "idchangelog.h"
 #include "menus/listpopupmenu.h"
 #include "objectnodewidget.h"
 #include "pinwidget.h"
 #include "port.h"
 #include "portwidget.h"
 #include "regionwidget.h"
 #include "signalwidget.h"
 #include "settingsdialog.h"
 #include "statewidget.h"
 #include "uml.h"
 #include "umldoc.h"
 #include "umllistview.h"
 #include "umlobject.h"
 #include "umlscene.h"
 #include "umlview.h"
 #include "usecase.h"
 #include "usecasewidget.h"
 #include "uniqueid.h"
 #include "widget_factory.h"
 
 // kde includes
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // qt includes
 #include <QApplication>
 #include <QColor>
 #include <QPainter>
 #include <QPointer>
 
 using namespace Uml;
 
 DEBUG_REGISTER_DISABLED(UMLWidget)
 
 const QSizeF UMLWidget::DefaultMinimumSize(50, 20);
 const QSizeF UMLWidget::DefaultMaximumSize(1000, 5000);
 const int UMLWidget::defaultMargin = 5;
 const int UMLWidget::selectionMarkerSize = 4;
 const int UMLWidget::resizeMarkerLineCount = 3;
 
 
 /**
  * Creates a UMLWidget object.
  *
  * @param scene The view to be displayed on.
  * @param type  The WidgetType to construct.
  *              This must be set to the appropriate value by the constructors of inheriting classes.
  * @param o The UMLObject to represent.
  */
 UMLWidget::UMLWidget(UMLScene * scene, WidgetType type, UMLObject * o)
   : WidgetBase(scene, type)
 {
     init();
     m_umlObject = o;
     if (m_umlObject) {
         connect(m_umlObject, SIGNAL(modified()), this, SLOT(updateWidget()));
         m_nId = m_umlObject->id();
     }
 }
 
 /**
  * Creates a UMLWidget object.
  *
  * @param scene The view to be displayed on.
  * @param type  The WidgetType to construct.
  *              This must be set to the appropriate value by the constructors of inheriting classes.
  * @param id The id of the widget.
  *  The default value (id_None) will prompt generation of a new ID.
  */
 UMLWidget::UMLWidget(UMLScene *scene, WidgetType type, Uml::ID::Type id)
   : WidgetBase(scene, type)
 {
     init();
     if (id == Uml::ID::None)
         m_nId = UniqueID::gen();
     else
         m_nId = id;
 }
 
 /**
  * Destructor.
  */
 UMLWidget::~UMLWidget()
 {
     cleanup();
 }
 
 /**
  * Assignment operator
  */
 UMLWidget& UMLWidget::operator=(const UMLWidget & other)
 {
     if (this == &other)
         return *this;
 
     WidgetBase::operator=(other);
 
     // assign members loaded/saved
     m_useFillColor = other.m_useFillColor;
     m_usesDiagramFillColor = other.m_usesDiagramFillColor;
     m_usesDiagramUseFillColor = other.m_usesDiagramUseFillColor;
     m_fillColor = other.m_fillColor;
     m_Assocs = other.m_Assocs;
     m_isInstance = other.m_isInstance;
     m_instanceName = other.m_instanceName;
     m_instanceName = other.m_instanceName;
     m_showStereotype = other.m_showStereotype;
     setX(other.x());
     setY(other.y());
     setRect(rect().x(), rect().y(), other.width(), other.height());
 
     // assign volatile (non-saved) members
     m_startMove = other.m_startMove;
     m_nPosX = other.m_nPosX;
     m_doc = other.m_doc;    //new
     m_resizable = other.m_resizable;
     for (unsigned i = 0; i < FT_INVALID; ++i)
         m_pFontMetrics[i] = other.m_pFontMetrics[i];
     m_activated = other.m_activated;
     m_ignoreSnapToGrid = other.m_ignoreSnapToGrid;
     m_ignoreSnapComponentSizeToGrid = other.m_ignoreSnapComponentSizeToGrid;
     return *this;
 }
 
 /**
  * Overload '==' operator
  */
 bool UMLWidget::operator==(const UMLWidget& other) const
 {
     if (this == &other)
         return true;
 
     if (baseType() != other.baseType()) {
         return false;
     }
 
     if (id() != other.id())
         return false;
 
     /* Testing the associations is already an exaggeration, no?
        The type and ID should uniquely identify an UMLWidget.
      */
     if (m_Assocs.count() != other.m_Assocs.count()) {
         return false;
     }
 
     // if(getBaseType() != wt_Text) // DON'T do this for floatingtext widgets, an infinite loop will result
     // {
     AssociationWidgetListIt assoc_it(m_Assocs);
     AssociationWidgetListIt assoc_it2(other.m_Assocs);
     AssociationWidget * assoc = 0, *assoc2 = 0;
     while (assoc_it.hasNext() &&  assoc_it2.hasNext()) {
         assoc = assoc_it.next();
         assoc2 = assoc_it2.next();
 
         if (!(*assoc == *assoc2)) {
             return false;
         }
     }
     // }
     return true;
     // NOTE:  In the comparison tests we are going to do, we don't need these values.
     // They will actually stop things functioning correctly so if you change these, be aware of that.
     /*
     if(m_useFillColor != other.m_useFillColor)
         return false;
     if(m_nId != other.m_nId)
         return false;
     if(m_nX  != other.m_nX)
         return false;
     if(m_nY != other.m_nY)
         return false;
      */
 }
 
 /**
  * Sets the local id of the object.
  *
  * @param id   The local id of the object.
  */
 void UMLWidget::setLocalID(Uml::ID::Type id)
 {
     m_nLocalID = id;
 }
 
 /**
  * Returns the local ID for this object.  This ID is used so that
  * many objects of the same @ref UMLObject instance can be on the
  * same diagram.
  *
  * @return  The local ID.
  */
 Uml::ID::Type UMLWidget::localID() const
 {
     return m_nLocalID;
 }
 
 /**
  * Returns the widget with the given ID.
  * The default implementation tests the following IDs:
  * - m_nLocalID
  * - if m_umlObject is non NULL: m_umlObject->id()
  * - m_nID
  * Composite widgets override this function to test further owned widgets.
  *
  * @param id  The ID to test this widget against.
  * @return  'this' if id is either of m_nLocalID, m_umlObject->id(), or m_nId;
  *           else NULL.
  */
 UMLWidget* UMLWidget::widgetWithID(Uml::ID::Type id)
 {
     if (id == m_nLocalID ||
         (m_umlObject != 0 && id == m_umlObject->id()) ||
         id == m_nId)
         return this;
     return 0;
 }
 
 /**
  * Compute the minimum possible width and height.
  *
  * @return QSizeF(mininum_width, minimum_height)
  */
 QSizeF UMLWidget::minimumSize() const
 {
     return m_minimumSize;
 }
 
 /**
  * This method is used to set the minimum size variable for this
  * widget.
  *
  * @param newSize The size being set as minimum.
  */
 void UMLWidget::setMinimumSize(const QSizeF& newSize)
 {
     m_minimumSize = newSize;
 }
 
 /**
  * Compute the maximum possible width and height.
  *
  * @return maximum size
  */
 QSizeF UMLWidget::maximumSize()
 {
     return m_maximumSize;
 }
 
 /**
  * This method is used to set the maximum size variable for this
  * widget.
  *
  * @param newSize The size being set as maximum.
  */
 void UMLWidget::setMaximumSize(const QSizeF& newSize)
 {
     m_maximumSize = newSize;
 }
 
 /**
  * Event handler for context menu events.
  */
 void UMLWidget::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
     WidgetBase::contextMenuEvent(event);
 }
 
 /**
  * Moves the widget to a new position using the difference between the
  * current position and the new position.
  * This method doesn't adjust associations. It only moves the widget.
  *
  * It can be overridden to constrain movement only in one axis even when
  * the user isn't constraining the movement with shift or control buttons, for example.
  * The movement policy set here is applied whenever the widget is moved, being it
  * moving it explicitly, or as a part of a selection but not receiving directly the
  * mouse events.
  *
  * Default behaviour is move the widget to the new position using the diffs.
  * @see constrainMovementForAllWidgets
  *
  * @param diffX The difference between current X position and new X position.
  * @param diffY The difference between current Y position and new Y position.
  */
 void UMLWidget::moveWidgetBy(qreal diffX, qreal diffY)
 {
     setX(x() + diffX);
     setY(y() + diffY);
 }
 
 /**
  * Modifies the value of the diffX and diffY variables used to move the widgets.
  *
  * It can be overridden to constrain movement of all the selected widgets only in one
  * axis even when the user isn't constraining the movement with shift or control
  * buttons, for example.
  * The difference with moveWidgetBy is that the diff positions used here are
  * applied to all the selected widgets instead of only to m_widget, and that
  * moveWidgetBy, in fact, moves the widget, and here simply the diff positions
  * are modified.
  *
  * Default behaviour is do nothing.
  * @see moveWidgetBy
  *
  * @param diffX The difference between current X position and new X position.
  * @param diffY The difference between current Y position and new Y position.
  */
 void UMLWidget::constrainMovementForAllWidgets(qreal &diffX, qreal &diffY)
 {
     Q_UNUSED(diffX) Q_UNUSED(diffY)
 }
 
 /**
  * Bring the widget at the pressed position to the foreground.
  */
 void UMLWidget::toForeground()
 {
     QRectF rect = QRectF(scenePos(), QSizeF(width(), height()));
     QList<QGraphicsItem*> items = scene()->items(rect, Qt::IntersectsItemShape, Qt::DescendingOrder);
     DEBUG(DBG_SRC) << "items at " << rect << " = " << items.count();
     if (items.count() > 1) {
         foreach(QGraphicsItem* i, items) {
             UMLWidget* w = dynamic_cast<UMLWidget*>(i);
             if (w) {
                 DEBUG(DBG_SRC) << "item=" << w->name() << " with zValue=" << w->zValue();
                 if (w->name() != name()) {
                     if (w->zValue() >= zValue()) {
                         setZValue(w->zValue() + 1.0);
                         DEBUG(DBG_SRC) << "bring to foreground with zValue: " << zValue();
                     }
                 }
             }
         }
     }
     else {
         setZValue(0.0);
     }
     DEBUG(DBG_SRC) << "zValue is " << zValue();
 }
 
 /**
  * Handles a mouse press event.
  * It'll select the widget (or mark it to be deselected) and prepare it to
  * be moved or resized. Go on reading for more info about this.
  *
  * Widget values and message bar status are saved.
  *
  * If shift or control buttons are pressed, we're in move area no matter
  * where the button was pressed in the widget. Moreover, if the widget
  * wasn't already selected, it's added to the selection. If already selected,
  * it's marked to be deselected when releasing the button (provided it isn't
  * moved).
  * Also, if the widget is already selected with other widgets but shift nor
  * control buttons are pressed, we're in move area. If finally we don't move
  * the widget, it's selected and the other widgets deselected when releasing
  * the left button.
  *
  * If shift nor control buttons are pressed, we're facing a single selection.
  * Depending on the position of the cursor, we're in move or in resize area.
  * If the widget wasn't selected (both when there are no widgets selected, or
  * when there're other widgets selected but not the one receiving the press
  * event) it's selected and the others deselected, if any. If already selected,
  * it's marked to be deselected when releasing the button (provided it wasn't
  * moved or resized).
  *
  * @param event The QGraphicsSceneMouseEvent event.
  */
 void UMLWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     if (event->button() != Qt::LeftButton) {
         event->ignore();
         return;
     }
     event->accept();
     DEBUG(DBG_SRC) << "widget = " << name() << " / type = " << baseTypeStr();
 
     toForeground();
 
     m_startMovePostion = pos();
     m_startResizeSize = QSizeF(width(), height());
 
     // saving the values of the widget
     m_pressOffset = event->scenePos() - pos();
     DEBUG(DBG_SRC) << "press offset=" << m_pressOffset;
 
     m_oldStatusBarMsg = UMLApp::app()->statusBarMsg();
 
     if (event->modifiers() == Qt::ShiftModifier || event->modifiers() == Qt::ControlModifier) {
         m_shiftPressed = true;
 
         if (event->button() == Qt::LeftButton) {
             m_inMoveArea = true;
         }
 
         if (!isSelected()) {
             selectMultiple(event);
         }
         return;
     }
 
     m_shiftPressed = false;
 
     int count = m_scene->selectedCount(true);
     if (event->button() == Qt::LeftButton) {
         if (isSelected() && count > 1) {
             // single selection is made in release event if the widget wasn't moved
             m_inMoveArea = true;
             m_oldPos = pos();
             return;
         }
 
         if (isInResizeArea(event)) {
             m_inResizeArea = true;
             m_oldW = width();
             m_oldH = height();
         } else {
             m_inMoveArea = true;
         }
     }
 
     // if widget wasn't selected, or it was selected but with other widgets also selected
     if (!isSelected() || count > 1) {
         selectSingle(event);
     }
 }
 
 /**
  * Handles a mouse move event.
  * It resizes or moves the widget, depending on where the cursor is pressed
  * on the widget. Go on reading for more info about this.
  *
  * If resizing, the widget is resized using UMLWidget::resizeWidget (where specific
  * widget resize constraint can be applied), and then the associations are
  * adjusted.
  * The resizing can be constrained also to a specific axis using control
  * and shift buttons. If on or another is pressed, it's constrained to X axis.
  * If both are pressed, it's constrained to Y axis.
  *
  * If not resizing, the widget is being moved. If the move is being started,
  * the selection bounds are set (which includes updating the list of selected
  * widgets).
  * The difference between the previous position of the selection and the new
  * one is got (taking in account the selection bounds so widgets don't go
  * beyond the scene limits). Then, it's constrained to X or Y axis depending
  * on shift and control buttons.
  * A further constraint is made using constrainMovementForAllWidgets (for example,
  * if the widget that receives the event can only be moved in Y axis, with this
  * method the movement of all the widgets in the selection can be constrained to
  * be moved only in Y axis).
  * Then, all the selected widgets are moved using moveWidgetBy (where specific
  * widget movement constraint can be applied) and, if a certain amount of time
  * passed from the last move event, the associations are also updated (they're
  * not updated always to be easy on the CPU). Finally, the scene is resized,
  * and selection bounds updated.
  *
  * @param event The QGraphicsSceneMouseEvent event.
  */
 void UMLWidget::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
 {
     if (m_inResizeArea) {
         resize(event);
         return;
     }
 
     if (!m_moved) {
         UMLApp::app()->document()->writeToStatusBar(i18n("Hold shift or ctrl to move in X axis. Hold shift and control to move in Y axis. Right button click to cancel move."));
 
         m_moved = true;
         //Maybe needed by AssociationWidget
         m_startMove = true;
 
         setSelectionBounds();
     }
 
     QPointF position = event->scenePos() - m_pressOffset;
     qreal diffX = position.x() - x();
     qreal diffY = position.y() - y();
 
     if ((event->modifiers() & Qt::ShiftModifier) && (event->modifiers() & Qt::ControlModifier)) {
         // move only in Y axis
         diffX = 0;
     } else if ((event->modifiers() & Qt::ShiftModifier) || (event->modifiers() & Qt::ControlModifier)) {
         // move only in X axis
         diffY = 0;
     }
 
     constrainMovementForAllWidgets(diffX, diffY);
 
     // nothing to move
     if (diffX == 0 && diffY == 0) {
         return;
     }
 
     QPointF delta = event->scenePos() - event->lastScenePos();
 
     DEBUG(DBG_SRC) << "diffX=" << diffX << " / diffY=" << diffY;
     foreach(UMLWidget* widget, umlScene()->selectedWidgets()) {
         if ((widget->parentItem() == 0) || (!widget->parentItem()->isSelected())) {
             widget->moveWidgetBy(diffX, diffY);
             widget->adjustUnselectedAssocs(delta.x(), delta.y());
             widget->slotSnapToGrid();
         }
     }
 
     // Move any selected associations.
     foreach(AssociationWidget* aw, m_scene->selectedAssocs()) {
         if (aw->isSelected()) {
             aw->moveEntireAssoc(diffX, diffY);
         }
     }
 
     umlScene()->resizeSceneToItems();
 }
 
 /**
  * Handles a mouse release event.
  * It selects or deselects the widget and cancels or confirms the move or
  * resize. Go on reading for more info about this.
  * No matter which tool is selected, Z position of widget is updated.
  *
  * Middle button release resets the selection.
  * Left button release, if it wasn't moved nor resized, selects the widget
  * and deselect the others if it wasn't selected and there were other widgets
  * selected. If the widget was marked to be deselected, deselects it.
  * If it was moved or resized, the document is set to modified if position
  * or size changed. Also, if moved, all the associations are adjusted because
  * the timer could have prevented the adjustment in the last move event before
  * the release.
  * If mouse was pressed in resize area, cursor is set again to normal cursor
  * Right button release if right button was pressed shows the pop up menu for
  * the widget.
  * If left button was pressed, it cancels the move or resize with a mouse move
  * event at the same position than the cursor was when pressed. Another left
  * button release is also sent.
  *
  * @param event The QGraphicsSceneMouseEvent event.
  */
 void UMLWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
     if (!m_moved && !m_resized) {
         if (!m_shiftPressed && (m_scene->selectedCount(true) > 1)) {
             selectSingle(event);
         } else if (!isSelected()) {
             deselect(event);
         }
     } else {
         // Commands
         if (m_moved) {
             int selectionCount = umlScene()->selectedWidgets().count();
             if (selectionCount > 1) {
                 UMLApp::app()->beginMacro(i18n("Move widgets"));
             }
             foreach(UMLWidget* widget, umlScene()->selectedWidgets()) {
                 UMLApp::app()->executeCommand(new Uml::CmdMoveWidget(widget));
             }
             if (selectionCount > 1) {
                 UMLApp::app()->endMacro();
             }
             m_moved = false;
         } else {
             UMLApp::app()->executeCommand(new Uml::CmdResizeWidget(this));
             m_autoResize = false;
             m_resized = false;
         }
 
         if ((m_inMoveArea && wasPositionChanged()) ||
                 (m_inResizeArea && wasSizeChanged())) {
             umlDoc()->setModified(true);
             umlScene()->invalidate();
         }
         umlScene()->resizeSceneToItems();
 
         UMLApp::app()->document()->writeToStatusBar(m_oldStatusBarMsg);
     }
 
     if (m_inResizeArea) {
         m_inResizeArea = false;
         m_scene->activeView()->setCursor(Qt::ArrowCursor);
     } else {
         m_inMoveArea = false;
     }
     m_startMove = false;
 }
 
 /**
  * Event handler for mouse double click events.
  * @param event the QGraphicsSceneMouseEvent event.
  */
 void UMLWidget::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 {
     if (event->button() == Qt::LeftButton) {
         DEBUG(DBG_SRC) << "widget = " << name() << " / type = " << baseTypeStr();
         showPropertiesDialog();
         event->accept();
     }
 }
 
 /**
  * Return the start position of the move action.
  * @return   point where the move began
  */
 QPointF UMLWidget::startMovePosition() const
 {
     return m_startMovePostion;
 }
 
 /**
  * Set the start position of the move action.
  * @param position point where the move began
  */
 void UMLWidget::setStartMovePosition(const QPointF &position)
 {
     m_startMovePostion = position;
 }
 
 /**
  * Return the start size of the resize action.
  * @return   size where the resize began
  */
 QSizeF UMLWidget::startResizeSize() const
 {
     return m_startResizeSize;
 }
 
 /**
  * Resizes the widget.
  * It's called from resize, after the values are constrained and before
  * the associations are adjusted.
  *
  * Default behaviour is resize the widget using the new size values.
  * @see resize
  *
  * @param newW   The new width for the widget.
  * @param newH   The new height for the widget.
  */
 void UMLWidget::resizeWidget(qreal newW, qreal newH)
 {
     setSize(newW, newH);
 }
 
 /**
  * Notify child widget about parent resizes.
  * Child widgets can override this function to move when their parent is resized.
  */
 void UMLWidget::notifyParentResize()
 {
 }
 
 
 /**
  * When a widget changes this slot captures that signal.
  */
 void UMLWidget::updateWidget()
 {
     updateGeometry();
     switch (baseType()) {
     case WidgetBase::wt_Class:
         m_scene->createAutoAttributeAssociations(this);
         break;
     case WidgetBase::wt_Entity:
         m_scene->createAutoConstraintAssociations(this);
         break;
     default:
         break;
     }
 
     if (isVisible())
         update();
 }
 
 /**
  * Apply possible constraints to the given candidate width and height.
  * The default implementation limits input values to the bounds returned
  * by minimumSize()/maximumSize().
  *
  * @param width  input value, may be modified by the constraint
  * @param height input value, may be modified by the constraint
  */
 void UMLWidget::constrain(qreal& width, qreal& height)
 {
     QSizeF minSize = minimumSize();
     if (width < minSize.width())
         width = minSize.width();
     if (height < minSize.height())
         height = minSize.height();
     QSizeF maxSize = maximumSize();
     if (width > maxSize.width())
         width = maxSize.width();
     if (height > maxSize.height())
         height = maxSize.height();
 
     if (fixedAspectRatio()) {
         QSizeF size = rect().size();
         float aspectRatio = size.width() > 0 ? (float)size.height()/size.width() : 1;
         height = width * aspectRatio;
     }
 }
 
 /**
  * Initializes key attributes of the class.
  */
 void UMLWidget::init()
 {
     m_nId = Uml::ID::None;
     m_nLocalID = UniqueID::gen();
     m_isInstance = false;
     setMinimumSize(DefaultMinimumSize);
     setMaximumSize(DefaultMaximumSize);
 
     m_font = QApplication::font();
     for (int i = (int)FT_INVALID - 1; i >= 0; --i) {
         FontType fontType = (FontType)i;
         setupFontType(m_font, fontType);
         m_pFontMetrics[fontType] = new QFontMetrics(m_font);
     }
 
     if (m_scene) {
         m_useFillColor = true;
         m_usesDiagramFillColor = true;
         m_usesDiagramUseFillColor = true;
         const Settings::OptionState& optionState = m_scene->optionState();
         m_fillColor = optionState.uiState.fillColor;
         m_showStereotype = optionState.classState.showStereoType;
     } else {
         uError() << "SERIOUS PROBLEM - m_scene is NULL";
         m_useFillColor = false;
         m_usesDiagramFillColor = false;
         m_usesDiagramUseFillColor = false;
         m_showStereotype = false;
     }
 
     m_resizable = true;
     m_fixedAspectRatio = false;
 
     m_startMove = false;
     m_activated = false;
     m_ignoreSnapToGrid = false;
     m_ignoreSnapComponentSizeToGrid = false;
     m_doc = UMLApp::app()->document();
     m_nPosX = 0;
     connect(m_scene, SIGNAL(sigFillColorChanged(Uml::ID::Type)), this, SLOT(slotFillColorChanged(Uml::ID::Type)));
     connect(m_scene, SIGNAL(sigLineColorChanged(Uml::ID::Type)), this, SLOT(slotLineColorChanged(Uml::ID::Type)));
     connect(m_scene, SIGNAL(sigTextColorChanged(Uml::ID::Type)), this, SLOT(slotTextColorChanged(Uml::ID::Type)));
     connect(m_scene, SIGNAL(sigLineWidthChanged(Uml::ID::Type)), this, SLOT(slotLineWidthChanged(Uml::ID::Type)));
 
     m_umlObject = 0;
 
     m_oldPos = QPointF();
     m_pressOffset = QPointF();
     m_oldW = 0;
     m_oldH = 0;
 
     m_shiftPressed = false;
     m_inMoveArea = false;
     m_inResizeArea = false;
     m_moved = false;
     m_resized = false;
 
     // propagate line color set by base class constructor
     // which does not call the virtual methods from this class.
     setLineColor(lineColor());
 
     setZValue(2.0);  // default for most widgets
 }
 
 /**
  * This is usually called synchronously after menu.exec() and \a
  * trigger's parent is always the ListPopupMenu which can be used to
  * get the type of action of \a trigger.
  *
  * @note Subclasses can reimplement to handle specific actions and
  *       leave the rest to WidgetBase::slotMenuSelection.
  */
 void UMLWidget::slotMenuSelection(QAction *trigger)
 {
     if (!trigger) {
         return;
     }
 
     ListPopupMenu::MenuType sel = ListPopupMenu::typeFromAction(trigger);
     switch (sel) {
     case ListPopupMenu::mt_Resize:
         umlScene()->resizeSelection();
         break;
 
     case ListPopupMenu::mt_AutoResize:
         setAutoResize(trigger->isChecked());
         updateGeometry();
         break;
 
     case ListPopupMenu::mt_Rename_Object: {
         QString name = m_instanceName;
         bool ok = Dialog_Utils::askName(i18n("Rename Object"),
                                         i18n("Enter object name:"),
                                         name);
         if (ok) {
             m_instanceName = name;
             updateGeometry();
             moveEvent(0);
             update();
             UMLApp::app()->document()->setModified(true);
         }
         break;
     }
 
     case ListPopupMenu::mt_FloatText: {
         FloatingTextWidget* ft = new FloatingTextWidget(umlScene());
         ft->showChangeTextDialog();
         //if no text entered delete
         if (!FloatingTextWidget::isTextValid(ft->text())) {
             delete ft;
         } else {
             ft->setID(UniqueID::gen());
             addWidget(ft, false);
         }
         break;
     }
 
     case ListPopupMenu::mt_Actor: {
         UMLActor *actor = new UMLActor;
         UMLWidget *widget = new ActorWidget(umlScene(), actor);
         addConnectedWidget(widget, Uml::AssociationType::Association);
         break;
     }
 
     case ListPopupMenu::mt_Artifact: {
         UMLArtifact *a = new UMLArtifact();
         ArtifactWidget *widget = new ArtifactWidget(umlScene(), a);
         addConnectedWidget(widget, Uml::AssociationType::Association);
         break;
     }
 
     case ListPopupMenu::mt_Component: {
         UMLComponent *c = new UMLComponent();
         ComponentWidget *widget = new ComponentWidget(umlScene(), c);
         addConnectedWidget(widget, Uml::AssociationType::Association, SetupSize);
         break;
     }
 
     case ListPopupMenu::mt_Interface: {
         UMLPackage* component = umlObject()->asUMLPackage();
         QString name = Model_Utils::uniqObjectName(UMLObject::ot_Interface, component);
         if (Dialog_Utils::askNewName(WidgetBase::wt_Interface, name)) {
             UMLClassifier *c = new UMLClassifier();
             c->setBaseType(UMLObject::ot_Interface);
             ClassifierWidget *widget = new ClassifierWidget(umlScene(), c);
             addConnectedWidget(widget, Uml::AssociationType::Association);
         }
         break;
     }
 
     case ListPopupMenu::mt_InterfaceComponent:
     case ListPopupMenu::mt_InterfaceProvided: {
         UMLObject *o = Object_Factory::createUMLObject(UMLObject::ot_Interface);
         InterfaceWidget *w = new InterfaceWidget(umlScene(), o->asUMLClassifier());
         w->setDrawAsCircle(true);
         addConnectedWidget(w, Uml::AssociationType::Association, SetupSize);
         break;
     }
 
     case ListPopupMenu::mt_InterfaceRequired: {
         UMLObject *o = Object_Factory::createUMLObject(UMLObject::ot_Interface);
         InterfaceWidget *w = new InterfaceWidget(umlScene(), o->asUMLClassifier());
         w->setDrawAsCircle(true);
         addConnectedWidget(w, Uml::AssociationType::Association, SetupSize | SwitchDirection);
         break;
     }
 
     case ListPopupMenu::mt_Note: {
         NoteWidget *widget = new NoteWidget(umlScene());
         addConnectedWidget(widget, Uml::AssociationType::Anchor);
         break;
     }
 
     case ListPopupMenu::mt_Port: {
         // TODO: merge with ToolbarStateOneWidget::setWidget()
         UMLPackage* component = umlObject()->asUMLPackage();
         QString name = Model_Utils::uniqObjectName(UMLObject::ot_Port, component);
         if (Dialog_Utils::askNewName(WidgetBase::wt_Port, name)) {
             UMLPort *port = Object_Factory::createUMLObject(UMLObject::ot_Port, name, component)->asUMLPort();
             UMLWidget *umlWidget = Widget_Factory::createWidget(umlScene(), port);
             umlWidget->setParentItem(this);
             umlScene()->setupNewWidget(umlWidget);
         }
         break;
     }
 
     case ListPopupMenu::mt_UseCase: {
         UMLUseCase *useCase = new UMLUseCase;
         UMLWidget *widget = new UseCaseWidget(umlScene(), useCase);
         addConnectedWidget(widget, Uml::AssociationType::Association);
         break;
     }
 
     case ListPopupMenu::mt_MessageSynchronous:
 //        MessageWidget *widget = new MessageWidget(umlScene(), this);
 //        addConnectedWidget(widget, Uml::AssociationType::Coll_Message_Synchronous);
     case ListPopupMenu::mt_MessageAsynchronous:
     case ListPopupMenu::mt_MessageFound:
     case ListPopupMenu::mt_MessageLost:
         break;
 
     // activity diagrams
     case ListPopupMenu::mt_Accept_Signal:
         addConnectedWidget(new SignalWidget(umlScene(), SignalWidget::Accept), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Accept_Time_Event:
         addConnectedWidget(new SignalWidget(umlScene(), SignalWidget::Time), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Activity:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Normal), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Activity_Transition:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Final), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Branch:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Branch), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Exception:
         umlScene()->triggerToolbarButton(WorkToolBar::tbb_Exception);
         break;
     case ListPopupMenu::mt_Final_Activity:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Final), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Fork:
         addConnectedWidget(new ForkJoinWidget(umlScene()), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_End_Activity:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::End), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Initial_Activity:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Initial), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Invoke_Activity:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Invok), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Object_Node:
         addConnectedWidget(new ObjectNodeWidget(umlScene(), ObjectNodeWidget::Data), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Pin:
         umlScene()->triggerToolbarButton(WorkToolBar::tbb_Pin);
         break;
     case ListPopupMenu::mt_Param_Activity:
         addConnectedWidget(new ActivityWidget(umlScene(), ActivityWidget::Param), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_PrePostCondition:
         addConnectedWidget(new NoteWidget(umlScene(), NoteWidget::Normal), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Region:
         addConnectedWidget(new RegionWidget(umlScene()), Uml::AssociationType::Activity, NoOption);
         break;
     case ListPopupMenu::mt_Send_Signal:
         addConnectedWidget(new SignalWidget(umlScene(), SignalWidget::Send), Uml::AssociationType::Activity, NoOption);
         break;
 
   // state diagrams
     case ListPopupMenu::mt_Choice:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::Choice), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_DeepHistory:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::DeepHistory), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_End_State:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::End), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_Junction:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::Junction), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_ShallowHistory:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::ShallowHistory), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_State:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::Normal), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_StateFork:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::Fork), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_StateJoin:
         addConnectedWidget(new StateWidget(umlScene(), StateWidget::Join), Uml::AssociationType::State, NoOption);
         break;
     case ListPopupMenu::mt_StateTransition:
         umlScene()->triggerToolbarButton(WorkToolBar::tbb_State_Transition);
         break;
     default:
         WidgetBase::slotMenuSelection(trigger);
         break;
     }
 }
 
 /**
  * Captures when another widget moves if this widget is linked to it.
  * @see sigWidgetMoved
  *
  * @param id The id of object behind the widget.
  */
 void UMLWidget::slotWidgetMoved(Uml::ID::Type /*id*/)
 {
 }
 
 /**
  * Captures a color change signal.
  *
  * @param viewID  The id of the UMLScene behind the widget.
  */
 void UMLWidget::slotFillColorChanged(Uml::ID::Type viewID)
 {
     //only change if on the diagram concerned
     if (m_scene->ID() != viewID) {
         return;
     }
     if (m_usesDiagramFillColor) {
         WidgetBase::setFillColor(m_scene->fillColor());
     }
     if (m_usesDiagramUseFillColor) {
         WidgetBase::setUseFillColor(m_scene->useFillColor());
     }
     update();
 }
 
 /**
  * Captures a text color change signal.
  *
  * @param viewID  The id of the UMLScene behind the widget.
  */
 void UMLWidget::slotTextColorChanged(Uml::ID::Type viewID)
 {
     //only change if on the diagram concerned
     if (m_scene->ID() != viewID)
         return;
     WidgetBase::setTextColor(m_scene->textColor());
     update();
 }
 
 
 /**
  * Captures a line color change signal.
  *
  * @param viewID  The id of the UMLScene behind the widget.
  */
 void UMLWidget::slotLineColorChanged(Uml::ID::Type viewID)
 {
     //only change if on the diagram concerned
     if (m_scene->ID() != viewID)
         return;
 
     if (m_usesDiagramLineColor) {
         WidgetBase::setLineColor(m_scene->lineColor());
     }
     update();
 }
 
 /**
  * Captures a linewidth change signal.
  *
  * @param viewID  The id of the UMLScene behind the widget.
  */
 void UMLWidget::slotLineWidthChanged(Uml::ID::Type viewID)
 {
     //only change if on the diagram concerned
     if (m_scene->ID() != viewID) {
         return;
     }
     if (m_usesDiagramLineWidth) {
         WidgetBase::setLineWidth(m_scene->lineWidth());
     }
     update();
 }
 
 /**
  * Set the status of using fill color (undo action)
  *
  * @param fc the status of using fill color.
  */
 void UMLWidget::setUseFillColor(bool fc)
 {
     if (useFillColor() != fc) {
         UMLApp::app()->executeCommand(new CmdChangeUseFillColor(this, fc));
     }
 }
 
 /**
  * Set the status of using fill color.
  *
  * @param fc the status of using fill color.
  */
 void UMLWidget::setUseFillColorCmd(bool fc)
 {
     WidgetBase::setUseFillColor(fc);
     update();
 }
 
 /**
  * Overrides the method from WidgetBase.
  */
 void UMLWidget::setTextColorCmd(const QColor &color)
 {
     WidgetBase::setTextColor(color);
     update();
 }
 
 /**
  * Overrides the method from WidgetBase.
  */
 void UMLWidget::setTextColor(const QColor &color)
 {
     if (textColor() != color) {
         UMLApp::app()->executeCommand(new CmdChangeTextColor(this, color));
         update();
     }
 }
 
 /**
  * Overrides the method from WidgetBase.
  */
 void UMLWidget::setLineColorCmd(const QColor &color)
 {
     WidgetBase::setLineColor(color);
     update();
 }
 
 /**
  * Overrides the method from WidgetBase.
  */
 void UMLWidget::setLineColor(const QColor &color)
 {
     if (lineColor() != color) {
         UMLApp::app()->executeCommand(new CmdChangeLineColor(this, color));
     }
 }
 
 /**
  * Overrides the method from WidgetBase, execute CmdChangeLineWidth
  */
 void UMLWidget::setLineWidth(uint width)
 {
     if (lineWidth() != width) {
         UMLApp::app()->executeCommand(new CmdChangeLineWidth(this, width));
     }
 }
 
 /**
  * Overrides the method from WidgetBase.
  */
 void UMLWidget::setLineWidthCmd(uint width)
 {
     WidgetBase::setLineWidth(width);
     update();
 }
 
 /**
  * Sets the background fill color
  *
  * @param color the new fill color
  */
 void UMLWidget::setFillColor(const QColor &color)
 {
     if (fillColor() != color) {
         UMLApp::app()->executeCommand(new CmdChangeFillColor(this, color));
     }
 }
 
 /**
  * Sets the background fill color
  *
  * @param color the new fill color
  */
 void UMLWidget::setFillColorCmd(const QColor &color)
 {
     WidgetBase::setFillColor(color);
     update();
 }
 
 /**
  * Activate the object after serializing it from a QDataStream
  *
  * @param ChangeLog
  * @return  true for success
  */
 bool UMLWidget::activate(IDChangeLog* /*ChangeLog  = 0 */)
 {
     if (widgetHasUMLObject(baseType()) && m_umlObject == 0) {
         m_umlObject = m_doc->findObjectById(m_nId);
         if (m_umlObject == 0) {
             uError() << "cannot find UMLObject with id=" << Uml::ID::toString(m_nId);
             return false;
         }
     }
     setFontCmd(m_font);
     setSize(width(), height());
     m_activated = true;
     updateGeometry();
     if (m_scene->getPaste()) {
         FloatingTextWidget * ft = 0;
         QPointF point = m_scene->getPastePoint();
         int x = point.x() + this->x();
         int y = point.y() + this->y();
         if (m_scene->isSequenceDiagram()) {
             switch (baseType()) {
             case WidgetBase::wt_Object:
             case WidgetBase::wt_Precondition :
                 setY(this->y());
                 setX(x);
                 break;
 
             case WidgetBase::wt_Message:
                 setY(this->y());
                 setX(x);
                 break;
 
             case WidgetBase::wt_Text:
                 ft = static_cast<FloatingTextWidget *>(this);
                 if (ft->textRole() == Uml::TextRole::Seq_Message) {
                     setX(x);
                     setY(this->y());
                 } else {
                     setX(this->x());
                     setY(this->y());
                 }
                 break;
 
             default:
                 setY(y);
                 break;
             }//end switch base type
         }//end if sequence
         else {
             setX(x);
             setY(y);
         }
     }//end if pastepoint
     else {
         setX(this->x());
         setY(this->y());
     }
     if (m_scene->getPaste())
         m_scene->createAutoAssociations(this);
     updateGeometry();
     return true;
 }
 
 /**
  * Returns true if the Activate method has been called for this instance
  *
  * @return The activate status.
  */
 bool UMLWidget::isActivated() const
 {
     return m_activated;
 }
 
 /**
  * Set the m_activated flag of a widget but does not perform the Activate method
  *
  * @param active  Status of activation is to be set.
  */
 void UMLWidget::setActivated(bool active /*=true*/)
 {
     m_activated = active;
 }
 
 /**
  * Adds an already created association to the list of
  * associations that include this UMLWidget
  */
 void UMLWidget::addAssoc(AssociationWidget* pAssoc)
 {
     if (pAssoc && !associationWidgetList().contains(pAssoc)) {
         associationWidgetList().append(pAssoc);
     }
 }
 
 /**
  *  Returns the list of associations connected to this widget.
  */
 AssociationWidgetList &UMLWidget::associationWidgetList() const
 {
     m_Assocs.removeAll(0);
     return m_Assocs;
 }
 
 /**
  * Removes an already created association from the list of
  * associations that include this UMLWidget
  */
 void UMLWidget::removeAssoc(AssociationWidget* pAssoc)
 {
     if (pAssoc) {
         associationWidgetList().removeAll(pAssoc);
     }
 
     if (changesShape()) {
         updateGeometry();
     }
 }
 
 /**
  * Adjusts associations with the given co-ordinates
  *
  * @param dx  The amount by which the widget moved in X direction.
  * @param dy  The amount by which the widget moved in Y direction.
  */
 void UMLWidget::adjustAssocs(qreal dx, qreal dy)
 {
     qDebug() << this;
     // don't adjust Assocs on file load, as
     // the original positions, which are stored in XMI
     // should be reproduced exactly
     // (don't try to reposition assocs as long
     //   as file is only partly loaded -> reposition
     //   could be misguided)
     /// @todo avoid trigger of this event during load
     if (m_doc->loading()) {
         // don't recalculate the assocs during load of XMI
         // -> return immediately without action
         return;
     }
 
     foreach(AssociationWidget* assocwidget, associationWidgetList()) {
         assocwidget->saveIdealTextPositions();
     }
 
     foreach(AssociationWidget* assocwidget, associationWidgetList()) {
         assocwidget->widgetMoved(this, dx, dy);
     }
 }
 
 /**
  * Adjusts all unselected associations with the given co-ordinates
  *
  * @param dx  The amount by which the widget moved in X direction.
  * @param dy  The amount by which the widget moved in Y direction.
  */
 void UMLWidget::adjustUnselectedAssocs(qreal dx, qreal dy)
 {
     foreach(AssociationWidget* assocwidget, associationWidgetList()) {
         if (!assocwidget->isSelected())
             assocwidget->saveIdealTextPositions();
     }
 
     foreach(AssociationWidget* assocwidget, associationWidgetList()) {
         if (!assocwidget->isSelected()) {
             assocwidget->widgetMoved(this, dx, dy);
         }
     }
 }
 
 /**
  * Show a properties dialog for a UMLWidget.
  */
 bool UMLWidget::showPropertiesDialog()
 {
     bool result = false;
     // will already be selected so make sure docWindow updates the doc
     // back it the widget
     UMLApp::app()->docWindow()->updateDocumentation(false);
     QPointer<ClassPropertiesDialog> dlg = new ClassPropertiesDialog((QWidget*)UMLApp::app(), this);
 
     if (dlg->exec()) {
         UMLApp::app()->docWindow()->showDocumentation(umlObject(), true);
         m_doc->setModified(true);
         result = true;
     }
     dlg->close(); //wipe from memory
     delete dlg;
     return result;
 }
 
 /**
  * Move the widget by an X and Y offset relative to
  * the current position.
  */
 void UMLWidget::moveByLocal(qreal dx, qreal dy)
 {
     qreal newX = x() + dx;
     qreal newY = y() + dy;
     setX(newX);
     setY(newY);
     adjustAssocs(dx, dy);
 }
 
 /**
  * Set the pen.
  */
 void UMLWidget::setPenFromSettings(QPainter & p)
 {
     p.setPen(QPen(m_lineColor, m_lineWidth));
 }
 
 /**
  * Set the pen.
  */
 void UMLWidget::setPenFromSettings(QPainter *p)
 {
     p->setPen(QPen(m_lineColor, m_lineWidth));
 }
 
 /**
  * Returns the cursor to be shown when resizing the widget.
  * Default cursor is KCursor::sizeFDiagCursor().
  *
  * @return The cursor to be shown when resizing the widget.
  */
 QCursor UMLWidget::resizeCursor() const
 {
     return Qt::SizeFDiagCursor;
 }
 
 /**
  * Checks if the mouse is in resize area (right bottom corner), and sets
  * the cursor depending on that.
  * The cursor used when resizing is gotten from resizeCursor().
  *
  * @param me The QMouseEVent to check.
  * @return true if the mouse is in resize area, false otherwise.
  */
 bool UMLWidget::isInResizeArea(QGraphicsSceneMouseEvent *me)
 {
     qreal m = 10.0;
     const qreal w = width();
     const qreal h = height();
 
     // If the widget itself is very small then make the resize area small, too.
     // Reason: Else it becomes impossible to do a move instead of resize.
     if (w - m < m || h - m < m) {
         m = 2.0;
     }
 
     if (m_resizable &&
             me->scenePos().x() >= (x() + w - m) &&
             me->scenePos().y() >= (y() + h - m)) {
         m_scene->activeView()->setCursor(resizeCursor());
         return true;
     } else {
         m_scene->activeView()->setCursor(Qt::ArrowCursor);
         return false;
     }
 }
 
 /**
  * calculate content related size of widget.
  *
  * @return calculated widget size
  */
 QSizeF UMLWidget::calculateSize(bool withExtensions /* = true */) const
 {
     Q_UNUSED(withExtensions)
     const QFontMetrics &fm = getFontMetrics(UMLWidget::FT_NORMAL);
     const int fontHeight = fm.lineSpacing();
     if (m_umlObject) {
         qreal width = 0, height = defaultMargin;
         if (!m_umlObject->stereotype().isEmpty()) {
             height += fontHeight;
             const QFontMetrics &bfm = UMLWidget::getFontMetrics(UMLWidget::FT_BOLD);
             const int stereoWidth = bfm.size(0, m_umlObject->stereotype(true)).width();
             if (stereoWidth > width)
                 width = stereoWidth;
         }
         height += fontHeight;
         const QFontMetrics &bfm = UMLWidget::getFontMetrics(UMLWidget::FT_BOLD);
         const int nameWidth = bfm.size(0, m_umlObject->name()).width();
         if (nameWidth > width)
             width = nameWidth;
         return QSizeF(width + 2*defaultMargin, height);
     }
     else
         return QSizeF(width(), height());
 }
 
 /**
  * Resize widget to minimum size.
  */
 void UMLWidget::resize()
 {
     qreal oldW = width();
     qreal oldH = height();
     // @TODO minimumSize() do not work in all cases, we need a dedicated autoResize() method
     QSizeF size = minimumSize();
     setSize(size.width(), size.height());
     DEBUG(DBG_SRC) << "size=" << size;
     adjustAssocs(size.width()-oldW, size.height()-oldH);
 }
 
 /**
  * Resizes the widget and adjusts the associations.
  * It's called when a mouse move event happens and the cursor was
  * in resize area when pressed.
  * Resizing can be constrained to an specific axis using control and shift buttons.
  *
  * @param me The QGraphicsSceneMouseEvent to get the values from.
  */
 void UMLWidget::resize(QGraphicsSceneMouseEvent *me)
 {
     QString msgX = i18n("Hold shift or control to move in X axis.");
     QString msgY = i18n("Hold shift and control to move in Y axis.");
     QString msg;
     if (isMessageWidget())
         msg = msgY;
     else if (isObjectWidget())
         msg = msgX;
     else
         msg = QString(QLatin1String("%1 %2")).arg(msgX, msgY);
     UMLApp::app()->document()->writeToStatusBar(msg);
 
     m_resized = true;
 
     qreal newW = m_oldW + me->scenePos().x() - x() - m_pressOffset.x();
     qreal newH = m_oldH + me->scenePos().y() - y() - m_pressOffset.y();
 
     if ((me->modifiers() & Qt::ShiftModifier) && (me->modifiers() & Qt::ControlModifier)) {
         //Move in Y axis
         newW = m_oldW;
     } else if ((me->modifiers() & Qt::ShiftModifier) || (me->modifiers() & Qt::ControlModifier)) {
         //Move in X axis
         newH = m_oldH;
     }
 
     constrain(newW, newH);
     resizeWidget(newW, newH);
     DEBUG(DBG_SRC) << "event=" << me->scenePos() << "/ pos=" << pos() << " / newW=" << newW << " / newH=" << newH;
     QPointF delta = me->scenePos() - me->lastScenePos();
     adjustAssocs(delta.x(), delta.y());
 
     m_scene->resizeSceneToItems();
 }
 
 /**
  * Checks if the size of the widget changed respect to the size that
  * it had when press event was fired.
  *
  * @return true if was resized, false otherwise.
  */
 bool UMLWidget::wasSizeChanged()
 {
     return m_oldW != width() || m_oldH != height();
 }
 
 /**
  * Checks if the position of the widget changed respect to the position that
  * it had when press event was fired.
  *
  * @return true if was moved, false otherwise.
  */
 bool UMLWidget::wasPositionChanged()
 {
     return m_oldPos != pos();
 }
 
 /**
  * Fills m_selectedWidgetsList and sets the selection bounds ((m_min/m_max)X/Y attributes).
  */
 void UMLWidget::setSelectionBounds()
 {
 }
 
 void UMLWidget::setSelectedFlag(bool _select)
 {
     WidgetBase::setSelected(_select);
 }
 
 /**
  * Sets the state of whether the widget is selected.
  *
  * @param _select The state of whether the widget is selected.
  */
 void UMLWidget::setSelected(bool _select)
 {
-    WidgetBase::setSelected(_select);
     const WidgetBase::WidgetType wt = baseType();
     if (_select) {
         if (m_scene->selectedCount() == 0) {
             if (widgetHasUMLObject(wt)) {
                 UMLApp::app()->docWindow()->showDocumentation(m_umlObject, false);
             } else {
                 UMLApp::app()->docWindow()->showDocumentation(this, false);
             }
         }//end if
         /* if (wt != wt_Text && wt != wt_Box) {
             setZ(9);//keep text on top and boxes behind so don't touch Z value
         } */
     } else {
         /* if (wt != wt_Text && wt != wt_Box) {
             setZ(m_origZ);
         } */
         if (isSelected())
             UMLApp::app()->docWindow()->updateDocumentation(true);
     }
 
+    WidgetBase::setSelected(_select);
+
     update();
 
     // selection changed, we have to make sure the copy and paste items
     // are correctly enabled/disabled
     UMLApp::app()->slotCopyChanged();
 
     // select in tree view as done for diagrams
     if (_select) {
         UMLListViewItem * item = UMLApp::app()->listView()->findItem(id());
         if (item)
             UMLApp::app()->listView()->setCurrentItem(item);
         else
             UMLApp::app()->listView()->clearSelection();
     }
 }
 
 /**
  * Selects the widget and clears the other selected widgets, if any.
  *
  * @param me The QGraphicsSceneMouseEvent which made the selection.
  */
 void UMLWidget::selectSingle(QGraphicsSceneMouseEvent *me)
 {
     m_scene->clearSelected();
 
     // Adds the widget to the selected widgets list, but as it has been cleared
     // only the current widget is selected.
     selectMultiple(me);
 }
 
 /**
  * Selects the widget and adds it to the list of selected widgets.
  *
  * @param me The QGraphicsSceneMouseEvent which made the selection.
  */
 void UMLWidget::selectMultiple(QGraphicsSceneMouseEvent *me)
 {
     Q_UNUSED(me);
 
     setSelected(true);
 }
 
 /**
  * Deselects the widget and removes it from the list of selected widgets.
  *
  * @param me The QGraphicsSceneMouseEvent which made the selection.
  */
 void UMLWidget::deselect(QGraphicsSceneMouseEvent *me)
 {
     Q_UNUSED(me);
 
     setSelected(false);
 }
 
 /**
  * Clears the selection, resets the toolbar and deselects the widget.
  */
 //void UMLWidget::resetSelection()
 //{
 //    m_scene->clearSelected();
 //    m_scene->resetToolbar();
 //    setSelected(false);
 //}
 
 /**
  * Sets the view the widget is on.
  *
  * @param scene  The UMLScene the widget is on.
  */
 void UMLWidget::setScene(UMLScene *scene)
 {
     //remove signals from old view - was probably 0 anyway
     disconnect(m_scene, SIGNAL(sigFillColorChanged(Uml::ID::Type)), this, SLOT(slotFillColorChanged(Uml::ID::Type)));
     disconnect(m_scene, SIGNAL(sigTextColorChanged(Uml::ID::Type)), this, SLOT(slotTextColorChanged(Uml::ID::Type)));
     disconnect(m_scene, SIGNAL(sigLineWidthChanged(Uml::ID::Type)), this, SLOT(slotLineWidthChanged(Uml::ID::Type)));
     m_scene = scene;
     connect(m_scene, SIGNAL(sigFillColorChanged(Uml::ID::Type)), this, SLOT(slotFillColorChanged(Uml::ID::Type)));
     connect(m_scene, SIGNAL(sigTextColorChanged(Uml::ID::Type)), this, SLOT(slotTextColorChanged(Uml::ID::Type)));
     connect(m_scene, SIGNAL(sigLineWidthChanged(Uml::ID::Type)), this, SLOT(slotLineWidthChanged(Uml::ID::Type)));
 }
 
 /**
  * Sets the x-coordinate.
  * Currently, the only class that reimplements this method is
  * ObjectWidget.
  *
  * @param x The x-coordinate to be set.
  */
 void UMLWidget::setX(qreal x)
 {
     QGraphicsObject::setX(x);
 }
 
 /**
  * Sets the y-coordinate.
  * Currently, the only class that reimplements this method is
  * ObjectWidget.
  *
  * @param y The y-coordinate to be set.
  */
 void UMLWidget::setY(qreal y)
 {
     QGraphicsObject::setY(y);
 }
 
 /**
  * Used to cleanup any other widget it may need to delete.
  * Used by child classes.  This should be called before deleting a widget of a diagram.
  */
 void UMLWidget::cleanup()
 {
 }
 
 /**
  * Tells the widget to snap to grid.
  * Will use the grid settings of the @ref UMLView it belongs to.
  */
 void UMLWidget::slotSnapToGrid()
 {
     if (!m_ignoreSnapToGrid) {
         qreal newX = m_scene->snappedX(x());
         setX(newX);
         qreal newY = m_scene->snappedY(y());
         setY(newY);
     }
 }
 
 /**
  * Returns whether the widget type has an associated UMLObject
  */
 bool UMLWidget::widgetHasUMLObject(WidgetBase::WidgetType type)
 {
     if (type == WidgetBase::wt_Actor         ||
             type == WidgetBase::wt_UseCase   ||
             type == WidgetBase::wt_Class     ||
             type == WidgetBase::wt_Interface ||
             type == WidgetBase::wt_Enum      ||
             type == WidgetBase::wt_Datatype  ||
             type == WidgetBase::wt_Package   ||
             type == WidgetBase::wt_Component ||
             type == WidgetBase::wt_Port ||
             type == WidgetBase::wt_Node      ||
             type == WidgetBase::wt_Artifact  ||
             type == WidgetBase::wt_Object) {
         return true;
     } else {
         return false;
     }
 }
 
 /**
  * Set m_ignoreSnapToGrid.
  */
 void UMLWidget::setIgnoreSnapToGrid(bool to)
 {
     m_ignoreSnapToGrid = to;
 }
 
 /**
  * Return the value of m_ignoreSnapToGrid.
  */
 bool UMLWidget::getIgnoreSnapToGrid() const
 {
     return m_ignoreSnapToGrid;
 }
 
 /**
  * Sets the size.
  * If m_scene->snapComponentSizeToGrid() is true, then
  * set the next larger size that snaps to the grid.
  */
 void UMLWidget::setSize(qreal width, qreal height)
 {
     // snap to the next larger size that is a multiple of the grid
     if (!m_ignoreSnapComponentSizeToGrid
             && m_scene->snapComponentSizeToGrid()) {
         // integer divisions
         int numX = width / m_scene->snapX();
         int numY = height / m_scene->snapY();
         // snap to the next larger valid value
         if (width > numX * m_scene->snapX())
             width = (numX + 1) * m_scene->snapX();
         if (height > numY * m_scene->snapY())
             height = (numY + 1) * m_scene->snapY();
     }
 
     const QRectF newRect(rect().x(), rect().y(), width, height);
     setRect(newRect);
     foreach(QGraphicsItem* child, childItems()) {
         UMLWidget* umlChild = static_cast<UMLWidget*>(child);
         umlChild->notifyParentResize();
     }
 }
 
 /**
  * Sets the size with another size.
  */
 void UMLWidget::setSize(const QSizeF& size)
 {
     setSize(size.width(), size.height());
 }
 
 /**
  * Update the size of this widget.
  *
  * @param withAssocs true - update associations too
  */
 void UMLWidget::updateGeometry(bool withAssocs)
 {
     if (m_doc->loading()) {
         return;
     }
     if (!m_autoResize)
         return;
     qreal oldW = width();
     qreal oldH = height();
     QSizeF size = calculateSize();
     qreal clipWidth = size.width();
     qreal clipHeight = size.height();
     constrain(clipWidth, clipHeight);
     setSize(clipWidth, clipHeight);
     slotSnapToGrid();
     if (withAssocs)
         adjustAssocs(size.width()-oldW, size.height()-oldH);
     update();
 }
 
 /**
  * clip the size of this widget against the
  * minimal and maximal limits.
  */
 void UMLWidget::clipSize()
 {
     qreal clipWidth = width();
     qreal clipHeight = height();
     constrain(clipWidth, clipHeight);
     setSize(clipWidth, clipHeight);
 }
 
 /**
  * Template Method, override this to set the default font metric.
  */
 void UMLWidget::setDefaultFontMetrics(QFont &font, UMLWidget::FontType fontType)
 {
     setupFontType(font, fontType);
     setFontMetrics(fontType, QFontMetrics(font));
 }
 
 void UMLWidget::setupFontType(QFont &font, UMLWidget::FontType fontType)
 {
     switch (fontType) {
     case FT_NORMAL:
         font.setBold(false);
         font.setItalic(false);
         font.setUnderline(false);
         break;
     case FT_BOLD:
         font.setBold(true);
         font.setItalic(false);
         font.setUnderline(false);
         break;
     case FT_ITALIC:
         font.setBold(false);
         font.setItalic(true);
         font.setUnderline(false);
         break;
     case FT_UNDERLINE:
         font.setBold(false);
         font.setItalic(false);
         font.setUnderline(true);
         break;
     case FT_BOLD_ITALIC:
         font.setBold(true);
         font.setItalic(true);
         font.setUnderline(false);
         break;
     case FT_BOLD_UNDERLINE:
         font.setBold(true);
         font.setItalic(false);
         font.setUnderline(true);
         break;
     case FT_ITALIC_UNDERLINE:
         font.setBold(false);
         font.setItalic(true);
         font.setUnderline(true);
         break;
     case FT_BOLD_ITALIC_UNDERLINE:
         font.setBold(true);
         font.setItalic(true);
         font.setUnderline(true);
         break;
     default: return;
     }
 }
 
 void UMLWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
     Q_UNUSED(option);
     Q_UNUSED(widget);
 
     if (option->state & QStyle::State_Selected) {
         const qreal w = width();
         const qreal h = height();
         const qreal s = selectionMarkerSize;
         QBrush brush(Qt::blue);
         painter->fillRect(0, 0, s,  s, brush);
         painter->fillRect(0, 0 + h - s, s, s, brush);
         painter->fillRect(0 + w - s, 0, s, s, brush);
 
         // Draw the resize anchor in the lower right corner.
         // Don't draw it if the widget is so small that the
         // resize anchor would cover up most of the widget.
         if (m_resizable && w >= s+8 && h >= s+8) {
             brush.setColor(Qt::red);
             const int right = 0 + w;
             const int bottom = 0 + h;
             painter->drawLine(right - s, 0 + h - 1, 0 + w - 1, 0 + h - s);
             painter->drawLine(right - (s*2), bottom - 1, right - 1, bottom - (s*2));
             painter->drawLine(right - (s*3), bottom - 1, right - 1, bottom - (s*3));
         } else {
             painter->fillRect(0 + w - s, 0 + h - s, s, s, brush);
         }
         // debug info
         if (Tracer::instance()->isEnabled(QLatin1String(metaObject()->className()))) {
             painter->setPen(Qt::green);
             painter->setBrush(Qt::NoBrush);
             painter->drawPath(shape());
             painter->setPen(Qt::blue);
             painter->drawRect(boundingRect());
             // origin
             painter->drawLine(-10, 0, 10, 0);
             painter->drawLine(0, -10, 0, 10);
         }
     }
 
     if (umlScene()->isShowDocumentationIndicator() && hasDocumentation()) {
         const qreal h = height();
         const qreal d = 8;
         QPolygonF p;
         p << QPointF(0, h - d) << QPointF(d, h) << QPointF(0, h);
         painter->setPen(Qt::blue);
         painter->setBrush(Qt::red);
         painter->drawPolygon(p);
     }
 }
 
 /**
  * Template Method, override this to set the default font metric.
  */
 void UMLWidget::setDefaultFontMetrics(QFont &font, UMLWidget::FontType fontType, QPainter &painter)
 {
     setupFontType(font, fontType);
     painter.setFont(font);
     setFontMetrics(fontType, painter.fontMetrics());
 }
 
 /**
  * Returns the font metric used by this object for Text
  * which uses bold/italic fonts.
  */
 QFontMetrics &UMLWidget::getFontMetrics(UMLWidget::FontType fontType) const
 {
     return *m_pFontMetrics[fontType];
 }
 
 /**
  * Set the font metric to use.
  */
 void UMLWidget::setFontMetrics(UMLWidget::FontType fontType, QFontMetrics fm)
 {
     delete m_pFontMetrics[fontType];
     m_pFontMetrics[fontType] = new QFontMetrics(fm);
 }
 
 /**
  * Sets the font the widget is to use.
  *
  * @param font Font to be set.
  */
 void UMLWidget::setFont(const QFont &font)
 {
     QFont newFont = font;
     forceUpdateFontMetrics(newFont, 0);
 
     if (m_font != newFont) {
         UMLApp::app()->executeCommand(new CmdChangeFont(this, font));
     }
 }
 
 /**
  * Sets the font the widget is to use.
  *
  * @param font Font to be set.
  */
 void UMLWidget::setFontCmd(const QFont &font)
 {
     WidgetBase::setFont(font);
     forceUpdateFontMetrics(0);
     if (m_doc->loading())
         return;
     update();
 }
 
 /**
  * Updates font metrics for widgets current m_font
  */
 void UMLWidget::forceUpdateFontMetrics(QPainter *painter)
 {
     forceUpdateFontMetrics(m_font, painter);
 }
 
 /**
  * @note For performance Reasons, only FontMetrics for already used
  *  font types are updated. Not yet used font types will not get a font metric
  *  and will get the same font metric as if painter was zero.
  *  This behaviour is acceptable, because diagrams will always be shown on Display
  *  first before a special painter like a printer device is used.
  */
 void UMLWidget::forceUpdateFontMetrics(QFont& font, QPainter *painter)
 {
     if (painter == 0) {
         for (int i = (int)FT_INVALID - 1; i >= 0; --i) {
             if (m_pFontMetrics[(UMLWidget::FontType)i] != 0)
                 setDefaultFontMetrics(font, (UMLWidget::FontType)i);
         }
     } else {
         for (int i2 = (int)FT_INVALID - 1; i2 >= 0; --i2) {
             if (m_pFontMetrics[(UMLWidget::FontType)i2] != 0)
                 setDefaultFontMetrics(font, (UMLWidget::FontType)i2, *painter);
         }
     }
     if (m_doc->loading())
         return;
     // calculate the size, based on the new font metric
     updateGeometry();
 }
 
 /**
  * Set the status of whether to show Stereotype.
  *
  * @param flag   True if stereotype shall be shown.
  */
 void UMLWidget::setShowStereotype(bool flag)
 {
     m_showStereotype = flag;
     updateGeometry();
     update();
 }
 
 /**
  * Returns the status of whether to show Stereotype.
  *
  * @return  True if stereotype is shown.
  */
 bool UMLWidget::showStereotype() const
 {
     return m_showStereotype;
 }
 
 /**
  * Overrides the standard operation.
  *
  * @param me The move event.
  */
 void UMLWidget::moveEvent(QGraphicsSceneMouseEvent* me)
 {
   Q_UNUSED(me)
 }
 
 void UMLWidget::saveToXMI1(QDomDocument & qDoc, QDomElement & qElement)
 {
     /*
       Call after required actions in child class.
       Type must be set in the child class.
     */
     WidgetBase::saveToXMI1(qDoc, qElement);
     qElement.setAttribute(QLatin1String("xmi.id"), Uml::ID::toString(id()));
 
     qreal dpiScale = UMLApp::app()->document()->dpiScale();
     qElement.setAttribute(QLatin1String("x"), QString::number(x() / dpiScale));
     qElement.setAttribute(QLatin1String("y"), QString::number(y() / dpiScale));
     qElement.setAttribute(QLatin1String("width"), QString::number(width() / dpiScale));
     qElement.setAttribute(QLatin1String("height"), QString::number(height() / dpiScale));
 
     qElement.setAttribute(QLatin1String("isinstance"), m_isInstance);
     if (!m_instanceName.isEmpty())
         qElement.setAttribute(QLatin1String("instancename"), m_instanceName);
     if (m_showStereotype)
         qElement.setAttribute(QLatin1String("showstereotype"), m_showStereotype);
 
     // Unique identifier for widget (todo: id() should be unique, new attribute
     // should indicate the UMLObject's ID it belongs to)
     qElement.setAttribute(QLatin1String("localid"), Uml::ID::toString(m_nLocalID));
 }
 
 bool UMLWidget::loadFromXMI1(QDomElement & qElement)
 {
     QString id = qElement.attribute(QLatin1String("xmi.id"), QLatin1String("-1"));
     m_nId = Uml::ID::fromString(id);
 
     WidgetBase::loadFromXMI1(qElement);
     QString x = qElement.attribute(QLatin1String("x"), QLatin1String("0"));
     QString y = qElement.attribute(QLatin1String("y"), QLatin1String("0"));
     QString h = qElement.attribute(QLatin1String("height"), QLatin1String("0"));
     QString w = qElement.attribute(QLatin1String("width"), QLatin1String("0"));
     qreal dpiScale = UMLApp::app()->document()->dpiScale();
     setSize(toDoubleFromAnyLocale(w) * dpiScale,
             toDoubleFromAnyLocale(h) * dpiScale);
     setX(toDoubleFromAnyLocale(x) * dpiScale);
     setY(toDoubleFromAnyLocale(y) * dpiScale);
 
     QString isinstance = qElement.attribute(QLatin1String("isinstance"), QLatin1String("0"));
     m_isInstance = (bool)isinstance.toInt();
     m_instanceName = qElement.attribute(QLatin1String("instancename"));
     QString showstereo = qElement.attribute(QLatin1String("showstereotype"), QLatin1String("0"));
     m_showStereotype = (bool)showstereo.toInt();
 
     QString localid = qElement.attribute(QLatin1String("localid"), QLatin1String("0"));
     if (localid != QLatin1String("0")) {
         m_nLocalID = Uml::ID::fromString(localid);
     }
 
     return true;
 }
 
 /**
  * Adds a widget to the diagram, which is connected to the current widget
  * @param widget widget instance to add to diagram
  * @param type association type
  * @param options widget options
  */
 void UMLWidget::addConnectedWidget(UMLWidget *widget, Uml::AssociationType::Enum type, AddWidgetOptions options)
 {
     umlScene()->addItem(widget);
     widget->setX(x() + rect().width() + 100);
     widget->setY(y());
     if (options & SetupSize) {
         widget->setSize(100, 40);
         QSizeF size = widget->minimumSize();
         widget->setSize(size);
     }
     AssociationWidget* assoc = options & SwitchDirection ? AssociationWidget::create(umlScene(), widget, type, this)
                                                     : AssociationWidget::create(umlScene(), this, type, widget);
     umlScene()->addAssociation(assoc);
     umlScene()->clearSelected();
     umlScene()->selectWidget(widget);
     if (options & ShowProperties)
         widget->showPropertiesDialog();
 }
 
 /**
  * Adds a widget to the diagram, which is connected to the current widget
  * @param widget widget instance to add to diagram
  * @param showProperties whether to show properties of the widget
  */
 void UMLWidget::addWidget(UMLWidget *widget, bool showProperties)
 {
     umlScene()->addItem(widget);
     widget->setX(x() + rect().width() + 100);
     widget->setY(y());
     widget->setSize(100, 40);
     if (showProperties)
         widget->showPropertiesDialog();
     QSizeF size = widget->minimumSize();
     widget->setSize(size);
 }