/*!
\reimp
*/
bool QScrollBar::event(QEvent *event)
{
switch(event->type()) {
case QEvent::HoverEnter:
case QEvent::HoverLeave:
case QEvent::HoverMove:
if (const QHoverEvent *he = static_cast<const QHoverEvent *>(event))
d_func()->updateHoverControl(he->pos());
break;
#ifndef QT_NO_WHEELEVENT
case QEvent::Wheel: {
event->ignore();
// override wheel event without adding virtual function override
QWheelEvent *ev = static_cast<QWheelEvent *>(event);
int delta = ev->delta();
// scrollbar is a special case - in vertical mode it reaches minimum
// value in the upper position, however QSlider's minimum value is on
// the bottom. So we need to invert a value, but since the scrollbar is
// inverted by default, we need to inverse the delta value for the
// horizontal orientation.
if (ev->orientation() == Qt::Horizontal)
delta = -delta;
Q_D(QScrollBar);
if (d->scrollByDelta(ev->orientation(), ev->modifiers(), delta))
event->accept();
return true;
}
#endif
default:
break;
}
return QAbstractSlider::event(event);
}
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 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;
}
// Применение изменений по вращении колеса мыши
void QWheelZoomSvc::applyWheel(QEvent *event,bool ax,bool ay)
{
// приводим тип QEvent к QWheelEvent
QWheelEvent *wEvent = static_cast<QWheelEvent *>(event);
// если вращается вертикальное колесо мыши
if (wEvent->orientation() == Qt::Vertical)
{
// определяем угол поворота колеса мыши
// (значение 120 соответствует углу поворота 15°)
int wd = wEvent->delta();
// вычисляем масштабирующий множитель
// (во сколько раз будет увеличен/уменьшен график)
double kw = sfact*wd/120;
if (wd != 0) // если колесо вращалось, то
{
// фиксируем исходные границы графика (если этого еще не было сделано)
zoom->fixBounds();
// получаем указатель на график
QwtPlot *plt = zoom->plot();
if (ax) // если задано масштабирование по горизонтали
{
// получаем карту основной горизонтальной шкалы
QwtScaleMap sm = plt->canvasMap(zoom->masterH());
// определяем центр отображаемого на шкале x интервала
double mx = (sm.s1()+sm.s2())/2;
// и полуширину интервала
double dx = (sm.s2()-sm.s1())/2;
// в зависимости от знака угла поворота колеса мыши
// уменьшаем полуширину отображаемых интервалов в kw раз
if (wd > 0) dx /= kw;
// или увеличиваем полуширину отображаемых интервалов в -kw раз
else dx *= -kw;
// устанавливаем новые левую и правую границы шкалы для оси x
// (центр изображаемой части графика остается на месте,
// а границы удаляются от центра, т.о. изображение графика уменьшается)
zoom->isb_x->set(mx-dx,mx+dx);
}
if (ay) // если задано масштабирование по вертикали
{
// получаем карту основной вертикальной шкалы
QwtScaleMap sm = plt->canvasMap(zoom->masterV());
// определяем центр отображаемого на шкале y интервала
double my = (sm.s1()+sm.s2())/2;
// и полуширину интервала
double dy = (sm.s2()-sm.s1())/2;
// в зависимости от знака угла поворота колеса мыши
// уменьшаем полуширину отображаемых интервалов в kw раз
if (wd > 0) dy /= kw;
// увеличиваем полуширину отображаемых интервалов в -kw раз
else dy *= -kw;
// устанавливаем новые нижнюю и верхнюю границы вертикальной шкалы
// (центр изображаемой части графика остается на месте,
// а границы удаляются от центра, т.о. изображение графика уменьшается)
zoom->isb_y->set(my-dy,my+dy);
}
// перестраиваем график (синхронно с остальными)
plt->replot();
}
}
}
bool QWheelArea::event(QEvent *e)
{
switch (e->type()) {
case QEvent::GraphicsSceneWheel: {
QGraphicsSceneWheelEvent *we = static_cast<QGraphicsSceneWheelEvent *>(e);
if (we->orientation() == Qt::Vertical)
setVerticalDelta(we->delta());
else
setHorizontalDelta(we->delta());
return true;
}
case QEvent::Wheel: {
QWheelEvent *we = static_cast<QWheelEvent *>(e);
if (we->orientation() == Qt::Vertical)
setVerticalDelta(we->delta());
else
setHorizontalDelta(we->delta());
return true;
}
default:
break;
}
return QDeclarativeItem::event(e);
}
bool OffscreenSurface::eventFilter(QObject* originalDestination, QEvent* event) {
if (!filterEnabled(originalDestination, event)) {
return false;
}
#ifdef DEBUG
// Don't intercept our own events, or we enter an infinite recursion
{
auto rootItem = _sharedObject->getRootItem();
auto quickWindow = _sharedObject->getWindow();
QObject* recurseTest = originalDestination;
while (recurseTest) {
Q_ASSERT(recurseTest != rootItem && recurseTest != quickWindow);
recurseTest = recurseTest->parent();
}
}
#endif
switch (event->type()) {
case QEvent::KeyPress:
case QEvent::KeyRelease: {
event->ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), event)) {
return event->isAccepted();
}
break;
}
case QEvent::Wheel: {
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(wheelEvent->pos());
QWheelEvent mappedEvent(transformedPos, wheelEvent->delta(), wheelEvent->buttons(), wheelEvent->modifiers(),
wheelEvent->orientation());
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
case QEvent::MouseMove: {
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(mouseEvent->localPos());
QMouseEvent mappedEvent(mouseEvent->type(), transformedPos, mouseEvent->screenPos(), mouseEvent->button(),
mouseEvent->buttons(), mouseEvent->modifiers());
if (event->type() == QEvent::MouseMove) {
// TODO - this line necessary for the QML Tooltop to work (which is not currently being used), but it causes interface to crash on launch on a fresh install
// need to investigate into why this crash is happening.
//_qmlContext->setContextProperty("lastMousePosition", transformedPos);
}
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
default:
break;
}
return false;
}
bool pHexEdit::QtHexEditScrollBar::event(QEvent* event) {
if(event->type() == QEvent::Wheel) {
QWheelEvent* wheelEvent = (QWheelEvent*)event;
if(wheelEvent->orientation() == Qt::Vertical) {
signed offset = wheelEvent->delta() < 0 ? +1 : -1;
self.scrollTo(sliderPosition() + offset);
return true;
}
}
return QScrollBar::event(event);
}
void wheelEvent (State& state, const QWheelEvent& event) {
if (event.orientation () == Qt::Vertical) {
if (event.delta () > 0) {
state.camera ().stepAlongGaze (this->zoomInFactor);
}
else if (event.delta () < 0) {
state.camera ().stepAlongGaze (1.0f / this->zoomInFactor);
}
state.mainWindow ().mainWidget ().glWidget ().update ();
}
}
bool WebPage::event(QEvent *ev)
{
QMouseEvent* mouseEvent = NULL;
QWheelEvent* wheelEvent = NULL;
QKeyEvent* keyEvent = NULL;
QByteArray byteArray;
QBuffer buffer(&byteArray);
buffer.open(QIODevice::ReadWrite);
QDataStream out(&buffer);
out << (int) ev->type();
switch (ev->type()) {
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonRelease:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;
mouseEvent = (static_cast<QMouseEvent*>(ev));
out << mouseEvent->pos() << mouseEvent->globalPos()
<< (int) mouseEvent->button() << (int) mouseEvent->buttons()
<< (int) mouseEvent->modifiers();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
case QEvent::Wheel:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;;
wheelEvent = (static_cast<QWheelEvent*>(ev));
out << wheelEvent->pos() << wheelEvent->globalPos()
<< wheelEvent->delta() << (int) wheelEvent->buttons()
<< (int) wheelEvent->modifiers() << (int) wheelEvent->orientation();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
case QEvent::KeyPress:
case QEvent::KeyRelease:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;
keyEvent = (static_cast<QKeyEvent*>(ev));
out << keyEvent->key() << (int) keyEvent->modifiers()
<< keyEvent->text() << keyEvent->isAutoRepeat()
<< (int) keyEvent->count();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
default:
break;
}
return QWebPage::event(ev);
}
ToolResponse runWheelEvent (const QWheelEvent& e) {
if (e.orientation () == Qt::Vertical && e.modifiers () == Qt::ShiftModifier) {
if (e.delta () > 0) {
this->radiusEdit.setIntValue ( this->radiusEdit.intValue ()
+ this->radiusEdit.intSingleStep () );
}
else if (e.delta () < 0) {
this->radiusEdit.setIntValue ( this->radiusEdit.intValue ()
- this->radiusEdit.intSingleStep () );
}
}
return ToolResponse::Redraw;
}
QString KisTabletDebugger::eventToString(const QWheelEvent &ev, const QString &prefix)
{
QString string;
QTextStream s(&string);
dumpBaseParams(s, ev, prefix);
dumpMouseRelatedParams(s, ev);
s << "delta: " << ev.delta() << " ";
s << "orientation: " << (ev.orientation() == Qt::Horizontal ? "H" : "V") << " ";
return string;
}
virtual bool eventFilter( QObject *object, QEvent *event )
{
if ( event->type() == QEvent::Wheel )
{
QWheelEvent *we = ( QWheelEvent * )event;
QWheelEvent wheelEvent( QPoint( 5, 5 ), we->delta(),
we->buttons(), we->modifiers(),
we->orientation() );
QApplication::sendEvent( this, &wheelEvent );
return true;
}
return QwtWheel::eventFilter( object, event );
}
void WebView::mouseWheelTimerFired()
{
pMouseWheelTimer_->stop();
if (mouseWheelEvents_.empty())
return;
int totalDelta = 0;
for (int i = 0; i < mouseWheelEvents_.length(); i++)
{
totalDelta += mouseWheelEvents_.at(i).delta();
}
QWheelEvent event = mouseWheelEvents_.last();
mouseWheelEvents_.clear();
while (totalDelta != 0)
{
// If the absolute delta value exceeds 5000, Ace editor
// goes into a super fine granularity mode that we need
// to avoid
const int MAX_ABS_DELTA_VALUE = 5000;
int thisDelta = totalDelta;
if (thisDelta > MAX_ABS_DELTA_VALUE)
{
thisDelta = MAX_ABS_DELTA_VALUE;
}
else if (thisDelta < -MAX_ABS_DELTA_VALUE)
{
thisDelta = -MAX_ABS_DELTA_VALUE;
}
totalDelta -= thisDelta;
QWheelEvent totalEvent(event.pos(),
event.globalPos(),
thisDelta,
event.buttons(),
event.modifiers(),
event.orientation());
this->QWebView::wheelEvent(&totalEvent);
}
}
bool
ArtistInfoWidget::eventFilter( QObject* obj, QEvent* event )
{
if ( event->type() == QEvent::Wheel )
{
QWheelEvent* we = static_cast<QWheelEvent*>( event );
QWheelEvent* wheelEvent = new QWheelEvent(
we->pos(),
we->globalPos(),
we->delta(),
we->buttons(),
we->modifiers(),
we->orientation() );
qApp->postEvent( m_area->viewport(), wheelEvent );
event->accept();
return true;
}
else
return QObject::eventFilter( obj, event );
}
void WebView::mouseWheelTimerFired()
{
pMouseWheelTimer_->stop();
if (mouseWheelEvents_.empty())
return;
int totalDelta = 0;
for (int i = 0; i < mouseWheelEvents_.length(); i++)
{
totalDelta += mouseWheelEvents_.at(i).delta();
}
QWheelEvent event = mouseWheelEvents_.last();
mouseWheelEvents_.clear();
QWheelEvent totalEvent(event.pos(),
event.globalPos(),
totalDelta,
event.buttons(),
event.modifiers(),
event.orientation());
this->QWebView::wheelEvent(&totalEvent);
}
/* Checks for a focus out event. The display of the date is updated
* to display the proper date when the focus leaves.
*/
bool AnnotationDialog::KDateEdit::eventFilter(QObject *obj, QEvent *e)
{
if (obj == lineEdit()) {
if (e->type() == QEvent::Wheel) {
// Up and down arrow keys step the date
QWheelEvent* we = dynamic_cast<QWheelEvent*>(e);
Q_ASSERT( we != nullptr );
int step = 0;
step = we->delta() > 0 ? 1 : -1;
if (we->orientation() == Qt::Vertical) {
setDate( value.addDays(step) );
}
}
}
else {
// It's a date picker event
switch (e->type()) {
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress: {
QMouseEvent *me = (QMouseEvent*)e;
if (!mDateFrame->rect().contains(me->pos())) {
QPoint globalPos = mDateFrame->mapToGlobal(me->pos());
if (QApplication::widgetAt(globalPos) == this) {
// The date picker is being closed by a click on the
// KDateEdit widget. Avoid popping it up again immediately.
mDiscardNextMousePress = true;
}
}
break;
}
default:
break;
}
}
return false;
}
bool QWindowCompositor::eventFilter(QObject *obj, QEvent *event)
{
if (obj != m_window)
return false;
QWaylandInputDevice *input = defaultInputDevice();
switch (event->type()) {
case QEvent::Expose:
m_renderScheduler.start(0);
if (m_window->isExposed()) {
// Alt-tabbing away normally results in the alt remaining in
// pressed state in the clients xkb state. Prevent this by sending
// a release. This is not an issue in a "real" compositor but
// is very annoying when running in a regular window on xcb.
Qt::KeyboardModifiers mods = QGuiApplication::queryKeyboardModifiers();
if (m_modifiers != mods && input->keyboardFocus()) {
Qt::KeyboardModifiers stuckMods = m_modifiers ^ mods;
if (stuckMods & Qt::AltModifier)
input->sendKeyReleaseEvent(64); // native scancode for left alt
m_modifiers = mods;
}
}
break;
case QEvent::MouseButtonPress: {
QPointF local;
QMouseEvent *me = static_cast<QMouseEvent *>(event);
QWaylandSurface *targetSurface = surfaceAt(me->localPos(), &local);
if (m_dragKeyIsPressed && targetSurface) {
m_draggingWindow = targetSurface;
m_drag_diff = local;
} else {
if (targetSurface && input->keyboardFocus() != targetSurface) {
input->setKeyboardFocus(targetSurface);
m_surfaces.removeOne(targetSurface);
m_surfaces.append(targetSurface);
m_renderScheduler.start(0);
}
input->sendMousePressEvent(me->button(), local, me->localPos());
}
return true;
}
case QEvent::MouseButtonRelease: {
QWaylandSurface *targetSurface = input->mouseFocus();
if (m_draggingWindow) {
m_draggingWindow = 0;
m_drag_diff = QPointF();
} else {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
QPointF localPos;
if (targetSurface)
localPos = toSurface(targetSurface, me->localPos());
input->sendMouseReleaseEvent(me->button(), localPos, me->localPos());
}
return true;
}
case QEvent::MouseMove: {
QMouseEvent *me = static_cast<QMouseEvent *>(event);
if (m_draggingWindow) {
m_draggingWindow->setPos(me->localPos() - m_drag_diff);
m_renderScheduler.start(0);
} else {
QPointF local;
QWaylandSurface *targetSurface = surfaceAt(me->localPos(), &local);
input->sendMouseMoveEvent(targetSurface, local, me->localPos());
}
break;
}
case QEvent::Wheel: {
QWheelEvent *we = static_cast<QWheelEvent *>(event);
input->sendMouseWheelEvent(we->orientation(), we->delta());
break;
}
case QEvent::KeyPress: {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_Meta || ke->key() == Qt::Key_Super_L) {
m_dragKeyIsPressed = true;
}
m_modifiers = ke->modifiers();
QWaylandSurface *targetSurface = input->keyboardFocus();
if (targetSurface)
input->sendKeyPressEvent(ke->nativeScanCode());
break;
}
case QEvent::KeyRelease: {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
if (ke->key() == Qt::Key_Meta || ke->key() == Qt::Key_Super_L) {
m_dragKeyIsPressed = false;
}
m_modifiers = ke->modifiers();
QWaylandSurface *targetSurface = input->keyboardFocus();
if (targetSurface)
input->sendKeyReleaseEvent(ke->nativeScanCode());
break;
}
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
{
QWaylandSurface *targetSurface = 0;
QTouchEvent *te = static_cast<QTouchEvent *>(event);
QList<QTouchEvent::TouchPoint> points = te->touchPoints();
QPoint pointPos;
if (!points.isEmpty()) {
pointPos = points.at(0).pos().toPoint();
targetSurface = surfaceAt(pointPos);
}
if (targetSurface && targetSurface != input->mouseFocus())
input->setMouseFocus(targetSurface, pointPos, pointPos);
if (input->mouseFocus())
input->sendFullTouchEvent(te);
break;
}
default:
break;
}
return false;
}
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
QClipboard * clipboard = QApplication::clipboard(); //added by AiO
if ( obj == canvas->viewport() )
{
// paint
if ( event->type() == QEvent::Paint )
{
set_drawing_rectangle(canvas->viewport()->size().width(), canvas->viewport()->size().height());
QPainter p(canvas->viewport());
p.setPen(Qt::black);
p.setBrush(Qt::green);
PaintStruct ps;
ps.p = &p;
ps.border = 2;
drawGraph(&ps);
}
// mouse
else if ( event->type() == QEvent::MouseMove )
{
QMouseEvent *mevent = (QMouseEvent *) event;
if ( qApp->overrideCursor() )
{
//cursor is overridden, we are panning
if ( mevent->x() != ox || mevent->y() != oy )
{
move_focus(ox - mevent->x(), oy - mevent->y());
ox = mevent->x();
oy = mevent->y();
canvas->viewport()->update();
//update();
}
}
}
else if ( event->type() == QEvent::MouseButtonPress )
{
QMouseEvent *mevent = (QMouseEvent *) event;
if ( mevent->button() == Qt::LeftButton )
{
Qt::KeyboardModifiers mods = mevent->modifiers();
if (mods & Qt::ShiftModifier) zoomIn();
else if (mods & Qt::ControlModifier) zoomOut();
if ( !sticky )
{
qApp->setOverrideCursor(*MOVING_CURSOR);
}
else
{
if ( qApp->overrideCursor() )
{
//cursor is already overridden, release it
qApp->restoreOverrideCursor();
canvas->setMouseTracking(false);
}
else
{
qApp->setOverrideCursor(*MOVING_CURSOR);
canvas->setMouseTracking(true);
}
}
ox = mevent->x();
oy = mevent->y();
}
else if(mevent->button() == Qt::RightButton ) //Added by AiO
{
//query the cordinates of the mouse for node
char curNodeTitle[1024];
char * curNode;
char *index; //used for search
QMessageBox msgBox;
curNode = node_xy_title(mevent->x(),mevent->y());
if(curNode == 0) return true;
strncpy(curNodeTitle, curNode, 1024-1);
curNodeTitle[1024-1] = 0;
//label ends with ':'
//test for color characters format sym num num TEXT sym :
// replace : -1 with 0 and use &curNodeTitle[3]
//test with popup
if(curNodeTitle[0] == 0x0c)
{
index = strchr(curNodeTitle, ':');
if(index == 0) goto nocolon; //test for no label but color
--index;
--index;
--index;
*index = 0;
msgBox.setText(&curNodeTitle[3]);
clipboard->setText(&curNodeTitle[3]);
}
else
{
nocolon:
msgBox.setText(curNodeTitle);
clipboard->setText(curNodeTitle);
}
msgBox.exec();
}
}
else if ( event->type() == QEvent::MouseButtonRelease )
{
if ( !sticky )
qApp->restoreOverrideCursor();
}
// wheel
else if ( event->type() == QEvent::Wheel )
{
QWheelEvent *wevent = (QWheelEvent *) event;
if ( (qApp->keyboardModifiers() & Qt::ControlModifier) != 0 )
{
wevent->accept();
int numDegrees = wevent->delta() / 8;
int numSteps = numDegrees / 15;
if ( numSteps < 0)
{
numSteps = -numSteps;
for ( int x = 0; x < numSteps; x++ )
zoomOut();
}
else
{
for ( int x = 0; x < numSteps; x++ )
zoomIn();
}
return true;
}
else
{
bool ret = QMainWindow::eventFilter(obj, event);
QAbstractSlider *slider = (QAbstractSlider *) (wevent->orientation() == Qt::Vertical?
canvas->verticalScrollBar() :
canvas->horizontalScrollBar());
int ScrollPos = slider->sliderPosition();
bool reset_slider;
calc_scroll(QAbstractSlider::SliderMove + 100, ScrollPos, reset_slider);
slider->setSliderPosition(ScrollPos);
return ret;
}
}
// keyboard
else if ( event->type() == QEvent::KeyPress )
{
QKeyEvent *kevent = (QKeyEvent *) event;
int key = kevent->key();
KeyDown(key, kevent->modifiers());
if ( key == 0 )
{
event->accept();
return true;
}
}
}
return QMainWindow::eventFilter(obj, event);
}
// Handle events on behalf of the text area.
bool QsciScintillaBase::eventFilter(QObject *o, QEvent *e)
{
if (o != txtarea)
return QWidget::eventFilter(o, e);
bool used = true;
switch (e->type())
{
case QEvent::ContextMenu:
contextMenuEvent(static_cast<QContextMenuEvent *>(e));
break;
case QEvent::DragEnter:
dragEnterEvent(static_cast<QDragEnterEvent *>(e));
break;
case QEvent::DragLeave:
dragLeaveEvent(static_cast<QDragLeaveEvent *>(e));
break;
case QEvent::DragMove:
dragMoveEvent(static_cast<QDragMoveEvent *>(e));
break;
case QEvent::Drop:
dropEvent(static_cast<QDropEvent *>(e));
break;
case QEvent::MouseButtonDblClick:
mouseDoubleClickEvent(static_cast<QMouseEvent *>(e));
break;
case QEvent::MouseButtonPress:
mousePressEvent(static_cast<QMouseEvent *>(e));
break;
case QEvent::MouseButtonRelease:
mouseReleaseEvent(static_cast<QMouseEvent *>(e));
break;
case QEvent::MouseMove:
mouseMoveEvent(static_cast<QMouseEvent *>(e));
break;
case QEvent::Paint:
paintEvent(static_cast<QPaintEvent *>(e));
break;
case QEvent::Resize:
resizeEvent(static_cast<QResizeEvent *>(e));
break;
case QEvent::Wheel:
{
QWheelEvent *we = static_cast<QWheelEvent *>(e);
setFocus();
if (we->orientation() == Horizontal || we->state() & ShiftButton)
QApplication::sendEvent(hsb, we);
else if (we->orientation() == Vertical)
QApplication::sendEvent(vsb, we);
break;
}
default:
used = false;
}
return used;
}
bool OffscreenSurface::eventFilter(QObject* originalDestination, QEvent* event) {
if (!filterEnabled(originalDestination, event)) {
return false;
}
#ifdef DEBUG
// Don't intercept our own events, or we enter an infinite recursion
{
auto rootItem = _sharedObject->getRootItem();
auto quickWindow = _sharedObject->getWindow();
QObject* recurseTest = originalDestination;
while (recurseTest) {
Q_ASSERT(recurseTest != rootItem && recurseTest != quickWindow);
recurseTest = recurseTest->parent();
}
}
#endif
switch (event->type()) {
case QEvent::KeyPress:
case QEvent::KeyRelease: {
event->ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), event)) {
return event->isAccepted();
}
break;
}
case QEvent::Wheel: {
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(wheelEvent->pos());
QWheelEvent mappedEvent(transformedPos, wheelEvent->delta(), wheelEvent->buttons(), wheelEvent->modifiers(),
wheelEvent->orientation());
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
case QEvent::MouseMove: {
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
QPointF transformedPos = mapToVirtualScreen(mouseEvent->localPos());
QMouseEvent mappedEvent(mouseEvent->type(), transformedPos, mouseEvent->screenPos(), mouseEvent->button(),
mouseEvent->buttons(), mouseEvent->modifiers());
mappedEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &mappedEvent)) {
return mappedEvent.isAccepted();
}
break;
}
#if defined(Q_OS_ANDROID)
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd: {
QTouchEvent *originalEvent = static_cast<QTouchEvent *>(event);
QEvent::Type fakeMouseEventType = QEvent::None;
Qt::MouseButton fakeMouseButton = Qt::LeftButton;
Qt::MouseButtons fakeMouseButtons = Qt::NoButton;
switch (event->type()) {
case QEvent::TouchBegin:
fakeMouseEventType = QEvent::MouseButtonPress;
fakeMouseButtons = Qt::LeftButton;
break;
case QEvent::TouchUpdate:
fakeMouseEventType = QEvent::MouseMove;
fakeMouseButtons = Qt::LeftButton;
break;
case QEvent::TouchEnd:
fakeMouseEventType = QEvent::MouseButtonRelease;
fakeMouseButtons = Qt::NoButton;
break;
}
// Same case as OffscreenUi.cpp::eventFilter: touch events are always being accepted so we now use mouse events and consider one touch, touchPoints()[0].
QMouseEvent fakeMouseEvent(fakeMouseEventType, originalEvent->touchPoints()[0].pos(), fakeMouseButton, fakeMouseButtons, Qt::NoModifier);
fakeMouseEvent.ignore();
if (QCoreApplication::sendEvent(_sharedObject->getWindow(), &fakeMouseEvent)) {
/*qInfo() << __FUNCTION__ << "sent fake touch event:" << fakeMouseEvent.type()
<< "_quickWindow handled it... accepted:" << fakeMouseEvent.isAccepted();*/
return fakeMouseEvent.isAccepted();
}
break;
}
case QEvent::InputMethod:
case QEvent::InputMethodQuery: {
auto window = getWindow();
if (window && window->activeFocusItem()) {
event->ignore();
if (QCoreApplication::sendEvent(window->activeFocusItem(), event)) {
bool eventAccepted = event->isAccepted();
if (event->type() == QEvent::InputMethodQuery) {
QInputMethodQueryEvent *imqEvent = static_cast<QInputMethodQueryEvent *>(event);
// this block disables the selection cursor in android which appears in
// the top-left corner of the screen
if (imqEvent->queries() & Qt::ImEnabled) {
imqEvent->setValue(Qt::ImEnabled, QVariant(false));
}
}
return eventAccepted;
}
return false;
}
break;
}
#endif
default:
break;
}
return false;
}
bool SimpleKeyGrabberButton::eventFilter(QObject *obj, QEvent *event)
{
Q_UNUSED(obj);
int controlcode = 0;
if (grabNextAction && event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = (QMouseEvent*) event;
if (mouseEve->button() == Qt::RightButton)
{
controlcode = 3;
}
else if (mouseEve->button() == Qt::MiddleButton)
{
controlcode = 2;
}
else {
controlcode = mouseEve->button();
}
setText(QString(tr("Mouse")).append(" ").append(QString::number(controlcode)));
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
releaseMouse();
releaseKeyboard();
grabNextAction = grabbingWheel = false;
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::KeyRelease)
{
QKeyEvent *keyEve = (QKeyEvent*) event;
int tempcode = keyEve->nativeScanCode();
int virtualactual = keyEve->nativeVirtualKey();
#ifdef Q_OS_WIN
// Find more specific virtual key (VK_SHIFT -> VK_LSHIFT)
// by checking for extended bit in scan code.
int finalvirtual = WinInfo::correctVirtualKey(tempcode, virtualactual);
int checkalias = AntKeyMapper::returnQtKey(virtualactual, tempcode);
#else
// Obtain group 1 X11 keysym. Removes effects from modifiers.
int finalvirtual = X11KeyCodeToX11KeySym(tempcode);
// Check for alias against group 1 keysym.
int checkalias = AntKeyMapper::returnQtKey(finalvirtual);
#endif
controlcode = tempcode;
if ((keyEve->modifiers() & Qt::ControlModifier) && keyEve->key() == Qt::Key_X)
{
controlcode = 0;
setText("");
}
else if (controlcode <= 0)
{
controlcode = 0;
setText("");
}
else
{
if (checkalias > 0)
{
buttonslot.setSlotCode(finalvirtual, checkalias);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKey(finalvirtual, checkalias).toUpper());
}
else
{
buttonslot.setSlotCode(virtualactual);
buttonslot.setSlotMode(JoyButtonSlot::JoyKeyboard);
setText(keysymToKey(finalvirtual).toUpper());
}
}
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
emit buttonCodeChanged(controlcode);
}
else if (grabNextAction && event->type() == QEvent::Wheel && !grabbingWheel)
{
grabbingWheel = true;
}
else if (grabNextAction && event->type() == QEvent::Wheel)
{
QWheelEvent *wheelEve = (QWheelEvent*) event;
QString text = QString(tr("Mouse")).append(" ");
if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() >= 120)
{
controlcode = 4;
}
else if (wheelEve->orientation() == Qt::Vertical && wheelEve->delta() <= -120)
{
controlcode = 5;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() >= 120)
{
controlcode = 6;
}
else if (wheelEve->orientation() == Qt::Horizontal && wheelEve->delta() <= -120)
{
controlcode = 7;
}
if (controlcode > 0)
{
text = text.append(QString::number(controlcode));
setText(text);
grabNextAction = false;
grabbingWheel = false;
releaseMouse();
releaseKeyboard();
buttonslot.setSlotCode(controlcode);
buttonslot.setSlotMode(JoyButtonSlot::JoyMouseButton);
emit buttonCodeChanged(controlcode);
}
}
else if (event->type() == QEvent::MouseButtonRelease)
{
QMouseEvent *mouseEve = (QMouseEvent*) event;
if (mouseEve->button() == Qt::LeftButton)
{
grabNextAction = true;
setText("...");
setFocus();
grabKeyboard();
grabMouse();
}
}
return false;
}
void QtEventConsumer::handleWheelEvent ( QObject *obj, QEvent *event )
{
// check the object
QWidget *widget = isValidWidget(obj);
if (!widget){
DEBUG(D_CONSUMER,"(QtEventConsumer::handleWheelEvent) No widget to handle");
return;
}
DEBUG(D_CONSUMER,"(QtEventConsumer::handleWheelEvent)");
QWheelEvent *we = dynamic_cast<QWheelEvent*> ( event );
//create the event
QOE::QOE_MouseWheel qoe;
qoe.timestamp(_timer.restart());
completeBasicData(qoe,widget);
qoe.delta(we->delta());
qoe.orientation(we->orientation());
qoe.buttons(we->buttons());
qoe.modifiers(we->modifiers());
///sensitive value
completeSensitiveData(qoe, widget);
//send event if qoe is valid
if (isValidQOE(qoe) && isValidQOEMouse(qoe))
sendNewTestItem(qoe);
}
