bool PixelOrientedViewNavigator::eventFilter(QObject *widget, QEvent *e) {
if(e->type() != QEvent::MouseButtonDblClick && e->type() != QEvent::MouseMove)
return false;
GlMainWidget *glWidget = (GlMainWidget *) widget;
if (!glWidget->hasMouseTracking()) {
glWidget->setMouseTracking(true);
}
if (!pixelView->smallMultiplesViewSet() && !pixelView->interactorsEnabled()) {
pixelView->toggleInteractors(true);
}
if (pixelView->getOverviews().size() == 0) {
return false;
}
if (e->type() == QEvent::MouseMove && pixelView->smallMultiplesViewSet()) {
QMouseEvent *me = (QMouseEvent *) e;
int x = glWidget->width() - me->x();
int y = me->y();
Coord screenCoords(x, y, 0);
Coord sceneCoords = glWidget->getScene()->getGraphCamera().viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
PixelOrientedOverview *overviewUnderPointer = getOverviewUnderPointer(sceneCoords);
if (overviewUnderPointer != NULL && overviewUnderPointer != selectedOverview) {
selectedOverview = overviewUnderPointer;
}
return true;
}
else if (e->type() == QEvent::MouseButtonDblClick) {
if (selectedOverview != NULL && !selectedOverview->overviewGenerated()) {
pixelView->generatePixelOverview(selectedOverview, glWidget);
glWidget->draw();
}
else if (selectedOverview != NULL && pixelView->smallMultiplesViewSet()) {
QtGlSceneZoomAndPanAnimator zoomAndPanAnimator(glWidget, selectedOverview->getBoundingBox());
zoomAndPanAnimator.animateZoomAndPan();
pixelView->switchFromSmallMultiplesToDetailView(selectedOverview);
selectedOverview = NULL;
}
else if (!pixelView->smallMultiplesViewSet() && pixelView->getOverviews().size() > 1) {
pixelView->switchFromDetailViewToSmallMultiples();
QtGlSceneZoomAndPanAnimator zoomAndPanAnimator(glWidget, pixelView->getSmallMultiplesViewBoundingBox());
zoomAndPanAnimator.animateZoomAndPan();
pixelView->centerView();
}
return true;
}
return false;
}
bool FishEyeInteractorComponent::eventFilter(QObject *obj, QEvent *e) {
GlMainWidget *glWidget = (GlMainWidget*)obj;
Camera *camera=&glWidget->getScene()->getGraphCamera();
activateFishEye = false;
if (e->type() == QEvent::MouseMove ||
e->type() == QEvent::MouseButtonPress ||
e->type() == QEvent::MouseButtonRelease) {
activateFishEye = true;
QMouseEvent *me = (QMouseEvent *) e;
float x = glWidget->width() - me->x();
float y = me->y();
Coord screenCoords(x, y, 0);
fisheyeCenter = camera->viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
glWidget->redraw();
return true;
}
else if (e->type() == QEvent::Wheel) {
activateFishEye = true;
QWheelEvent *wheelEvent = (QWheelEvent *) e;
int numDegrees = wheelEvent->delta() / 8;
int numSteps = numDegrees / 15;
if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ControlModifier)) {
activateFishEye = true;
configWidget->setFishEyeRadius(configWidget->getFishEyeRadius() + configWidget->getFishEyeRadiusIncrementStep() * numSteps);
glWidget->redraw();
return true;
}
else if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ShiftModifier)) {
activateFishEye = true;
float newHeight = configWidget->getFishEyeHeight() + configWidget->getFishEyeHeightIncrementStep() * numSteps;
if (newHeight < 0) {
newHeight = 0;
}
configWidget->setFishEyeHeight(newHeight);
glWidget->redraw();
return true;
}
return false;
}
return false;
}
//========================================================================================
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 ParallelCoordsAxisBoxPlot::eventFilter(QObject *widget, QEvent *e) {
GlMainWidget *glWidget = dynamic_cast<GlMainWidget *>(widget);
if(!glWidget)
return false;
initOrUpdateBoxPlots();
if (e->type() == QEvent::MouseMove) {
QMouseEvent *me = (QMouseEvent *) e;
int x = glWidget->width() - me->x();
int y = me->y();
Coord screenCoords(x, y, 0.0f);
Coord sceneCoords(glWidget->getScene()->getLayer("Main")->getCamera().viewportTo3DWorld(glWidget->screenToViewport(screenCoords)));
selectedAxis = parallelView->getAxisUnderPointer(me->x(), me->y());
if (selectedAxis != NULL && dynamic_cast<QuantitativeParallelAxis *>(selectedAxis)) {
if (axisBoxPlotMap.find(static_cast<QuantitativeParallelAxis *>(selectedAxis)) != axisBoxPlotMap.end())
if (parallelView->getLayoutType() == ParallelCoordinatesDrawing::CIRCULAR) {
rotateVector(sceneCoords, -(selectedAxis->getRotationAngle()), Z_ROT);
}
axisBoxPlotMap[static_cast<QuantitativeParallelAxis *>(selectedAxis)]->setHighlightRangeIfAny(sceneCoords);
}
parallelView->refresh();
return true;
}
if (e->type() == QEvent::MouseButtonPress) {
return false;
}
if (e->type() == QEvent::MouseButtonRelease) {
if (selectedAxis != NULL && dynamic_cast<QuantitativeParallelAxis *>(selectedAxis)) {
Observable::holdObservers();
if (axisBoxPlotMap.find(static_cast<QuantitativeParallelAxis *>(selectedAxis)) != axisBoxPlotMap.end())
parallelView->highlightDataInAxisBoxPlotRange(static_cast<QuantitativeParallelAxis *>(selectedAxis));
Observable::unholdObservers();
selectedAxis = NULL;
parallelView->refresh();
return true;
}
}
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;
}