toolbarstate.cpp

Go to the documentation of this file.

/***************************************************************************
 *   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) 2004-2013                                               *
 *   Umbrello UML Modeller Authors <umbrello-devel@kde.org>                *
 ***************************************************************************/

// own header
#include "toolbarstate.h"

// app includes
#include "associationwidget.h"
#include "debug_utils.h"
#include "messagewidget.h"
#include "floatingdashlinewidget.h"
#include "objectwidget.h"
#include "uml.h"
#include "umlview.h"
#include "umlwidget.h"

// qt includes
#include <QWMatrix> // need for inverseWorldMatrix.map
#include <QScrollBar>

ToolBarState::~ToolBarState()
{
    delete m_pMouseEvent;
}

void ToolBarState::init()
{
    m_pUMLScene->activeView()->viewport()->setMouseTracking(false);
    m_pMouseEvent = 0;
    m_currentWidget = 0;
    m_currentAssociation = 0;

    connect(m_pUMLScene, SIGNAL(sigAssociationRemoved(AssociationWidget*)),
            this, SLOT(slotAssociationRemoved(AssociationWidget*)));
    connect(m_pUMLScene, SIGNAL(sigWidgetRemoved(UMLWidget*)),
            this, SLOT(slotWidgetRemoved(UMLWidget*)));
}

void ToolBarState::cleanBeforeChange()
{
    disconnect(m_pUMLScene, SIGNAL(sigAssociationRemoved(AssociationWidget*)),
               this, SLOT(slotAssociationRemoved(AssociationWidget*)));
    disconnect(m_pUMLScene, SIGNAL(sigWidgetRemoved(UMLWidget*)),
               this, SLOT(slotWidgetRemoved(UMLWidget*)));
}

void ToolBarState::mousePress(QGraphicsSceneMouseEvent* ome)
{
    setMouseEvent(ome, QEvent::MouseButtonPress);

    m_pUMLScene->activeView()->viewport()->setMouseTracking(true);

    // TODO: Check who needs this.
    m_pUMLScene->setPos(m_pMouseEvent->scenePos());

    //TODO check why
    m_pUMLScene->setPaste(false);

    setCurrentElement();

    if (currentWidget()) {
        mousePressWidget();
    } else if (currentAssociation()) {
        mousePressAssociation();
    } else {
        mousePressEmpty();
    }
}

void ToolBarState::mouseRelease(QGraphicsSceneMouseEvent* ome)
{
    setMouseEvent(ome, QEvent::MouseButtonRelease);

    // Set the position of the mouse
    // TODO, should only be available in this state?
    m_pUMLScene->setPos(m_pMouseEvent->scenePos());

    m_pUMLScene->activeView()->viewport()->setMouseTracking(false);

    if (currentWidget()) {
        mouseReleaseWidget();
        setCurrentWidget(0);
    } else if (currentAssociation()) {
        mouseReleaseAssociation();
        setCurrentAssociation(0);
    } else {
        mouseReleaseEmpty();
    }

    // Default, rightbutton changes the tool.
    // The arrow tool overrides the changeTool() function.
    changeTool();
}

void ToolBarState::mouseDoubleClick(QGraphicsSceneMouseEvent* ome)
{
    setMouseEvent(ome, QEvent::MouseButtonDblClick);

    UMLWidget* currentWidget = m_pUMLScene->widgetAt(m_pMouseEvent->scenePos());
    AssociationWidget* currentAssociation = associationAt(m_pMouseEvent->scenePos());
    if (currentWidget) {
        setCurrentWidget(currentWidget);
        mouseDoubleClickWidget();
        setCurrentWidget(0);
    } else if (currentAssociation) {
        setCurrentAssociation(currentAssociation);
        mouseDoubleClickAssociation();
        setCurrentAssociation(0);
    } else {
        mouseDoubleClickEmpty();
    }
}

void ToolBarState::mouseMove(QGraphicsSceneMouseEvent* ome)
{
    setMouseEvent(ome, QEvent::MouseMove);

    if (currentWidget()) {
        mouseMoveWidget();
    } else if (currentAssociation()) {
        mouseMoveAssociation();
    } else {
        mouseMoveEmpty();
    }
#if 0
    // scrolls the view
    static int mouseCount = 0;
    int vx = ome->scenePos().x();
    int vy = ome->scenePos().y();
    UMLView* view = m_pUMLScene->activeView();
//    QRectF maxArea = view->sceneRect();
    QRectF visibleArea = view->mapToScene(view->rect()).boundingRect();
    int dtr = visibleArea.x() + visibleArea.width() - vx;   // delta right
    int dtb = visibleArea.y() + visibleArea.height() - vy;  // delta bottom
    int dtt = vy - visibleArea.y();        // delta top
    int dtl = vx - visibleArea.x();        // delta left
//    uDebug() << "mouse [x, y] = [ " << vx << ", " << vy << "] / "
//             << "visibleArea [x, y, w, h] = [ " << visibleArea.x() << ", " << visibleArea.y() << ", " << visibleArea.width() << ", " << visibleArea.height() << "] / "
//             << "maxArea [x, y, w, h] = [ " << maxArea.x() << ", " << maxArea.y() << ", " << maxArea.width() << ", " << maxArea.height() << "] / "
//             << "delta right=" << dtr << ", bottom=" << dtb << ", top=" << dtt << ", left=" << dtl;
    if (dtr < 30) { uDebug() << "translate RIGHT";  view->ensureVisible(vx, vy, 0.1 /*30-dtr*/, 0, 2, 2); }
    if (dtb < 30) {
        mouseCount++;
        uDebug() << "translate BOTTOM " << mouseCount;
//        view->ensureVisible(vx, vy, 0, 0.1 /*30-dtb*/, 2,  2);
        if (mouseCount > 30) {
            view->verticalScrollBar()->triggerAction(QAbstractSlider::SliderSingleStepAdd);
            mouseCount = 0;
        }
    }
    if (dtl < 30) { uDebug() << "translate LEFT";   view->ensureVisible(vx, vy, -0.1 /*-(30-dtl)*/, 0, 2, 2); }
    if (dtt < 30) { uDebug() << "translate TOP";    view->ensureVisible(vx, vy, 0, -0.1 /*-(30-dtt)*/, 2, 2); }
#endif
}

void ToolBarState::slotAssociationRemoved(AssociationWidget* association)
{
    if (association == currentAssociation()) {
        setCurrentAssociation(0);
    }
}

void ToolBarState::slotWidgetRemoved(UMLWidget* widget)
{
    if (widget == currentWidget()) {
        setCurrentWidget(0);
    }
}

ToolBarState::ToolBarState(UMLScene *umlScene)
  : QObject(umlScene),
    m_pUMLScene(umlScene),
    m_pMouseEvent(0)
{
    init();
}

void ToolBarState::setCurrentElement()
{
    // Check associations.
    AssociationWidget* association = associationAt(m_pMouseEvent->scenePos());
    if (association) {
        setCurrentAssociation(association);
        return;
    }

    // Check messages.
    //TODO check why message widgets are treated different
    MessageWidget* message = messageAt(m_pMouseEvent->scenePos());
    if (message) {
        setCurrentWidget(message);
        return;
    }

    //TODO check why message widgets are treated different
    FloatingDashLineWidget* floatingline = floatingLineAt(m_pMouseEvent->scenePos());
    if (floatingline) {
        setCurrentWidget(floatingline);
        return;
    }

    ObjectWidget* objectWidgetLine = m_pUMLScene->onWidgetDestructionBox(m_pMouseEvent->scenePos());
    if (objectWidgetLine) {
        setCurrentWidget(objectWidgetLine);
        return;
    }

    // Check widgets.
    UMLWidget *widget = m_pUMLScene->widgetAt(m_pMouseEvent->scenePos());
    if (widget) {
        setCurrentWidget(widget);
        return;
    }
}

void ToolBarState::mousePressAssociation()
{
}

void ToolBarState::mousePressWidget()
{
}

void ToolBarState::mousePressEmpty()
{
    // TODO activate when QGraphicsScene selection handling is used
    //m_pUMLScene->clearSelection();
    m_pUMLScene->clearSelected();
}

void ToolBarState::mouseReleaseAssociation()
{
}

void ToolBarState::mouseReleaseWidget()
{
}

void ToolBarState::mouseReleaseEmpty()
{
}

void ToolBarState::mouseDoubleClickAssociation()
{
}

void ToolBarState::mouseDoubleClickWidget()
{
}

void ToolBarState::mouseDoubleClickEmpty()
{
    // TODO activate when QGraphicsScene selection handling is used
    //m_pUMLScene->clearSelection();
    m_pUMLScene->clearSelected();
}

void ToolBarState::mouseMoveAssociation()
{
}

void ToolBarState::mouseMoveWidget()
{
}

void ToolBarState::mouseMoveEmpty()
{
}

void ToolBarState::changeTool()
{
    if (m_pMouseEvent->buttons() == Qt::RightButton) {
        UMLApp::app()->workToolBar()->setDefaultTool();
    }
}

UMLWidget* ToolBarState::currentWidget() const
{
    return m_currentWidget;
}

void ToolBarState::setCurrentWidget(UMLWidget* widget)
{
    m_currentWidget = widget;
}

AssociationWidget* ToolBarState::currentAssociation() const
{
    return m_currentAssociation;
}

void ToolBarState::setCurrentAssociation(AssociationWidget* association)
{
    m_currentAssociation = association;
}

void ToolBarState::setMouseEvent(QGraphicsSceneMouseEvent* ome, const QEvent::Type &type)
{
    delete m_pMouseEvent;

    //:TODO: uDebug() << "[PORT] Check if scenePos works like view->inverseWorldMatrix().map()";
    // Using copy constructor here.
    m_pMouseEvent = new QGraphicsSceneMouseEvent(type);
    m_pMouseEvent->setPos(ome->pos());
    m_pMouseEvent->setScenePos(ome->scenePos());
    m_pMouseEvent->setScreenPos(ome->screenPos());
    m_pMouseEvent->setLastPos(ome->lastPos());
    m_pMouseEvent->setLastScenePos(ome->lastScenePos());
    m_pMouseEvent->setLastScreenPos(ome->lastScreenPos());
    m_pMouseEvent->setButtons(ome->buttons());
    m_pMouseEvent->setButton(ome->button());
    m_pMouseEvent->setModifiers(ome->modifiers());
}

MessageWidget* ToolBarState::messageAt(const QPointF& pos)
{
    foreach (MessageWidget* message, m_pUMLScene->messageList()) {
        if (message->isVisible() && message->onWidget(pos)) {
            return message;
        }
    }
    return 0;
}

AssociationWidget* ToolBarState::associationAt(const QPointF& pos)
{
    foreach (AssociationWidget* association, m_pUMLScene->associationList()) {
        if (association->onAssociation(pos)) {
            return association;
        }
    }
    return 0;
}

FloatingDashLineWidget* ToolBarState::floatingLineAt(const QPointF& pos)
{
    FloatingDashLineWidget* floatingline = 0;

    foreach (UMLWidget* widget, m_pUMLScene->widgetList()) {
        if (widget->baseType() == WidgetBase::wt_FloatingDashLine){
            if (dynamic_cast<FloatingDashLineWidget*>(widget)->onLine(pos)) {
                floatingline = dynamic_cast<FloatingDashLineWidget*>(widget);
            }
        }
    }

    return floatingline;
}

#include "toolbarstate.moc"