**
****************************************************************************/
-#include "sgabstracttool.h"
+#include "abstracttool.h"
-#include "sgviewinspector.h"
+#include "abstractviewinspector.h"
namespace QmlJSDebugger {
-SGAbstractTool::SGAbstractTool(SGViewInspector *inspector) :
+AbstractTool::AbstractTool(AbstractViewInspector *inspector) :
QObject(inspector),
m_inspector(inspector)
{
**
****************************************************************************/
-#ifndef SGABSTRACTTOOL_H
-#define SGABSTRACTTOOL_H
+#ifndef ABSTRACTTOOL_H
+#define ABSTRACTTOOL_H
#include <QtCore/QObject>
namespace QmlJSDebugger {
-class SGViewInspector;
+class AbstractViewInspector;
-class SGAbstractTool : public QObject
+class AbstractTool : public QObject
{
Q_OBJECT
public:
- explicit SGAbstractTool(SGViewInspector *inspector);
+ explicit AbstractTool(AbstractViewInspector *inspector);
- SGViewInspector *inspector() const { return m_inspector; }
+ AbstractViewInspector *inspector() const { return m_inspector; }
virtual void leaveEvent(QEvent *event) = 0;
virtual void keyReleaseEvent(QKeyEvent *keyEvent) = 0;
private:
- SGViewInspector *m_inspector;
+ AbstractViewInspector *m_inspector;
};
} // namespace QmlJSDebugger
-#endif // SGABSTRACTTOOL_H
+#endif // ABSTRACTTOOL_H
#include "abstractviewinspector.h"
+#include "abstracttool.h"
#include "editor/qmltoolbar.h"
#include "qdeclarativeinspectorprotocol.h"
#include "QtDeclarative/private/qdeclarativeinspectorservice_p.h"
#include <QtGui/QVBoxLayout>
+#include <QtGui/QMouseEvent>
#include <QtCore/QSettings>
static inline void initEditorResource() { Q_INIT_RESOURCE(editor); }
AbstractViewInspector::AbstractViewInspector(QObject *parent) :
QObject(parent),
m_toolBox(0),
+ m_currentTool(0),
m_showAppOnTop(false),
m_designModeBehavior(false),
m_animationPaused(false),
changeTool(InspectorProtocol::SelectMarqueeTool);
}
+bool AbstractViewInspector::eventFilter(QObject *obj, QEvent *event)
+{
+ if (!designModeBehavior())
+ return QObject::eventFilter(obj, event);
+
+ switch (event->type()) {
+ case QEvent::Leave:
+ if (leaveEvent(event))
+ return true;
+ break;
+ case QEvent::MouseButtonPress:
+ if (mousePressEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ case QEvent::MouseMove:
+ if (mouseMoveEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ case QEvent::MouseButtonRelease:
+ if (mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ case QEvent::KeyPress:
+ if (keyPressEvent(static_cast<QKeyEvent*>(event)))
+ return true;
+ break;
+ case QEvent::KeyRelease:
+ if (keyReleaseEvent(static_cast<QKeyEvent*>(event)))
+ return true;
+ break;
+ case QEvent::MouseButtonDblClick:
+ if (mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)))
+ return true;
+ break;
+ case QEvent::Wheel:
+ if (wheelEvent(static_cast<QWheelEvent*>(event)))
+ return true;
+ break;
+ default:
+ break;
+ }
+
+ return QObject::eventFilter(obj, event);
+}
+
+bool AbstractViewInspector::leaveEvent(QEvent *event)
+{
+ m_currentTool->leaveEvent(event);
+ return true;
+}
+
+bool AbstractViewInspector::mousePressEvent(QMouseEvent *event)
+{
+ m_currentTool->mousePressEvent(event);
+ return true;
+}
+
+bool AbstractViewInspector::mouseMoveEvent(QMouseEvent *event)
+{
+ if (event->buttons()) {
+ m_currentTool->mouseMoveEvent(event);
+ } else {
+ m_currentTool->hoverMoveEvent(event);
+ }
+ return true;
+}
+
+bool AbstractViewInspector::mouseReleaseEvent(QMouseEvent *event)
+{
+ m_currentTool->mouseReleaseEvent(event);
+ return true;
+}
+
+bool AbstractViewInspector::keyPressEvent(QKeyEvent *event)
+{
+ m_currentTool->keyPressEvent(event);
+ return true;
+}
+
+bool AbstractViewInspector::keyReleaseEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_V:
+ changeTool(InspectorProtocol::SelectTool);
+ break;
+// disabled because multiselection does not do anything useful without design mode
+// case Qt::Key_M:
+// changeTool(InspectorProtocol::SelectMarqueeTool);
+// break;
+ case Qt::Key_I:
+ changeTool(InspectorProtocol::ColorPickerTool);
+ break;
+ case Qt::Key_Z:
+ changeTool(InspectorProtocol::ZoomTool);
+ break;
+ case Qt::Key_Space:
+ setAnimationPaused(!animationPaused());
+ break;
+ default:
+ break;
+ }
+
+ m_currentTool->keyReleaseEvent(event);
+ return true;
+}
+
+bool AbstractViewInspector::mouseDoubleClickEvent(QMouseEvent *event)
+{
+ m_currentTool->mouseDoubleClickEvent(event);
+ return true;
+}
+
+bool AbstractViewInspector::wheelEvent(QWheelEvent *event)
+{
+ m_currentTool->wheelEvent(event);
+ return true;
+}
+
void AbstractViewInspector::handleMessage(const QByteArray &message)
{
QDataStream ds(message);
QT_BEGIN_NAMESPACE
class QDeclarativeEngine;
class QDeclarativeInspectorService;
+class QKeyEvent;
+class QMouseEvent;
+class QWheelEvent;
QT_END_NAMESPACE
namespace QmlJSDebugger {
+class AbstractTool;
class ToolBox;
/*
void animationSpeedChanged(qreal factor);
void animationPausedChanged(bool paused);
+protected:
+ bool eventFilter(QObject *, QEvent *);
+
+ virtual bool leaveEvent(QEvent *);
+ virtual bool mousePressEvent(QMouseEvent *event);
+ virtual bool mouseMoveEvent(QMouseEvent *event);
+ virtual bool mouseReleaseEvent(QMouseEvent *event);
+ virtual bool keyPressEvent(QKeyEvent *event);
+ virtual bool keyReleaseEvent(QKeyEvent *keyEvent);
+ virtual bool mouseDoubleClickEvent(QMouseEvent *event);
+ virtual bool wheelEvent(QWheelEvent *event);
+
+ AbstractTool *currentTool() const { return m_currentTool; }
+ void setCurrentTool(AbstractTool *tool) { m_currentTool = tool; }
+
private slots:
void handleMessage(const QByteArray &message);
void createToolBox();
ToolBox *m_toolBox;
+ AbstractTool *m_currentTool;
bool m_showAppOnTop;
bool m_designModeBehavior;
namespace QmlJSDebugger {
AbstractLiveEditTool::AbstractLiveEditTool(QDeclarativeViewInspector *editorView)
- : QObject(editorView), m_inspector(editorView)
+ : AbstractTool(editorView)
{
}
QDeclarativeViewInspector *AbstractLiveEditTool::inspector() const
{
- return m_inspector;
+ return static_cast<QDeclarativeViewInspector*>(AbstractTool::inspector());
}
QDeclarativeView *AbstractLiveEditTool::view() const
{
- return m_inspector->declarativeView();
+ return inspector()->declarativeView();
}
QGraphicsScene* AbstractLiveEditTool::scene() const
QDeclarativeItem *declarativeItem = qobject_cast<QDeclarativeItem*>(gfxObject);
if (declarativeItem) {
- objectStringId = m_inspector->idStringForObject(declarativeItem);
+ objectStringId = inspector()->idStringForObject(declarativeItem);
}
if (!objectStringId.isEmpty()) {
#define ABSTRACTLIVEEDITTOOL_H
#include <QtCore/QList>
-#include <QtCore/QObject>
+#include "../abstracttool.h"
QT_BEGIN_NAMESPACE
class QMouseEvent;
class QDeclarativeViewInspector;
-class AbstractLiveEditTool : public QObject
+class AbstractLiveEditTool : public AbstractTool
{
Q_OBJECT
public:
virtual ~AbstractLiveEditTool();
- virtual void mousePressEvent(QMouseEvent *event) = 0;
- virtual void mouseMoveEvent(QMouseEvent *event) = 0;
- virtual void mouseReleaseEvent(QMouseEvent *event) = 0;
- virtual void mouseDoubleClickEvent(QMouseEvent *event) = 0;
+ void leaveEvent(QEvent *) {}
- virtual void hoverMoveEvent(QMouseEvent *event) = 0;
- virtual void wheelEvent(QWheelEvent *event) = 0;
-
- virtual void keyPressEvent(QKeyEvent *event) = 0;
- virtual void keyReleaseEvent(QKeyEvent *keyEvent) = 0;
virtual void itemsAboutToRemoved(const QList<QGraphicsItem*> &itemList) = 0;
virtual void clear() = 0;
QGraphicsScene *scene() const;
private:
- QDeclarativeViewInspector *m_inspector;
QList<QGraphicsItem*> m_itemList;
};
#include "editor/boundingrecthighlighter.h"
#include <QtDeclarative/QDeclarativeItem>
-#include <QtDeclarative/QDeclarativeEngine>
-#include <QtDeclarative/QDeclarativeContext>
-#include <QtDeclarative/QDeclarativeExpression>
#include <QtGui/QWidget>
#include <QtGui/QMouseEvent>
#include <QtGui/QGraphicsObject>
-#include <QtGui/QApplication>
namespace QmlJSDebugger {
data->zoomTool = new ZoomTool(this);
data->colorPickerTool = new ColorPickerTool(this);
data->boundingRectHighlighter = new BoundingRectHighlighter(this);
- data->currentTool = data->selectionTool;
+ setCurrentTool(data->selectionTool);
// to capture ChildRemoved event when viewport changes
data->view->installEventFilter(this);
}
}
+AbstractLiveEditTool *QDeclarativeViewInspector::currentTool() const
+{
+ return static_cast<AbstractLiveEditTool*>(AbstractViewInspector::currentTool());
+}
+
QDeclarativeEngine *QDeclarativeViewInspector::declarativeEngine() const
{
return data->view->engine();
return QObject::eventFilter(obj, event);
}
- // Event from viewport
- switch (event->type()) {
- case QEvent::Leave: {
- if (leaveEvent(event))
- return true;
- break;
- }
- case QEvent::MouseButtonPress: {
- if (mousePressEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- }
- case QEvent::MouseMove: {
- if (mouseMoveEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- }
- case QEvent::MouseButtonRelease: {
- if (mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- }
- case QEvent::KeyPress: {
- if (keyPressEvent(static_cast<QKeyEvent*>(event)))
- return true;
- break;
- }
- case QEvent::KeyRelease: {
- if (keyReleaseEvent(static_cast<QKeyEvent*>(event)))
- return true;
- break;
- }
- case QEvent::MouseButtonDblClick: {
- if (mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- }
- case QEvent::Wheel: {
- if (wheelEvent(static_cast<QWheelEvent*>(event)))
- return true;
- break;
- }
- default: {
- break;
- }
- } //switch
-
- // standard event processing
- return QObject::eventFilter(obj, event);
+ return AbstractViewInspector::eventFilter(obj, event);
}
-bool QDeclarativeViewInspector::leaveEvent(QEvent * /*event*/)
+bool QDeclarativeViewInspector::leaveEvent(QEvent *event)
{
- if (!designModeBehavior())
- return false;
data->clearHighlight();
- return true;
+ return AbstractViewInspector::leaveEvent(event);
}
bool QDeclarativeViewInspector::mousePressEvent(QMouseEvent *event)
{
- if (!designModeBehavior())
- return false;
data->cursorPos = event->pos();
- data->currentTool->mousePressEvent(event);
- return true;
+ return AbstractViewInspector::mousePressEvent(event);
}
bool QDeclarativeViewInspector::mouseMoveEvent(QMouseEvent *event)
{
- if (!designModeBehavior()) {
- data->clearEditorItems();
- return false;
- }
data->cursorPos = event->pos();
QList<QGraphicsItem*> selItems = data->selectableItems(event->pos());
if (!selItems.isEmpty()) {
- declarativeView()->setToolTip(data->currentTool->titleForItem(selItems.first()));
+ declarativeView()->setToolTip(currentTool()->titleForItem(selItems.first()));
} else {
declarativeView()->setToolTip(QString());
}
- if (event->buttons()) {
- data->currentTool->mouseMoveEvent(event);
- } else {
- data->currentTool->hoverMoveEvent(event);
- }
- return true;
+
+ return AbstractViewInspector::mouseMoveEvent(event);
}
bool QDeclarativeViewInspector::mouseReleaseEvent(QMouseEvent *event)
{
- if (!designModeBehavior())
- return false;
-
data->cursorPos = event->pos();
- data->currentTool->mouseReleaseEvent(event);
- return true;
-}
-
-bool QDeclarativeViewInspector::keyPressEvent(QKeyEvent *event)
-{
- if (!designModeBehavior())
- return false;
-
- data->currentTool->keyPressEvent(event);
- return true;
-}
-
-bool QDeclarativeViewInspector::keyReleaseEvent(QKeyEvent *event)
-{
- if (!designModeBehavior())
- return false;
-
- switch (event->key()) {
- case Qt::Key_V:
- changeTool(InspectorProtocol::SelectTool);
- break;
-// disabled because multiselection does not do anything useful without design mode
-// case Qt::Key_M:
-// changeTool(InspectorProtocol::SelectMarqueeTool);
-// break;
- case Qt::Key_I:
- changeTool(InspectorProtocol::ColorPickerTool);
- break;
- case Qt::Key_Z:
- changeTool(InspectorProtocol::ZoomTool);
- break;
- case Qt::Key_Space:
- setAnimationPaused(!animationPaused());
- break;
- default:
- break;
- }
-
- data->currentTool->keyReleaseEvent(event);
- return true;
+ return AbstractViewInspector::mouseReleaseEvent(event);
}
void QDeclarativeViewInspector::reparentQmlObject(QObject *object, QObject *newParent)
setSelectedItems(items);
}
-bool QDeclarativeViewInspector::mouseDoubleClickEvent(QMouseEvent * /*event*/)
-{
- if (!designModeBehavior())
- return false;
-
- return true;
-}
-
-bool QDeclarativeViewInspector::wheelEvent(QWheelEvent *event)
-{
- if (!designModeBehavior())
- return false;
- data->currentTool->wheelEvent(event);
- return true;
-}
-
void QDeclarativeViewInspectorPrivate::setSelectedItemsForTools(const QList<QGraphicsItem *> &items)
{
foreach (const QWeakPointer<QGraphicsObject> &obj, currentSelection) {
}
}
- currentTool->updateSelectedItems();
+ q->currentTool()->updateSelectedItems();
}
void QDeclarativeViewInspectorPrivate::setSelectedItems(const QList<QGraphicsItem *> &items)
void QDeclarativeViewInspectorPrivate::changeToSingleSelectTool()
{
- currentToolMode = Constants::SelectionToolMode;
selectionTool->setRubberbandSelectionMode(false);
changeToSelectTool();
void QDeclarativeViewInspectorPrivate::changeToSelectTool()
{
- if (currentTool == selectionTool)
+ if (q->currentTool() == selectionTool)
return;
- currentTool->clear();
- currentTool = selectionTool;
- currentTool->clear();
- currentTool->updateSelectedItems();
+ q->currentTool()->clear();
+ q->setCurrentTool(selectionTool);
+ q->currentTool()->clear();
+ q->currentTool()->updateSelectedItems();
}
void QDeclarativeViewInspectorPrivate::changeToMarqueeSelectTool()
{
changeToSelectTool();
- currentToolMode = Constants::MarqueeSelectionToolMode;
selectionTool->setRubberbandSelectionMode(true);
emit q->marqueeSelectToolActivated();
void QDeclarativeViewInspectorPrivate::changeToZoomTool()
{
- currentToolMode = Constants::ZoomMode;
- currentTool->clear();
- currentTool = zoomTool;
- currentTool->clear();
+ q->currentTool()->clear();
+ q->setCurrentTool(zoomTool);
+ q->currentTool()->clear();
emit q->zoomToolActivated();
q->sendCurrentTool(Constants::ZoomMode);
void QDeclarativeViewInspectorPrivate::changeToColorPickerTool()
{
- if (currentTool == colorPickerTool)
+ if (q->currentTool() == colorPickerTool)
return;
- currentToolMode = Constants::ColorPickerMode;
- currentTool->clear();
- currentTool = colorPickerTool;
- currentTool->clear();
+ q->currentTool()->clear();
+ q->setCurrentTool(colorPickerTool);
+ q->currentTool()->clear();
emit q->colorPickerActivated();
q->sendCurrentTool(Constants::ColorPickerMode);
#include <QtCore/QScopedPointer>
#include <QtDeclarative/QDeclarativeView>
-QT_FORWARD_DECLARE_CLASS(QDeclarativeItem)
-QT_FORWARD_DECLARE_CLASS(QMouseEvent)
-QT_FORWARD_DECLARE_CLASS(QToolBar)
-
namespace QmlJSDebugger {
+class AbstractLiveEditTool;
class QDeclarativeViewInspectorPrivate;
class QDeclarativeViewInspector : public AbstractViewInspector
bool mousePressEvent(QMouseEvent *event);
bool mouseMoveEvent(QMouseEvent *event);
bool mouseReleaseEvent(QMouseEvent *event);
- bool keyPressEvent(QKeyEvent *event);
- bool keyReleaseEvent(QKeyEvent *keyEvent);
- bool mouseDoubleClickEvent(QMouseEvent *event);
- bool wheelEvent(QWheelEvent *event);
- void setSelectedItemsForTools(QList<QGraphicsItem *> items);
+ AbstractLiveEditTool *currentTool() const;
private:
Q_DISABLE_COPY(QDeclarativeViewInspector)
QPointF cursorPos;
QList<QWeakPointer<QGraphicsObject> > currentSelection;
- Constants::DesignTool currentToolMode;
- AbstractLiveEditTool *currentTool;
-
LiveSelectionTool *selectionTool;
ZoomTool *zoomTool;
ColorPickerTool *colorPickerTool;
editor/colorpickertool.cpp \
editor/qmltoolbar.cpp \
editor/toolbarcolorbox.cpp \
- sgabstracttool.cpp \
+ abstracttool.cpp \
sgviewinspector.cpp \
sgselectiontool.cpp
editor/colorpickertool.h \
editor/qmltoolbar.h \
editor/toolbarcolorbox.h \
- sgabstracttool.h \
+ abstracttool.h \
sgviewinspector.h \
sgselectiontool.h
SGSelectionTool::SGSelectionTool(SGViewInspector *inspector) :
- SGAbstractTool(inspector),
+ AbstractTool(inspector),
m_hoverHighlight(new QSGRectangle(inspector->overlay()))
{
m_hoverHighlight->border()->setColor(QColor(64, 128, 255));
void SGSelectionTool::hoverMoveEvent(QMouseEvent *event)
{
- QSGItem *root = inspector()->view()->rootItem();
+ SGViewInspector *sgInspector = static_cast<SGViewInspector*>(inspector());
+ QSGItem *root = sgInspector->view()->rootItem();
QPointF mappedPos = root->mapFromScene(event->pos());
- QSGItem *item = itemAt(root, mappedPos, inspector()->overlay());
+ QSGItem *item = itemAt(root, mappedPos, sgInspector->overlay());
if (!item || item == root) {
m_hoverHighlight->setVisible(false);
return;
#ifndef SGSELECTIONTOOL_H
#define SGSELECTIONTOOL_H
-#include "sgabstracttool.h"
+#include "abstracttool.h"
#include <QtCore/QList>
namespace QmlJSDebugger {
-class SGSelectionTool : public SGAbstractTool
+class SGViewInspector;
+
+class SGSelectionTool : public AbstractTool
{
Q_OBJECT
public:
#include "sgviewinspector.h"
#include "qdeclarativeinspectorprotocol.h"
-
-#include "sgabstracttool.h"
#include "sgselectiontool.h"
#include <QtDeclarative/private/qdeclarativeinspectorservice_p.h>
AbstractViewInspector(parent),
m_view(view),
m_overlay(new QSGItem),
- m_currentTool(0),
m_selectionTool(new SGSelectionTool(this)),
m_designMode(true)
{
m_overlay->setParentItem(root);
view->installEventFilter(this);
- m_currentTool = m_selectionTool;
+ setCurrentTool(m_selectionTool);
}
void SGViewInspector::changeCurrentObjects(const QList<QObject*> &objects)
emit marqueeSelectToolActivated();
break;
case InspectorProtocol::SelectTool:
- m_currentTool = m_selectionTool;
+ setCurrentTool(m_selectionTool);
emit selectToolActivated();
break;
case InspectorProtocol::ZoomTool:
bool SGViewInspector::eventFilter(QObject *obj, QEvent *event)
{
- if (obj != m_view || !m_designMode)
+ if (obj != m_view)
return QObject::eventFilter(obj, event);
- switch (event->type()) {
- case QEvent::Leave:
- if (leaveEvent(event))
- return true;
- break;
- case QEvent::MouseButtonPress:
- if (mousePressEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- case QEvent::MouseMove:
- if (mouseMoveEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- case QEvent::MouseButtonRelease:
- if (mouseReleaseEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- case QEvent::KeyPress:
- if (keyPressEvent(static_cast<QKeyEvent*>(event)))
- return true;
- break;
- case QEvent::KeyRelease:
- if (keyReleaseEvent(static_cast<QKeyEvent*>(event)))
- return true;
- break;
- case QEvent::MouseButtonDblClick:
- if (mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)))
- return true;
- break;
- case QEvent::Wheel:
- if (wheelEvent(static_cast<QWheelEvent*>(event)))
- return true;
- break;
- default:
- break;
- }
-
- return QObject::eventFilter(obj, event);
-}
-
-bool SGViewInspector::leaveEvent(QEvent *event)
-{
- m_currentTool->leaveEvent(event);
- return true;
-}
-
-bool SGViewInspector::mousePressEvent(QMouseEvent *event)
-{
- m_currentTool->mousePressEvent(event);
- return true;
-}
-
-bool SGViewInspector::mouseMoveEvent(QMouseEvent *event)
-{
- if (event->buttons()) {
- m_currentTool->mouseMoveEvent(event);
- } else {
- m_currentTool->hoverMoveEvent(event);
- }
- return true;
-}
-
-bool SGViewInspector::mouseReleaseEvent(QMouseEvent *event)
-{
- m_currentTool->mouseReleaseEvent(event);
- return true;
-}
-
-bool SGViewInspector::keyPressEvent(QKeyEvent *event)
-{
- m_currentTool->keyPressEvent(event);
- return true;
-}
-
-bool SGViewInspector::keyReleaseEvent(QKeyEvent *event)
-{
- switch (event->key()) {
- default:
- break;
- }
-
- m_currentTool->keyReleaseEvent(event);
- return true;
-}
-
-bool SGViewInspector::mouseDoubleClickEvent(QMouseEvent *event)
-{
- m_currentTool->mouseDoubleClickEvent(event);
- return true;
-}
-
-bool SGViewInspector::wheelEvent(QWheelEvent *event)
-{
- m_currentTool->wheelEvent(event);
- return true;
+ return AbstractViewInspector::eventFilter(obj, event);
}
} // namespace QmlJSDebugger
#include <QtCore/QWeakPointer>
QT_BEGIN_NAMESPACE
-class QMouseEvent;
-class QKeyEvent;
-class QWheelEvent;
-
class QSGView;
class QSGItem;
QT_END_NAMESPACE
namespace QmlJSDebugger {
-class SGAbstractTool;
class SGSelectionTool;
class SGViewInspector : public AbstractViewInspector
void removeFromSelectedItems(QObject *);
private:
- bool leaveEvent(QEvent *);
- bool mousePressEvent(QMouseEvent *event);
- bool mouseMoveEvent(QMouseEvent *event);
- bool mouseReleaseEvent(QMouseEvent *event);
- bool keyPressEvent(QKeyEvent *event);
- bool keyReleaseEvent(QKeyEvent *keyEvent);
- bool mouseDoubleClickEvent(QMouseEvent *event);
- bool wheelEvent(QWheelEvent *event);
-
QSGView *m_view;
QSGItem *m_overlay;
- SGAbstractTool *m_currentTool;
SGSelectionTool *m_selectionTool;
projects / konrad/qtdeclarative.git / commitdiff