/*
* Intercept wheel events from comboBox.
*/
bool
Aperture::eventFilter( QObject *target, QEvent *event )
{
if( (target == comboBox) && (event->type() == QEvent::Wheel) ) {
QWheelEvent *wheelEvent = static_cast<QWheelEvent *>(event);
int step;
if( wheelEvent->delta() < 0 ) step = -1;
else step = +1;
int row = comboBox->currentIndex();
int col = comboBox->modelColumn();
int index = row * maxCols + col;
index += step;
if( index < 0 ) index = 0;
if( index > n-1 ) index = n-1;
row = index / maxCols;
col = index % maxCols;
comboBox->setCurrentIndex( row );
comboBox->setModelColumn( col );
if( n > 0 ) {
emit propertyChanged( kEdsPropID_Av, v[index] );
}
return( true );
}
return( QWidget::eventFilter( target, event ) );
}
bool QtSystemTrayIcon::eventFilter(QObject* object, QEvent* event) {
if (QObject::eventFilter(object, event)) return true;
if (object != tray_) return false;
if (event->type() == QEvent::Wheel) {
QWheelEvent* e = static_cast<QWheelEvent*>(event);
if (e->modifiers() == Qt::ShiftModifier) {
if (e->delta() > 0) {
emit SeekForward();
} else {
emit SeekBackward();
}
} else if (e->modifiers() == Qt::ControlModifier) {
if (e->delta() < 0) {
emit NextTrack();
} else {
emit PreviousTrack();
}
} else {
emit ChangeVolume(e->delta());
}
return true;
}
return false;
}
bool csFontResizer::eventFilter(QObject *watched, QEvent *event)
{
if( event->type() == QEvent::KeyPress ) {
QKeyEvent *keyEvent = dynamic_cast<QKeyEvent*>(event);
if( keyEvent->matches(QKeySequence::ZoomIn) ||
(keyEvent->modifiers() == Qt::ControlModifier &&
keyEvent->key() == Qt::Key_BracketRight) ) {
resizeFont(watched, 0, incSize);
return true;
} else if( keyEvent->matches(QKeySequence::ZoomOut) ) {
resizeFont(watched, 0, -incSize);
return true;
} else if( keyEvent->modifiers() == Qt::ControlModifier &&
keyEvent->key() == Qt::Key_0 ) {
resizeFont(watched, defSize.value(dynamic_cast<QWidget*>(watched), 0));
return true;
}
} else if( event->type() == QEvent::Wheel ) {
QWheelEvent *wheelEvent = dynamic_cast<QWheelEvent*>(event);
if( wheelEvent->modifiers() == Qt::ControlModifier &&
wheelEvent->delta() > 0 ) {
resizeFont(watched, 0, incSize);
return true;
} else if( wheelEvent->modifiers() == Qt::ControlModifier &&
wheelEvent->delta() < 0 ) {
resizeFont(watched, 0, -incSize);
return true;
}
}
return QObject::eventFilter(watched, event);
}
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);
}
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 ();
}
}
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;
}
bool TrayIcon::eventFilter(QObject *object, QEvent *event)
{
if (object == legacyTrayIcon_.data() && event->type() == QEvent::Wheel) {
QWheelEvent *wheelEvent = static_cast<QWheelEvent*>(event);
const int steps = (wheelEvent->delta()>0) ? 1 : (wheelEvent->delta()<0) ? -1: 0;
if (steps > 0) {
emit activated(WHEELUP);
}
else {
emit activated(WHEELDOWN);
}
return true;
}
return false;
}
void Camera::OnWheelEvent(const QWheelEvent & event)
{
if (event.delta() > 0 ) //coup de molette vers le haut
{
_verticalMotionActive = true;
_timeBeforeStoppingVerticalMotion = 250;
_verticalMotionDirection = 1;
}
else if (event.delta() < 0) //coup de molette vers le bas
{
_verticalMotionActive = true;
_timeBeforeStoppingVerticalMotion = 250;
_verticalMotionDirection = -1;
}
}
bool PaletteDockerDock::eventFilter(QObject* object, QEvent* event)
{
if (object == m_wdgPaletteDock->paletteView->viewport() && event->type() == QEvent::Wheel) {
QWheelEvent* qwheel = dynamic_cast<QWheelEvent* >(event);
if (qwheel->modifiers() & Qt::ControlModifier) {
int numDegrees = qwheel->delta() / 8;
int numSteps = numDegrees / 7;
int curSize = m_wdgPaletteDock->paletteView->horizontalHeader()->sectionSize(0);
int setSize = numSteps + curSize;
if ( setSize >= 12 ) {
m_wdgPaletteDock->paletteView->horizontalHeader()->setDefaultSectionSize(setSize);
m_wdgPaletteDock->paletteView->verticalHeader()->setDefaultSectionSize(setSize);
KisConfig cfg;
cfg.setPaletteDockerPaletteViewSectionSize(setSize);
}
return true;
} else {
return false;
}
} else {
return QWidget::eventFilter(object, event);
}
}
bool ZoomEventFilter::eventFilter (QObject *viewObj, QEvent *someEvent)
{
if (someEvent->type () != QEvent::Wheel)
return false;
QWheelEvent *e = static_cast<QWheelEvent*> (someEvent);
if (!(e->modifiers () & Qt::ControlModifier))
return false;
int degrees = e->delta () / 8;
int steps = static_cast<qreal> (degrees) / 15;
QWebView *view = qobject_cast<QWebView*> (viewObj);
if (e->modifiers () & Qt::ShiftModifier)
{
auto multiplier = view->textSizeMultiplier ();
multiplier += steps * 0.1;
view->setTextSizeMultiplier (multiplier);
}
else
{
QWebSettings *settings = view->settings ();
settings->setFontSize (QWebSettings::DefaultFontSize,
std::max (6, settings->fontSize (QWebSettings::DefaultFontSize) + steps));
auto frame = view->page ()->mainFrame ();
frame->evaluateJavaScript ("setTimeout(ScrollToBottom,0);");
}
return true;
}
bool GUI_TrayIcon::event ( QEvent * e ) {
if (e->type ()== QEvent::Wheel) {
QWheelEvent * wheelEvent = dynamic_cast <QWheelEvent *> (e);
emit onVolumeChangedByWheel (wheelEvent->delta());
}
return true;
}
bool MainWindow::eventFilter(QObject* obj, QEvent* event) {
if(event->type() == QEvent::Wheel) {
if(obj == ui->graphicsView) {
QWheelEvent* wheel = (QWheelEvent*) event;
//Ensure that [-240 <= delta <= +240]
qreal delta = fmax(fmin(240, (qreal)wheel->delta()), -240);
qreal scale = ((delta / 4.0) / 120.0) + 1.0;
QTransform t = ui->graphicsView->transform();
t.scale(scale, scale);
//Prevent excessive zooming
if(t.m11() > 0.1 && t.m11() < 4.0) {
ui->graphicsView->setTransform(t);
}
return true;
}
else if(obj == ui->graphicsView->verticalScrollBar()) {
return true;
}
}
return false;
}
bool BaseViewer::zoomOnWheelEvent(QEvent * e)
{
if (e->type() == QEvent::Wheel)
{
QWheelEvent * event = static_cast<QWheelEvent*>(e);
// mouse has X units that covers 360 degrees. Zoom when 15 degrees is provided
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
QPoint numDegrees = event->angleDelta() / 8;
#else
QPoint numDegrees(0,event->delta() / 8);
#endif
if (!numDegrees.isNull())
{
if (numDegrees.y() >= 15)
{ // Zoom in
if (_zoomLevel+1<=_zoomMaxLevel)
centerOnAtZoom(_zoomLevel+1);
}
else if (numDegrees.y() <= -15)
{ // Zoom out
if (_zoomLevel-1>=_zoomMinLevel)
centerOnAtZoom(_zoomLevel-1);
}
event->accept();
return true;
}
return true;
}
return false;
}
/*!
\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 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;
}
// Применение изменений по вращении колеса мыши
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();
}
}
}
void ViewerInputController::handleEvent(QEvent *event)
{
if (event->type() == QEvent::MouseButtonPress)
{
QMouseEvent *mouseEvent = (QMouseEvent *)event;
ptrMousePosition = mouseEvent->pos();
isMousePressed = true;
}
else if (event->type() == QEvent::MouseButtonRelease)
{
isMousePressed = false;
}
else if (event->type() == QEvent::MouseMove)
{
QMouseEvent *mouseEvent = (QMouseEvent *)event;
if (isMousePressed)
{
QPoint diff = mouseEvent->pos() - ptrMousePosition;
m_camera->rotateAroundCenter(diff * MOUSE_SPEED);
ptrMousePosition = mouseEvent->pos();
}
}
else if (event->type() == QEvent::Wheel)
{
QWheelEvent *wheelEvent = (QWheelEvent *)event;
m_camera->moveForward(WHEEL_SPEED * wheelEvent->delta());
}
}
bool DataInspectionDialog::eventFilter(QObject *t, QEvent *e)
{
if (e->type() == QEvent::Wheel) {
QWheelEvent *we = static_cast<QWheelEvent *>(e);
int s = we->delta()/120;
if (t == CoronalLabel) {
int slice = qMin(qMax(imgRow+s,0),nRows-1);
if (slice != imgRow) {
imgRow = slice;
plotCoronal(imgRow);
}
}
else if (t == SagittalLabel) {
int slice = qMin(qMax(imgCol+s,0),nCols-1);
if (slice != imgCol) {
imgCol = slice;
plotSagittal(imgCol);
}
}
else if (t == AxialLabel) {
int slice = qMin(qMax(imgSlice+s,0),nSlices-1);
if (slice != imgSlice) {
imgSlice = slice;
plotAxial(imgSlice);
}
}
}
// this is a must otherwise keys are not handled
return QDialog::eventFilter(t,e);
}
// Extract event-specific arguments to co::Any array
void EventHub::extractArguments( QEvent* event, co::Any* args, int maxArgs )
{
QEvent::Type ev = event->type();
switch( ev )
{
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseMove:
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>( event );
// extract (x and y), button, modifiers
const QPoint& pos = mouseEvent->pos();
args[0].set( pos.x() );
args[1].set( pos.y() );
args[2].set( static_cast<co::uint32>( ev == QEvent::MouseMove ?
mouseEvent->buttons() : mouseEvent->button() ) );
fillKeyboardModifiers( mouseEvent->modifiers(), args[3] );
}
break;
case QEvent::KeyPress:
case QEvent::KeyRelease:
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>( event );
fillKeyCodeString( keyEvent->key(), args[0] );
fillKeyboardModifiers( keyEvent->modifiers(), args[1] );
}
break;
case QEvent::Wheel:
{
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>( event );
// extract position (x and y ), delta, modifiers
const QPoint& pos = wheelEvent->pos();
args[0].set( pos.x() );
args[1].set( pos.x() );
args[2].set( wheelEvent->delta() );
fillKeyboardModifiers( wheelEvent->modifiers(), args[3] );
}
break;
case QEvent::Resize:
{
QResizeEvent* resizeEvent = static_cast<QResizeEvent*>( event );
// extract size (width and height) and oldSize (width and height)
const QSize& size = resizeEvent->size();
const QSize& oldSize = resizeEvent->oldSize();
args[0].set( size.width() );
args[1].set( size.height() );
args[2].set( oldSize.width() );
args[3].set( oldSize.height() );
}
break;
default:
// Close, Show and Hide require no arguments
return;
}
}
void MainWindow::on_actionZoom_In_triggered(){
QWheelEvent *event;
double scaleFactor = 1.15;
if(event->delta() > 0) {
// Zoom in
graphicsView->scale(scaleFactor, scaleFactor);
}
}
void MainWindow::on_actionZoom_Out_triggered(){
QWheelEvent *event;
double scaleFactor = 1.15;
if(event->delta() > 0) {
// Zoom out
graphicsView->scale(1.0 / scaleFactor, 1.0 / scaleFactor);
}
}
void TControl::OnWheelEvent(QWheelEvent event) {
World->Power += 0.06 * event.delta();
if (World->Power < 0) {
World->Power = 0;
}
if (World->Power > 100) {
World->Power = 100;
}
}
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);
}
bool qtDLGDisassembler::eventFilter(QObject *pObject, QEvent *event)
{
if(event->type() == QEvent::Wheel && pObject == tblDisAs)
{
QWheelEvent *pWheel = (QWheelEvent*)event;
OnDisAsScroll(pWheel->delta() * -1);
return true;
}
return false;
}
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 PopupItem::eventFilter( QObject *object, QEvent *e )
{
MarbleWidget *widget = dynamic_cast<MarbleWidget*> ( object );
if ( !widget ) {
return BillboardGraphicsItem::eventFilter( object, e );
}
if ( e->type() == QEvent::MouseButtonDblClick
|| e->type() == QEvent::MouseMove
|| e->type() == QEvent::MouseButtonPress
|| e->type() == QEvent::MouseButtonRelease )
{
// Mouse events are forwarded to the underlying widget
QMouseEvent *event = static_cast<QMouseEvent*> ( e );
QPoint const shiftedPos = transform( event->pos() );
bool const forcedMouseRelease = m_needMouseRelease && e->type() == QEvent::MouseButtonRelease;
if ( !shiftedPos.isNull() || forcedMouseRelease ) {
if ( !m_needMouseRelease && e->type() == QEvent::MouseButtonPress ) {
m_needMouseRelease = true;
} else if ( forcedMouseRelease ) {
m_needMouseRelease = false;
}
widget->setCursor( Qt::ArrowCursor );
// transform to children's coordinates
QMouseEvent shiftedEvent = QMouseEvent( e->type(), shiftedPos,
event->globalPos(), event->button(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( m_webView, &shiftedEvent ) ) {
widget->setCursor( m_webView->cursor() );
emit dirty();
return true;
}
}
} else if ( e->type() == QEvent::Wheel ) {
// Wheel events are forwarded to the underlying widget
QWheelEvent *event = static_cast<QWheelEvent*> ( e );
QPoint const shiftedPos = transform( event->pos() );
if ( !shiftedPos.isNull() ) {
widget->setCursor( Qt::ArrowCursor );
QWheelEvent shiftedEvent = QWheelEvent( shiftedPos,
event->globalPos(), event->delta(), event->buttons(),
event->modifiers() );
if ( QApplication::sendEvent( m_webView, &shiftedEvent ) ) {
widget->setCursor( m_webView->cursor() );
emit dirty();
return true;
}
}
}
return BillboardGraphicsItem::eventFilter( object, e );
}
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);
}
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;
}
bool ContentAwareResizeTool::eventFilter(QObject* obj, QEvent* ev)
{
if (d->weightMaskBox->isChecked())
{
if (obj == d->previewWidget)
{
if (ev->type() == QEvent::Wheel)
{
QWheelEvent* wheel = static_cast<QWheelEvent *>(ev);
if (wheel->delta() >= 0)
d->maskPenSize->setValue(d->maskPenSize->value() + (wheel->delta()/8/15)*(wheel->delta()/8/15));
else
d->maskPenSize->setValue(d->maskPenSize->value() - (wheel->delta()/8/15)*(wheel->delta()/8/15));
d->previewWidget->setMaskCursor();
}
}
}
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);
}
