int main(int argc, char** argv) {
/*
A QApplication must always be declared at the beginning of the main function in order for Tulip to work.
This must be done before calling tlp::initTulipSoftware()
*/
QApplication app(argc,argv);
/*
Initialize the library, load plugins and set application runtime pathes accordingly to the host operating system
This method should always be called if you intend to use plugins in your application.
*/
tlp::initTulipSoftware(NULL);
// Creates the main widget that will display our graph
GlMainWidget* mainWidget = new GlMainWidget(NULL);
// Adds a layer to the scene
GlLayer* mainLayer = mainWidget->getScene()->createLayer("Main");
Coord center1(-1,-1,-1);
Coord center2(1,1,1);
Size size(1,1,1);
Color whiteOpaque(255, 255, 255, 255);
Color blackOpaque(0, 0, 0, 255);
GlBox *node1 = new GlBox(center1, size, whiteOpaque, blackOpaque);
GlBox *node2 = new GlBox(center2, size, whiteOpaque, blackOpaque);
mainLayer->addGlEntity(node1, "Gl Tutorial 1: Node 1");
mainLayer->addGlEntity(node2, "Gl Tutorial 1: Node 2");
Coord centerBox(0, 0, 0);
Size sizeBox(3.001, 3.001, 3.001);
Color purpleTrans(155, 0, 155, 50);
GlBox *box = new GlBox(centerBox, sizeBox, purpleTrans, blackOpaque);
mainLayer->addGlEntity(box, "Gl Tutorial 2: Box");
// Display the widget
mainWidget->show();
// Flush event loop in order to let paint events pass through in order for the scene to be initialized.
QApplication::processEvents();
// Center the camera and draw the graph
mainWidget->centerScene();
mainWidget->draw();
// Adds Zoom and pan navigation to the widget
mainWidget->installEventFilter(new MouseNKeysNavigator);
return app.exec();
}
bool GoogleMapViewNavigator::eventFilter(QObject *widget, QEvent *e) {
GoogleMapsView *googleMapsView=static_cast<GoogleMapsView*>(view());
if(googleMapsView->viewType()==GoogleMapsView::GoogleRoadMap ||
googleMapsView->viewType()==GoogleMapsView::GoogleSatellite ||
googleMapsView->viewType()==GoogleMapsView::GoogleTerrain ||
googleMapsView->viewType()==GoogleMapsView::GoogleHybrid) {
QMouseEvent *qMouseEv = dynamic_cast<QMouseEvent *>(e);
QWheelEvent *qWheelEv = dynamic_cast<QWheelEvent *>(e);
if(qMouseEv || qWheelEv) {
GoogleMapsView* googleMapsView=static_cast<GoogleMapsView*>(view());
QApplication::sendEvent(googleMapsView->getGoogleMap(), e);
}
return false;
}
else if (googleMapsView->viewType()==GoogleMapsView::Globe) {
if (e->type() == QEvent::Wheel &&
(((QWheelEvent *) e)->orientation() == Qt::Vertical)) {
#define WHEEL_DELTA 120
GlMainWidget *g = (GlMainWidget *) widget;
g->getScene()->zoomXY(((QWheelEvent *) e)->delta() / WHEEL_DELTA,
g->width()/2., g->height()/2.);
view()->draw();
return true;
}
if (e->type() == QEvent::MouseButtonPress && !inRotation) {
if(((QMouseEvent*)e)->button()==Qt::LeftButton) {
x = ((QMouseEvent *) e)->x();
y = ((QMouseEvent *) e)->y();
inRotation=true;
return true;
}
}
if(e->type() == QEvent::MouseButtonRelease) {
if(((QMouseEvent*)e)->button()==Qt::LeftButton) {
inRotation=false;
return true;
}
}
if (e->type() == QEvent::MouseMove && inRotation) {
GlMainWidget *g = (GlMainWidget *) widget;
Camera &camera=g->getScene()->getGraphCamera();
Coord c1=camera.getEyes()-camera.getCenter();
Coord c2=camera.getEyes()-camera.getCenter()+camera.getUp();
trans(c1,c2,-0.005*(((QMouseEvent *) e)->y()-y),-0.005*(((QMouseEvent *) e)->x()-x));
camera.setCenter(Coord(0,0,0));
camera.setEyes(c1);
camera.setUp(c2-camera.getEyes());
x = ((QMouseEvent *) e)->x();
y = ((QMouseEvent *) e)->y();
view()->draw();
return true;
}
if (e->type() == QEvent::KeyPress) {
GlMainWidget *g = (GlMainWidget *) widget;
float angle1=0;
float angle2=0;
switch(((QKeyEvent *) e)->key()) {
case Qt::Key_Left:
angle2=-0.05f;
break;
case Qt::Key_Right:
angle2=0.05f;
break;
case Qt::Key_Up:
angle1=0.05f;
break;
case Qt::Key_Down:
angle1=-0.05f;
break;
}
Camera &camera=g->getScene()->getGraphCamera();
Coord c1=camera.getEyes()-camera.getCenter();
Coord c2=camera.getEyes()-camera.getCenter()+camera.getUp();
trans(c1,c2,angle1,angle2);
camera.setCenter(Coord(0,0,0));
camera.setEyes(c1);
camera.setUp(c2-camera.getEyes());
view()->draw();
return true;
}
return false;
}
else {
return MouseNKeysNavigator::eventFilter(widget, e);
}
}
//========================================================================================
bool MouseSelectionEditor::eventFilter(QObject *widget, QEvent *e) {
QMouseEvent *qMouseEv = static_cast<QMouseEvent *>(e);
GlMainWidget *glMainWidget = static_cast<GlMainWidget *>(widget);
if (e->type() == QEvent::MouseButtonPress) {
initProxies(glMainWidget);
computeFFD(glMainWidget);
int H;
H = glMainWidget->height();
editCenter = centerRect.getCenter();
editCenter[2] = 0;
editCenter[1] = glMainWidget->screenToViewport(H) - editCenter[1];
// editCenter[0] = W - editCenter[0];
editPosition[0] = qMouseEv->x();
editPosition[1] = qMouseEv->y();
editPosition[2] = 0;
editLayoutCenter = _layoutCenter;
vector<SelectedEntity> select;
switch (qMouseEv->buttons()) {
case Qt::LeftButton: {
// first ensure that something is selected
bool hasSelection = _selection->hasNonDefaultValuatedNodes(_graph) ||
_selection->hasNonDefaultValuatedEdges(_graph);
if (!hasSelection ||
(!glMainWidget->pickGlEntities(int(editPosition[0]) - 3, int(editPosition[1]) - 3, 6, 6,
select, layer))) {
// event occurs outside the selection rectangle
// so from now we delegate the job to a MouseSelector object
// which should intercept the event
operation = NONE;
glMainWidget->setCursor(QCursor(Qt::CrossCursor));
return false;
}
glMainWidget->setCursor(QCursor(Qt::PointingHandCursor));
int shapeId = -1;
bool advShape = false;
for (unsigned int i = 0; (i < select.size()) && (shapeId == -1); ++i) {
for (int j = 0; j < 8; ++j) {
if (select[i].getSimpleEntity() == &_controls[j]) {
shapeId = i;
}
}
for (int j = 0; j < 6; ++j) {
if (select[i].getSimpleEntity() == &_advControls[j]) {
advShape = true;
shapeId = i;
}
}
}
if (shapeId != -1) {
if (!advShape) {
static_cast<GlCircle *>(select[shapeId].getSimpleEntity())
->setFillColor(Color(40, 255, 40, 200));
static_cast<GlCircle *>(select[shapeId].getSimpleEntity())
->setOutlineColor(Color(20, 128, 20, 200));
}
getOperation(select[shapeId].getSimpleEntity());
switch (operation) {
case ALIGN_TOP:
case ALIGN_BOTTOM:
case ALIGN_LEFT:
case ALIGN_RIGHT:
case ALIGN_VERTICALLY:
case ALIGN_HORIZONTALLY:
mAlign(operation, glMainWidget);
return true;
case ROTATE_Z:
case ROTATE_XY:
case NONE:
case STRETCH_X:
case STRETCH_Y:
case STRETCH_XY:
case TRANSLATE:
default:
break;
}
} else {
if (qMouseEv->modifiers() &
#if defined(__APPLE__)
Qt::AltModifier
#else
Qt::ControlModifier
#endif
) {
operation = ROTATE_XY;
glMainWidget->setCursor(QCursor(Qt::PointingHandCursor));
} else {
operation = TRANSLATE;
glMainWidget->setCursor(QCursor(Qt::SizeAllCursor));
}
}
mode = COORD_AND_SIZE;
if (qMouseEv->modifiers() & Qt::ShiftModifier)
mode = COORD;
if (qMouseEv->modifiers() &
#if defined(__APPLE__)
Qt::AltModifier
#else
Qt::ControlModifier
#endif
)
mode = SIZE;
initEdition();
break;
}
case Qt::MidButton:
undoEdition();
glMainWidget->setCursor(QCursor(Qt::ArrowCursor));
break;
default:
return false;
}
glMainWidget->redraw();
return true;
}
if (e->type() == QEvent::MouseButtonRelease && qMouseEv->button() == Qt::LeftButton &&
operation != NONE) {
stopEdition();
// restore colors
for (unsigned int i = 0; i < 8; ++i) {
_controls[i].setFillColor(Color(255, 40, 40, 200));
_controls[i].setOutlineColor(Color(128, 20, 20, 200));
}
glMainWidget->setCursor(QCursor(Qt::ArrowCursor));
glMainWidget->draw();
return true;
}
if (e->type() == QEvent::KeyPress) {
// first ensure that something is selected
bool hasSelection = _selection->hasNonDefaultValuatedNodes(_graph) ||
_selection->hasNonDefaultValuatedEdges(_graph);
if (hasSelection) {
switch (static_cast<QKeyEvent *>(e)->key()) {
case Qt::Key_Left:
mMouseTranslate(editPosition[0] - 1, editPosition[1], glMainWidget);
break;
case Qt::Key_Right:
mMouseTranslate(editPosition[0] + 1, editPosition[1], glMainWidget);
break;
case Qt::Key_Up:
mMouseTranslate(editPosition[0], editPosition[1] - 1, glMainWidget);
break;
case Qt::Key_Down:
mMouseTranslate(editPosition[0], editPosition[1] + 1, glMainWidget);
break;
}
}
}
if (e->type() == QEvent::MouseMove && qMouseEv->buttons() & Qt::LeftButton && operation != NONE) {
int newX = qMouseEv->x();
int newY = qMouseEv->y();
switch (operation) {
case STRETCH_X:
case STRETCH_Y:
case STRETCH_XY:
mMouseStretchAxis(newX, newY, glMainWidget);
return true;
case ROTATE_Z:
case ROTATE_XY:
mMouseRotate(newX, newY, glMainWidget);
return true;
case TRANSLATE:
mMouseTranslate(newX, newY, glMainWidget);
return true;
case NONE:
case ALIGN_TOP:
case ALIGN_BOTTOM:
case ALIGN_LEFT:
case ALIGN_RIGHT:
case ALIGN_VERTICALLY:
case ALIGN_HORIZONTALLY:
default:
qWarning() << "[Error] : " << __FUNCTION__ << " should not have been called" << endl;
break;
}
}
return false;
}
bool MouseEdgeBuilder::eventFilter(QObject *widget, QEvent *e) {
GlMainWidget *glMainWidget = static_cast<GlMainWidget *>(widget);
if (e->type() == QEvent::MouseButtonPress) {
QMouseEvent * qMouseEv = static_cast<QMouseEvent *>(e);
SelectedEntity selectedEntity;
GlGraphInputData *inputData=glMainWidget->getScene()->getGlGraphComposite()->getInputData();
Graph * _graph = inputData->getGraph();
LayoutProperty* mLayout = inputData->getElementLayout();
if (qMouseEv->buttons()==Qt::LeftButton) {
if (!_started) {
bool result=glMainWidget->pickNodesEdges(qMouseEv->x(), qMouseEv->y(), selectedEntity);
if (result && (selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED)) {
_started=true;
initObserver(_graph);
_source=node(selectedEntity.getComplexEntityId());
_curPos=_startPos=mLayout->getNodeValue(_source);
return true;
}
return false;
}
else {
bool result = glMainWidget->pickNodesEdges(qMouseEv->x(),qMouseEv->y(),selectedEntity);
if (result && (selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED)) {
Observable::holdObservers();
_started=false;
clearObserver();
// allow to undo
_graph->push();
addLink(widget,_source,node(selectedEntity.getComplexEntityId()));
Observable::unholdObservers();
}
else {
Coord point(glMainWidget->width() - qMouseEv->x(), qMouseEv->y(), 0);
_bends.push_back(glMainWidget->getScene()->getGraphCamera().viewportTo3DWorld(glMainWidget->screenToViewport(point)));
glMainWidget->redraw();
}
}
return true;
}
if (qMouseEv->buttons()==Qt::MidButton) {
_bends.clear();
_started=false;
_source=node();
clearObserver();
glMainWidget->draw();
return true;
}
}
if (e->type() == QEvent::MouseMove) {
QMouseEvent * qMouseEv = static_cast<QMouseEvent *>(e);
if (!_started) {
SelectedEntity selectedEntity;
bool hoveringOverNode = glMainWidget->pickNodesEdges(qMouseEv->x(), qMouseEv->y(), selectedEntity) && selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED;
if (!hoveringOverNode) {
glMainWidget->setCursor(QCursor(Qt::ArrowCursor));
return false;
}
else {
glMainWidget->setCursor(QCursor(Qt::CrossCursor));
}
}
else {
SelectedEntity selectedEntity;
if(glMainWidget->pickNodesEdges(qMouseEv->x(), qMouseEv->y(), selectedEntity) && selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED) {
glMainWidget->setCursor(QCursor(Qt::CrossCursor));
}
else {
glMainWidget->setCursor(QCursor(Qt::ArrowCursor));
}
Coord point(glMainWidget->width() - qMouseEv->x(), qMouseEv->y(), 0);
point = glMainWidget->getScene()->getGraphCamera().viewportTo3DWorld(glMainWidget->screenToViewport(point));
_curPos.set(point[0], point[1], point[2]);
glMainWidget->redraw();
}
return true;
}
return false;
}
//========================================================================================
bool MouseEdgeBendEditor::eventFilter(QObject *widget, QEvent *e) {
QMouseEvent * qMouseEv = (QMouseEvent *) e;
if(qMouseEv == NULL)
return false;
// Double click to create a new control point
if(e->type() == QEvent::MouseButtonDblClick && qMouseEv->button() == Qt::LeftButton && haveSelection(glMainWidget)) {
_operation = NEW_OP;
mMouseCreate(qMouseEv->x(), qMouseEv->y(), glMainWidget);
return true;
}
if (e->type() == QEvent::MouseButtonPress) {
if(!glMainWidget)
glMainWidget = (GlMainWidget *) widget;
initProxies(glMainWidget);
bool hasSelection = haveSelection(glMainWidget);
editPosition[0] = qMouseEv->x();
editPosition[1] = qMouseEv->y();
editPosition[2] = 0;
switch(qMouseEv->buttons()) {
case Qt::LeftButton : {
if (!hasSelection) {
// event occurs outside the selection rectangle
// so from now we delegate the job to a MouseEdgeSelector object
// which should intercept the event
_operation = NONE_OP;
}
else {
bool entityIsSelected = glMainWidget->pickGlEntities((int)editPosition[0] - 3, (int)editPosition[1] - 3, 6, 6, select, layer);
if(!entityIsSelected) {
// We have click outside an entity
_operation = NONE_OP;
}
else {
selectedEntity=circleString->findKey(select[0].getSimpleEntity());
if (qMouseEv->modifiers() &
#if defined(__APPLE__)
Qt::AltModifier
#else
Qt::ControlModifier
#endif
) {
_operation = DELETE_OP;
mMouseDelete();
}
else {
_graph->push();
_operation = TRANSLATE_OP;
glMainWidget->setCursor(QCursor(Qt::SizeAllCursor));
mode = COORD;
}
return true;
}
}
break;
}
default: {
return false;
}
}
glMainWidget->redraw();
}
if (e->type() == QEvent::MouseButtonRelease &&
qMouseEv->button() == Qt::LeftButton &&
_operation != NONE_OP) {
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
if(selectedEntity=="targetTriangle") {
SelectedEntity selectedEntity;
if (glMainWidget->pickNodesEdges(qMouseEv->x(), qMouseEv->y(), selectedEntity) && selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED) {
glMainWidget->getScene()->getGlGraphComposite()->getGraph()->setEnds(mEdge,glMainWidget->getScene()->getGlGraphComposite()->getGraph()->ends(mEdge).first,node(selectedEntity.getComplexEntityId()));
}
}
else if(selectedEntity=="sourceCircle") {
SelectedEntity selectedEntity;
if (glMainWidget->pickNodesEdges(qMouseEv->x(), qMouseEv->y(), selectedEntity) && selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED) {
glMainWidget->getScene()->getGlGraphComposite()->getGraph()->setEnds(mEdge,node(selectedEntity.getComplexEntityId()),glMainWidget->getScene()->getGlGraphComposite()->getGraph()->ends(mEdge).second);
}
}
selectedEntity="";
_operation = NONE_OP;
glMainWidget->setCursor(QCursor(Qt::PointingHandCursor));
glMainWidget->redraw();
return true;
}
if(e->type() == QEvent::MouseButtonPress) {
vector<SelectedEntity> selectedEntities;
glMainWidget->pickGlEntities(qMouseEv->x(), qMouseEv->y(), selectedEntities);
if(!selectedEntities.empty())
if(selectedEntities[0].getEntityType()==SelectedEntity::SIMPLE_ENTITY_SELECTED)
if(selectedEntities[0].getSimpleEntity()==edgeEntity) {
mouseButtonPressOnEdge=true;
return true;
}
}
if(e->type() == QEvent::MouseButtonRelease) {
vector<SelectedEntity> selectedEntities;
glMainWidget->pickGlEntities(qMouseEv->x(), qMouseEv->y(), selectedEntities);
if(!selectedEntities.empty())
if(selectedEntities[0].getEntityType()==SelectedEntity::SIMPLE_ENTITY_SELECTED)
if(selectedEntities[0].getSimpleEntity()==edgeEntity && mouseButtonPressOnEdge) {
mouseButtonPressOnEdge=false;
return true;
}
mouseButtonPressOnEdge=false;
}
if (e->type() == QEvent::MouseMove) {
if(qMouseEv->buttons() == Qt::LeftButton &&
_operation != NONE_OP) {
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
switch (_operation) {
case TRANSLATE_OP:
mMouseTranslate(qMouseEv->x(), qMouseEv->y(), glMainWidget);
return true;
default:
return false;
}
}
else if(qMouseEv->buttons() == Qt::NoButton) {
SelectedEntity selectedEntity;
GlMainWidget *g = (GlMainWidget *) widget;
if (g->pickNodesEdges(qMouseEv->x(), qMouseEv->y(), selectedEntity) && selectedEntity.getEntityType() == SelectedEntity::NODE_SELECTED) {
g->setCursor(Qt::CrossCursor);
}
else {
g->setCursor(Qt::ArrowCursor);
}
return false;
}
}
return false;
}
//=====================================================================
bool MouseBoxZoomer::eventFilter(QObject *widget, QEvent *e) {
GlMainWidget *glw = static_cast<GlMainWidget *>(widget);
GlGraphInputData *inputData = glw->getScene()->getGlGraphComposite()->getInputData();
if (e->type() == QEvent::MouseButtonPress) {
QMouseEvent * qMouseEv = static_cast<QMouseEvent *>(e);
if (qMouseEv->buttons() == mButton &&
(kModifier == Qt::NoModifier ||
qMouseEv->modifiers() & kModifier)) {
if (!started) {
x = qMouseEv->x();
y = glw->height() - qMouseEv->y();
w = 0;
h = 0;
started = true;
graph = inputData->getGraph();
}
else {
if (inputData->getGraph() != graph) {
graph = NULL;
started = false;
}
}
return true;
}
if (qMouseEv->buttons()==Qt::MidButton) {
started = false;
glw->redraw();
return true;
}
return false;
}
if (e->type() == QEvent::MouseMove) {
QMouseEvent * qMouseEv = static_cast<QMouseEvent *>(e);
if ((qMouseEv->buttons() & mButton) &&
(kModifier == Qt::NoModifier ||
qMouseEv->modifiers() & kModifier)) {
if (inputData->getGraph() != graph) {
graph = NULL;
started = false;
}
if (started) {
if ((qMouseEv->x() > 0) && (qMouseEv->x() < glw->width()))
w = qMouseEv->x() - x;
if ((qMouseEv->y() > 0) && (qMouseEv->y() < glw->height()))
h = y - (glw->height() - qMouseEv->y());
glw->redraw();
return true;
}
}
}
if (e->type() == QEvent::MouseButtonDblClick) {
GlBoundingBoxSceneVisitor bbVisitor(inputData);
glw->getScene()->getLayer("Main")->acceptVisitor(&bbVisitor);
QtGlSceneZoomAndPanAnimator zoomAnPan(glw, bbVisitor.getBoundingBox());
zoomAnPan.animateZoomAndPan();
return true;
}
if (e->type() == QEvent::MouseButtonRelease) {
QMouseEvent * qMouseEv = static_cast<QMouseEvent *>(e);
if ((qMouseEv->button() == mButton &&
(kModifier == Qt::NoModifier ||
qMouseEv->modifiers() & kModifier))) {
if (inputData->getGraph() != graph) {
graph = NULL;
started = false;
}
if (started) {
started = false;
if(!(w==0 && h==0)) {
int width = glw->width();
int height = glw->height();
Coord bbMin(width-x, height - y+h);
Coord bbMax(width-(x+w), height - y);
if (abs(bbMax[0] - bbMin[0]) > 1 && abs(bbMax[1] - bbMin[1]) > 1) {
BoundingBox sceneBB;
sceneBB.expand(glw->getScene()->getGraphCamera().viewportTo3DWorld(glw->screenToViewport(bbMin)));
sceneBB.expand(glw->getScene()->getGraphCamera().viewportTo3DWorld(glw->screenToViewport(bbMax)));
QtGlSceneZoomAndPanAnimator zoomAnPan(glw, sceneBB);
zoomAnPan.animateZoomAndPan();
}
}
}
return true;
}
}
return false;
}
//===============================================================
bool MousePanNZoomNavigator::eventFilter(QObject *widget, QEvent *e) {
// according to Qt's doc, this constant has been defined by wheel mouse vendors
// we need it to interpret the value of QWheelEvent->delta()
#define WHEEL_DELTA 120
if (e->type() == QEvent::Wheel &&
(((QWheelEvent *) e)->orientation() == Qt::Vertical)) {
GlMainWidget *g = (GlMainWidget *) widget;
if(((QWheelEvent *) e)->delta() < 0 && g->getScene()->getCamera().getZoomFactor() < 0.5f) {
return true;
}
g->getScene()->zoomXY(((QWheelEvent *) e)->delta() / WHEEL_DELTA,
((QWheelEvent *) e)->x(), ((QWheelEvent *) e)->y());
g->draw(false);
return true;
}
if(e->type() == QEvent::Gesture) {
GlMainWidget *g = (GlMainWidget *) widget;
QGestureEvent* gesture = (QGestureEvent*)e;
QPointF center;
//swipe events and pan events are never fired, known Qt bug
/*if(gesture->gesture(Qt::SwipeGesture)) {
QSwipeGesture* swipe = (QSwipeGesture*)gesture->gesture(Qt::SwipeGesture);
int x = cos(swipe->swipeAngle()) * swipe->property("velocity").toFloat();
int y = sin(swipe->swipeAngle()) * swipe->property("velocity").toFloat();
g->getScene()->translateCamera(x, y, 0);
}*/
if(gesture->gesture(Qt::PinchGesture)) {
QPinchGesture* pinch = (QPinchGesture*)gesture->gesture(Qt::PinchGesture);
Camera& camera = g->getScene()->getCamera();
//store the camera scale factor when starting the gesture
if(pinch->state() == Qt::GestureStarted) {
cameraScaleFactor = camera.getZoomFactor();
isGesturing = true;
}
if(pinch->changeFlags() & QPinchGesture::ScaleFactorChanged) {
//only set the zoom factor if two events in a row were in the same direction (zoom in or out) to smooth a bit the effect.
if((pinch->lastScaleFactor() > 1 && pinch->scaleFactor() > 1) || (pinch->lastScaleFactor() <= 1 && pinch->scaleFactor() <= 1)) {
camera.setZoomFactor(cameraScaleFactor * pinch->totalScaleFactor());
}
}
if(pinch->changeFlags() & QPinchGesture::RotationAngleChanged) {
/*//backup the current camera center
Coord oldCenter = camera.getCenter();
Coord oldEye = camera.getEyes();
//sets the camera center to the center of the pich gesture
Coord rotationCenter(g->mapFromGlobal(pinch->centerPoint().toPoint()).x(), g->mapFromGlobal(pinch->centerPoint().toPoint()).y(), oldCenter.getZ());
Coord rotationEye=camera.getEyes()+(rotationCenter-oldCenter);
camera.setCenter(rotationCenter);
camera.setEyes(rotationEye);*/
//rotates the camera
camera.rotate((pinch->rotationAngle() - pinch->lastRotationAngle())/180*M_PI, 0, 0, 1);
/*
//restore old camera center and eyes
camera.setCenter(oldCenter);
camera.setEyes(oldEye); */
}
if(pinch->state() == Qt::GestureFinished) {
isGesturing = false;
}
if(gesture->gesture(Qt::PanGesture)) {
QPanGesture* pan = (QPanGesture*)gesture->gesture(Qt::PanGesture);
if(pan->state() == Qt::GestureStarted) {
isGesturing = true;
}
if(pan->state() == Qt::GestureFinished) {
isGesturing = false;
}
center = pan->delta();
g->getScene()->translateCamera(pan->delta().x(), -pan->delta().y(), 0);
}
}
g->draw(false);
return true;
}
return false;
}
//===============================================================
bool MouseNKeysNavigator::eventFilter(QObject *widget, QEvent *e) {
if(isGesturing) {
return MousePanNZoomNavigator::eventFilter(widget, e);
}
if(currentSpecInteractorComponent) {
if(currentSpecInteractorComponent->eventFilter(widget,e))
return true;
}
if (e->type() == QEvent::MouseButtonPress) {
if (((QMouseEvent *) e)->buttons() == Qt::LeftButton) {
oldCursor=((QWidget*)widget)->cursor();
InteractorComponent *currentMouse;
// give focus so we can catch key events
((GlMainWidget *)widget)->setFocus();
if (((QMouseEvent *) e)->modifiers() &
#if defined(__APPLE__)
Qt::AltModifier
#else
Qt::ControlModifier
#endif
)
currentMouse = new MouseZoomRotZ();
else if (((QMouseEvent *) e)->modifiers() & Qt::ShiftModifier)
currentMouse = new MouseRotXRotY();
else {
currentMouse = new MouseMove();
((QWidget*)widget)->setCursor(QCursor(Qt::ClosedHandCursor));
}
bool result = currentMouse->eventFilter(widget, e);
currentSpecInteractorComponent=currentMouse;
//currentMouseID = abstractView->pushInteractor(currentMouse);
return result;
}
return false;
}
if (e->type() == QEvent::MouseButtonRelease) {
((QWidget*)widget)->setCursor(oldCursor);
delete currentSpecInteractorComponent;
currentSpecInteractorComponent=NULL;
return true;
}
if (e->type() == QEvent::KeyPress) {
int delta = (((QKeyEvent *) e)->isAutoRepeat() ? 3 : 1);
GlMainWidget *g = (GlMainWidget *) widget;
switch(((QKeyEvent *) e)->key()) {
case Qt::Key_Left:
g->getScene()->translateCamera(delta * 2,0,0);
break;
case Qt::Key_Right:
g->getScene()->translateCamera(-1 * delta * 2,0,0);
break;
case Qt::Key_Up:
g->getScene()->translateCamera(0,-1 * delta * 2,0);
break;
case Qt::Key_Down:
g->getScene()->translateCamera(0,delta * 2,0);
break;
case Qt::Key_PageUp:
g->getScene()->zoom(delta);
break;
case Qt::Key_PageDown:
g->getScene()->zoom(-1 * delta);
break;
case Qt::Key_Home:
g->getScene()->translateCamera(0,0,-1 * delta * 2);
break;
case Qt::Key_End:
g->getScene()->translateCamera(0,0,delta * 2);
break;
case Qt::Key_Insert:
g->getScene()->rotateScene(0,0,-1 * delta * 2);
break;
case Qt::Key_Delete :
g->getScene()->rotateScene(0,0,delta * 2);
break;
default:
return false;
}
g->draw();
return true;
}
if (e->type() == QEvent::KeyRelease) {
switch(((QKeyEvent *) e)->key()) {
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
case Qt::Key_PageUp:
case Qt::Key_PageDown:
case Qt::Key_Home:
case Qt::Key_End:
case Qt::Key_Insert:
case Qt::Key_Delete:
break;
default:
return false;
}
return true;
}
return MousePanNZoomNavigator::eventFilter(widget, e);
}