bool KFontDialog::eventFilter(QObject *obj, QEvent *event) {
if(obj == ui->btn_close) {
if(event->type() == QEvent::Enter){
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeBtn-hover.png"));
}else if(event->type() == QEvent::Leave){
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeBtn.png"));
}else if(event->type() == QEvent::MouseButtonPress){
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeBtn-hover.png"));
}else if(event->type() == QEvent::MouseButtonRelease){
QMouseEvent *me = (QMouseEvent *)event;
QLabel *lb = (QLabel *)obj;
if(me->x() > 0 && me->x() < lb->width() && me->y() > 0 && me->y() < lb->height()){
this->close();
}else{
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeBtn.png"));
}
} else {
return QObject::eventFilter(obj, event);
}
}
if(obj == ui->okBtn ||obj == ui->quitBtn)
{
if(event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *me = (QMouseEvent *)event;
dragPos = me->globalPos() - frameGeometry().topLeft();
}else if(event->type() == QEvent::MouseButtonRelease)
{
setWindowOpacity(1);
}
}
return QObject::eventFilter(obj, event);
}
bool MouseRotXRotY::eventFilter(QObject *widget, QEvent *e) {
if (e->type() == QEvent::MouseButtonPress) {
x = ((QMouseEvent *) e)->x();
y = ((QMouseEvent *) e)->y();
return true;
}
if (e->type() == QEvent::MouseMove) {
QMouseEvent *qMouseEv = (QMouseEvent *) e;
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
int deltaX,deltaY;
deltaX=qMouseEv->x()-x;
deltaY=qMouseEv->y()-y;
if (abs(deltaX)>abs(deltaY))
deltaY=0;
else
deltaX=0;
if (deltaY!=0) glMainWidget->getScene()->rotateScene(deltaY,0,0);
if (deltaX!=0) glMainWidget->getScene()->rotateScene(0,deltaX,0);
x=qMouseEv->x();
y=qMouseEv->y();
glMainWidget->draw();
return true;
}
return false;
}
bool MouseMove::eventFilter(QObject *widget, QEvent *e) {
if (e->type() == QEvent::MouseButtonPress) {
x = ((QMouseEvent *) e)->x();
y = ((QMouseEvent *) e)->y();
return true;
}
if (e->type() == QEvent::MouseMove) {
QMouseEvent *qMouseEv = (QMouseEvent *) e;
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
if (qMouseEv->x() != x)
glMainWidget->getScene()->translateCamera(qMouseEv->x()-x,0,0);
if (qMouseEv->y() != y)
glMainWidget->getScene()->translateCamera(0,y-qMouseEv->y(),0);
x = qMouseEv->x();
y = qMouseEv->y();
glMainWidget->draw(false);
return true;
}
return false;
}
bool ButtonDelegate::editorEvent(QEvent *event, QAbstractItemModel *, const QStyleOptionViewItem &option, const QModelIndex &index)
{
QRect rect = option.rect;
QRect rectBu(rect.left() + rect.width()/2 - 15,
rect.top() + rect.height()/2 - 5,
30, 15);
if (event->type() == QEvent::MouseMove) {
QMouseEvent* e =(QMouseEvent*)event;
if (rectBu.contains(e->x(), e->y())) {
}
}
if (event->type() == QEvent::MouseButtonRelease) {
QMouseEvent* e =(QMouseEvent*)event;
if (rectBu.contains(e->x(), e->y())) {
int row = index.row();
emit currentRow(row);
return true;
}
}
return false;
}
bool Row::eventFilter(QObject * obj, QEvent * ev) {
if (obj == sideWidget && ev->type() == QEvent::MouseButtonPress) {
QMouseEvent * e = static_cast<QMouseEvent *>(ev);
mousePressed(e->x(), e->y());
}
if (obj == this && ev->type() == QEvent::MouseButtonPress) {
QMouseEvent * e = static_cast<QMouseEvent *>(ev);
mousePressed(e->x(), e->y());
}
if ((obj == this) && (ev->type() == QEvent::Paint)) {
QPaintEvent * e = static_cast<QPaintEvent *>(ev);
paint(e->rect());
}
if ((obj == this) && (ev->type() == QEvent::Resize)) {
QResizeEvent * e = static_cast<QResizeEvent *>(ev);
this->pixPerMs = (double) e->size().width() / (double) (globalStopTime - globalStartTime);
qDebug() << pixPerMs;
repaint();
}
return true;
}
bool PersonalChatDlg::eventFilter(QObject *obj, QEvent *event)
{
if(obj == ui->btn_min){ //最小化、最大化、关闭按钮换图
if(event->type() == QEvent::Enter){
ui->btn_min->setPixmap(QPixmap(":/pixmap/image/miniButton-hover.png"));
}else if(event->type() == QEvent::Leave){
ui->btn_min->setPixmap(QPixmap(":/pixmap/image/miniButton.png"));
}else if(event->type() == QEvent::MouseButtonPress){
ui->btn_min->setPixmap(QPixmap(":/pixmap/image/miniButton-hover.png"));
}else if(event->type() == QEvent::MouseButtonRelease){
QMouseEvent *me = (QMouseEvent *)event;
QLabel *lb = (QLabel *)obj;
if(me->x() > 0 && me->x() < lb->width() && me->y() > 0 && me->y() < lb->height()){
this->showMinimized();
}else{
ui->btn_min->setPixmap(QPixmap(":/pixmap/image/miniButton.png"));
}
} else {
return QObject::eventFilter(obj, event);
}
}
if(obj == ui->btn_close){ //最小化、最大化、关闭按钮换图
if(event->type() == QEvent::Enter){
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeButton-hover.png"));
}else if(event->type() == QEvent::Leave){
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeButton.png"));
}else if(event->type() == QEvent::MouseButtonPress){
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeButton-hover.png"));
}else if(event->type() == QEvent::MouseButtonRelease){
QMouseEvent *me = (QMouseEvent *)event;
QLabel *lb = (QLabel *)obj;
if(me->x() > 0 && me->x() < lb->width() && me->y() > 0 && me->y() < lb->height()){
this->close();
emit closePersonalchatdlg(bareJid);
}else{
ui->btn_close->setPixmap(QPixmap(":/pixmap/image/closeButton.png"));
}
} else {
return QObject::eventFilter(obj, event);
}
}
if(obj==ui->closeButton||obj==ui->sendMessageButton
||obj==ui->sendfileButton
||obj==ui->saveFileButton
||obj==ui->refuseButton)
{
if(event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *me = (QMouseEvent *)event;
dragPos = me->globalPos() - frameGeometry().topLeft();
}else if(event->type() == QEvent::MouseButtonRelease)
{
setWindowOpacity(1);
}
}
return QObject::eventFilter(obj, event);
}
void Camera::OnMouseMotion(const QMouseEvent & event)
{
_theta -= (event.x() - initialCursorPositionX ) *_sensivity;
_phi -= (event.y() - initialCursorPositionY ) *_sensivity;
initialCursorPositionX = event.x();
initialCursorPositionY = event.y();
VectorsFromAngles();
}
bool MouseZoomRotZ::eventFilter(QObject *widget, QEvent *e) {
if (e->type() == QEvent::MouseButtonPress) {
x = ((QMouseEvent *) e)->x();
y = ((QMouseEvent *) e)->y();
inRotation=false;
inZoom=false;
return true;
}
if (e->type() == QEvent::MouseMove) {
QMouseEvent *qMouseEv = (QMouseEvent *) e;
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
int deltaX,deltaY;
if(!inRotation && !inZoom) {
deltaX = qMouseEv->x() - x;
deltaY= qMouseEv->y() - y;
if (deltaY && abs(deltaX) >= 3 * abs(deltaY)) {
inRotation=true;
inZoom=false;
}
else if (deltaX && abs(deltaY) >= 3 * abs(deltaX)) {
inZoom=true;
inRotation=false;
}
else {
}
x = qMouseEv->x();
y = qMouseEv->y();
}
if (inZoom) {
// Zoom
deltaY = qMouseEv->y() - y;
glMainWidget->getScene()->zoom(-deltaY/2);
y = qMouseEv->y();
}
if(inRotation) {
// Rotation
deltaX = qMouseEv->x() - x;
glMainWidget->getScene()->rotateScene(0,0,deltaX);
x = qMouseEv->x();
}
glMainWidget->draw();
return true;
}
return false;
}
void
KdmThemer::widgetEvent( QEvent *e )
{
if (!rootItem)
return;
switch (e->type()) {
case QEvent::MouseMove:
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
rootItem->mouseEvent( me->x(), me->y() );
}
break;
case QEvent::MouseButtonPress:
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
rootItem->mouseEvent( me->x(), me->y(), true );
}
break;
case QEvent::MouseButtonRelease:
{
QMouseEvent *me = static_cast<QMouseEvent *>(e);
rootItem->mouseEvent( me->x(), me->y(), false, true );
}
break;
case QEvent::Resize:
m_geometryOutdated = true;
widget()->update();
break;
case QEvent::Paint:
if (m_geometryOutdated) {
debug() << "==== updating geometry ====" << endl;
QStack<QSize> ps;
QRect rect( QPoint( 0, 0 ), widget()->size() );
rootItem->setGeometry( ps, rect, m_geometryInvalid );
if (debugLevel & DEBUG_THEMING)
showStructure();
m_geometryOutdated = m_geometryInvalid = false;
}
{
QRect paintRect = static_cast<QPaintEvent *>(e)->rect();
//kDebug() << "paint on: " << paintRect;
QPainter p( widget() );
rootItem->paint( &p, paintRect );
rootItem->showWidget();
}
break;
default:
break;
}
}
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 Renderer::eventFilter(QObject *object, QEvent *event) {
if (object == image_label_ && event->type() == QEvent::MouseButtonPress) {
QMouseEvent *keyEvent = static_cast<QMouseEvent*>(event);
if (keyEvent->button() == Qt::LeftButton && print_zp_) {
// Sets the fixed frequency of the zoneplate to the corresponding
// frequency of the click location
double dist = sqrt(keyEvent->x()*keyEvent->x() + keyEvent->y()*keyEvent->y());
dist = zone_plate_.Size() * dist / std::max(Height(), Width());
freq_spin_->setValue(dist);
return true;
} else
return false;
}
return false;
}
void PWidget::eventMouse(QObject *, QEvent *e)
{
PukeMessage pm;
widgetId wI;
QMouseEvent *me = Q_MOUSE_EVENT(e);
wI = widgetIden();
pm.iCommand = - e->type() - 1020; // 1020 offset for events
pm.iWinId = wI.iWinId;
pm.iArg = 0;
// special cArg handling
pm.iTextSize = 4*sizeof(int);
int *icArg = new int[4];
icArg[0] = me->x();
icArg[1] = me->y();
icArg[2] = me->button();
icArg[3] = me->state();
pm.cArg = (char *) icArg;
emit outputMessage(wI.fd, &pm);
delete[] icArg;
}
MouseEvent::MouseEvent(const QMouseEvent& event, const unsigned int deviceID) :
x(event.x()),
y(event.y()),
deviceID(deviceID),
isLeftButton(event.buttons().testFlag(Qt::LeftButton)),
isRightButton(event.buttons().testFlag(Qt::RightButton)),
isMiddleButton(event.buttons().testFlag(Qt::MiddleButton)),
isShifted(event.modifiers().testFlag(Qt::ShiftModifier)),
isControl(event.modifiers().testFlag(Qt::ControlModifier)),
isMeta(event.modifiers().testFlag(Qt::MetaModifier)),
isAlt(event.modifiers().testFlag(Qt::AltModifier))
{
// single button that caused the event
switch (event.button()) {
case Qt::LeftButton:
button = "LEFT";
isLeftButton = true;
break;
case Qt::RightButton:
button = "RIGHT";
isRightButton = true;
break;
case Qt::MiddleButton:
button = "MIDDLE";
isMiddleButton = true;
break;
default:
button = "NONE";
break;
}
}
bool TopBar::eventFilter(QObject *object, QEvent *event) {
if(object == ui->buttonIcon) {
if(event->type() == QEvent::MouseButtonPress) {
canMoveTopbar = true;
QMouseEvent *e = (QMouseEvent *)event;
pressedMouseX = e->x();
pressedMouseY = e->y();
event->accept();
} else if (event->type() == QEvent::MouseMove) {
if(canMoveTopbar) {
QMouseEvent *e = (QMouseEvent *)event;
ui->buttonIcon->setCursor(Qt::ClosedHandCursor);
move(e->globalX() - pressedMouseX, e->globalY() - pressedMouseY);
}
} else if(event->type() == QEvent::MouseButtonRelease) {
canMoveTopbar = false;
ui->buttonIcon->setCursor(Qt::OpenHandCursor);
event->accept();
} else if(event->type() == QEvent::Enter) {
ui->buttonIcon->setCursor(Qt::OpenHandCursor);
}
}
return QObject::eventFilter(object, event);
}
bool GameWindow::event(QEvent *event)
{
QMouseEvent *mouseEvent;
float deltaX = this->width() * 0.5f;
float deltaY = this->height() * 0.5f;
switch (event->type())
{
case QEvent::MouseMove:
if(cursorCaptured) {
mouseEvent = static_cast<QMouseEvent*>(event);
camera->rotate(-(deltaY - mouseEvent->y()) * 0.1f,
0,
-(deltaX - mouseEvent->x()) * 0.1f
);
}
return true;
case QEvent::MouseButtonPress:
this->setCursor(*cursor);
cursorCaptured = true;
return true;
case QEvent::UpdateRequest:
renderNow();
return true;
default:
return QWindow::event(event);
}
}
bool NodeTableDelegate::editorEvent ( QEvent* event,
QAbstractItemModel* model,
const QStyleOptionViewItem& option,
const QModelIndex& index )
{
if ( index.column() != 2 )
return false;
QMouseEvent *mouseEvent;
if ( event->type() == QEvent::MouseButtonRelease ) {
mouseEvent = static_cast<QMouseEvent*>( event );
QRect checkBoxRect1 = getCheckBoxDrawArea( option );
QRect checkBoxRect2 = getCheckBoxDrawArea( option, false );
if ( checkBoxRect1.contains( mouseEvent->x(), mouseEvent->y() ) )
{
bool xCheckState, yCheckState;
getCheckStates( xCheckState, yCheckState, index );
Node::Fixation fixType =
getFixationByCheckStates( ! xCheckState, yCheckState );
QVariant fixation;
qVariantSetValue<Node::Fixation>( fixation, fixType );
model->setData( index, fixation );
emit cellWasChanged( index.row(), index.column() );
}
else if ( checkBoxRect2.contains( mouseEvent->x(), mouseEvent->y() ) )
{
bool xCheckState, yCheckState;
getCheckStates( xCheckState, yCheckState, index );
Node::Fixation fixType =
getFixationByCheckStates( xCheckState, ! yCheckState );
QVariant fixation;
qVariantSetValue<Node::Fixation>( fixation, fixType );
model->setData( index, fixation );
emit cellWasChanged( index.row(), index.column() );
}
}
return true;
}
//===============================================================
bool MouseElementDeleter::eventFilter(QObject *widget, QEvent *e) {
QMouseEvent *qMouseEv = (QMouseEvent *) e;
if(qMouseEv != NULL) {
node tmpNode;
edge tmpEdge;
ElementType type;
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
if(e->type() == QEvent::MouseMove) {
if (glMainWidget->doSelect(qMouseEv->x(), qMouseEv->y(), type, tmpNode, tmpEdge)) {
glMainWidget->setCursor(QCursor(QPixmap(":/i_del.png")));
}
else {
glMainWidget->setCursor(Qt::ArrowCursor);
}
return false;
}
else if (e->type() == QEvent::MouseButtonPress && qMouseEv->button()==Qt::LeftButton) {
if (glMainWidget->doSelect(qMouseEv->x(), qMouseEv->y(), type, tmpNode, tmpEdge)) {
Observable::holdObservers();
Graph* graph = glMainWidget->getGraph();
// allow to undo
graph->push();
switch(type) {
case NODE:
graph->delNode(tmpNode);
break;
case EDGE:
graph->delEdge(tmpEdge);
break;
}
glMainWidget->redraw();
Observable::unholdObservers();
return true;
}
}
}
return false;
}
void wl_input_wait(struct wl_input_event *ev, int sleep)
{
WikiDisplay *display = window->display;
QWaitCondition *w = display->waitCondition;
QMutex mutex;
ev->type = -1;
do {
mutex.lock();
if (sleep && display->keyEventQueue->isEmpty() && display->mouseEventQueue->isEmpty()) {
w->wait(&mutex);
}
if (!display->keyEventQueue->isEmpty()) {
display->keyQueueMutex->lock();
QKeyEvent keyEvent = display->keyEventQueue->dequeue();
display->keyQueueMutex->unlock();
ev->type = WL_INPUT_EV_TYPE_KEYBOARD;
/* determine key type */
if (keyEvent.key() == Qt::Key_Down) {
ev->key_event.keycode = WL_INPUT_KEY_CURSOR_DOWN;
ev->type = WL_INPUT_EV_TYPE_CURSOR;
} else if (keyEvent.key() == Qt::Key_Up) {
ev->key_event.keycode = WL_INPUT_KEY_CURSOR_UP;
ev->type = WL_INPUT_EV_TYPE_CURSOR;
} else if (keyEvent.text().length() > 0) {
ev->key_event.keycode = keyEvent.text().at(0).unicode();
} else {
ev->key_event.keycode = keyEvent.key();
}
switch (keyEvent.type()) {
case QEvent::KeyPress:
ev->key_event.value = 1;
break;
case QEvent::KeyRelease:
ev->key_event.value = 0;
break;
default:
break;
}
}
if (!display->mouseEventQueue->isEmpty()) {
display->mouseQueueMutex->lock();
QMouseEvent mouseEvent = display->mouseEventQueue->dequeue();
display->mouseQueueMutex->unlock();
ev->type = WL_INPUT_EV_TYPE_TOUCH;
ev->touch_event.x = mouseEvent.x();
ev->touch_event.y = mouseEvent.y();
ev->touch_event.value = (mouseEvent.type() == QEvent::MouseButtonPress) ? 1 : 0;
}
mutex.unlock();
} while (ev->type == -1 && sleep);
}
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;
}
void GAllEvents::storeMouseState(QEvent *event)
{
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
this->nX = mouseEvent->x();
this->nY = mouseEvent->y();
this->nGlobalX = mouseEvent->globalX();
this->nGlobalY = mouseEvent->globalY();
this->nButton = mouseEvent->button();
this->nButtons = mouseEvent->buttons();
}
bool MouseEventFilter::eventFilter(QObject * obj, QEvent * evnt)
{
if (evnt->type() == QEvent::MouseButtonPress)
{
QMouseEvent* m = static_cast<QMouseEvent*>(evnt);
qDebug() << "X: " << m->x() << "Y: " << m->y();
m->setAccepted(true);
return true;
}
return false;
}
// Event filter of the interactor component (main function of the interactor component)
bool InteractorPluginComponent::eventFilter(QObject *widget, QEvent *e) {
if (e->type() == QEvent::MouseButtonRelease) {
QMouseEvent * qMouseEv = (QMouseEvent *) e;
GlMainWidget *glMainWidget = (GlMainWidget *) widget;
if (qMouseEv->button()== Qt::LeftButton) {
// Enter here if we have released the left button of the mouse
// doSelect function return node/edge under the mouse
node tmpNode;
edge tmpEdge;
ElementType type;
bool result = glMainWidget->doSelect(qMouseEv->x(), qMouseEv->y(), type, tmpNode, tmpEdge);
if (result) {
// Enter here if we have node/edge under the mouse
// Store selection property
Graph *graph=glMainWidget->getScene()->getGlGraphComposite()->getInputData()->getGraph();
string selectionPropertyName=glMainWidget->getScene()->getGlGraphComposite()->getInputData()->getElementSelectedPropName();
BooleanProperty* selection=graph->getProperty<BooleanProperty>(selectionPropertyName);
// Before do any think on the graph, we push the current state of the graph (this activate the undo/redo system)
graph->push();
// Deselect all nodes/edges
selection->setAllNodeValue(false);
selection->setAllEdgeValue(false);
switch(type) {
case NODE:
// Set selection at true for selected node
selection->setNodeValue(tmpNode, true);
break;
case EDGE:
// Set selection at false for selected edge
selection->setEdgeValue(tmpEdge, true);
break;
}
// We have treated the event so we return true
// (this event will not be passed to others interactorComponent)
return true;
}
}
}
// We don't have treated the event so we return false
// (this event will be passed to others interactorComponent)
return false;
}
bool RichTextDelegate::editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index)
{
if (event->type() == QEvent::MouseButtonPress) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
if (mouseEvent->button() == Qt::LeftButton && mouseEvent->x() - option.rect.left() < 18 && model->hasChildren(index)) {
QTreeView *tree = static_cast<QTreeView *>(parent());
tree->setExpanded(index, !tree->isExpanded(index));
return true;
}
}
return false;
}
void compare_mouse_event(QSignalSpy& spy,
const QMouseEvent& expected_event) const
{
spy.wait(_wait_ms);
BOOST_CHECK_EQUAL(spy.count(), 1);
QList<QVariant> arguments = spy.takeFirst();
BOOST_CHECK_EQUAL(arguments.at(0).toInt(), expected_event.x());
BOOST_CHECK_EQUAL(arguments.at(1).toInt(), expected_event.y());
BOOST_CHECK_EQUAL(arguments.at(2).value<Qt::MouseButtons>(),
expected_event.buttons());
}
bool MouseMagnifyingGlassInteractorComponent::eventFilter(QObject *, QEvent *e) {
bool updateMagnifyingGlass = false;
Coord screenCoords;
if (e->type() == QEvent::MouseMove) {
QMouseEvent *me = static_cast<QMouseEvent *>(e);
float x = glWidget->width() - me->x();
float y = me->y();
screenCoords = Coord(x, y, 0);
boxCenter = camera->viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
updateMagnifyingGlass = true;
}
else if (e->type() == QEvent::Wheel) {
QWheelEvent *wheelEvent = (QWheelEvent *) e;
float x = glWidget->width() - wheelEvent->x();
float y = wheelEvent->y();
screenCoords = Coord(x, y, 0);
boxCenter = camera->viewportTo3DWorld(glWidget->screenToViewport(screenCoords));
int numDegrees = wheelEvent->delta() / 8;
int numSteps = numDegrees / 15;
if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ControlModifier)) {
updateMagnifyingGlass = true;
radius += numSteps;
if (radius < 1) radius = 1;
delete fbo;
delete fbo2;
fbo = NULL;
fbo2 = NULL;
}
else if (wheelEvent->orientation() == Qt::Vertical && (wheelEvent->modifiers() == Qt::ShiftModifier)) {
updateMagnifyingGlass = true;
magnifyPower += numSteps;
if (magnifyPower < 1) magnifyPower = 1;
}
}
static bool canUseFbo = QGLFramebufferObject::hasOpenGLFramebufferObjects();
if (canUseFbo && updateMagnifyingGlass) {
generateMagnifyingGlassTexture(screenCoords);
drawInteractor = true;
glWidget->redraw();
return true;
}
return false;
}
bool SkinsWidget::eventFilter(QObject *obj, QEvent *event) {
if(obj == close_button) {
if(event->type() == QEvent::Enter){
close_button->setPixmap(QPixmap(":/pixmap/image/closeBtn-hover.png"));
}else if(event->type() == QEvent::Leave){
close_button->setPixmap(QPixmap(":/pixmap/image/closeBtn.png"));
}else if(event->type() == QEvent::MouseButtonPress){
close_button->setPixmap(QPixmap(":/pixmap/image/closeBtn-hover.png"));
}else if(event->type() == QEvent::MouseButtonRelease){
QMouseEvent *me = (QMouseEvent *)event;
QLabel *lb = (QLabel *)obj;
if(me->x() > 0 && me->x() < lb->width() && me->y() > 0 && me->y() < lb->height()){
this->hide();
}else{
close_button->setPixmap(QPixmap(":/pixmap/image/closeBtn.png"));
}
} else {
return QObject::eventFilter(obj, event);
}
}
return QObject::eventFilter(obj, event);
}
bool TestProjectWindow::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::KeyRelease) {
QKeyEvent * keyEvent = static_cast <QKeyEvent *> (event);
if (keyEvent->key() == Qt::Key_Left) {
this->selectImage(selected - 1);
}
if (keyEvent->key() == Qt::Key_Right) {
this->selectImage(selected + 1);
}
}
if (obj->objectName() == "image" && (event->type() == QEvent::MouseButtonRelease)) {
QMouseEvent * mouseEvent = static_cast <QMouseEvent *> (event);
if (mouseEvent->button() == 1) {
this->addPoint(mouseEvent->x(), mouseEvent->y());
} else {
this->removePoint(mouseEvent->x(), mouseEvent->y());
}
}
return false;
}
bool MainWindow::eventFilter(QObject *target, QEvent *event)
{
auto imagePaint = [&](QLabel* imageLabel, QImage& img) -> bool
{
if (imageLabel != nullptr)
{
QPaintEvent* paintEvent = dynamic_cast<QPaintEvent*>(event);
if (paintEvent != nullptr && !img.isNull())
{
QPainter painter(imageLabel);
if (ui->scrollArea->widgetResizable())
{
painter.drawImage(0,0, img.scaled(paintEvent->rect().size()));
}
else
{
painter.drawImage(paintEvent->rect(), img, paintEvent->rect());
}
return true;
}
}
return false;
};
if ((target == ui->imageLabel1 || target == ui->imageLabel2)
&& event->type() == QEvent::MouseMove)
{
QMouseEvent* mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (mouseEvent != nullptr)
{
currentX = mouseEvent->x();
currentY = mouseEvent->y();
updateStatusBar();
ui->imageLabel1->update();
ui->imageLabel2->update();
}
}
else if ((target == ui->imageLabel1 || target == ui->imageLabel2)
&& event->type() == QEvent::Paint)
{
int cam = target == ui->imageLabel1 ? 0 : 1;
return imagePaint(dynamic_cast<QLabel*>(target), currentQImage[cam]);
}
else if (target == ui->depthMapLabel && event->type() == QEvent::Paint)
{
return imagePaint(dynamic_cast<QLabel*>(target), depthQImage);
}
return QMainWindow::eventFilter(target, event);
}
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;
}
/** event filter */
bool EmoticonDialog::eventFilter(QObject * object, QEvent * event) {
if ((event->type() == QEvent::MouseButtonPress) && ((QLabel*) object == m_pLabel)) {
QMouseEvent * e = (QMouseEvent*) event;
m_nX = e->x();
m_nY = e->y();
//printf("EVENT %d %d!\n",e->x(),e->y());
accept();
}
return QWidget::eventFilter(object, event); // standard event processing
}
