/*
* 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 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 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 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 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);
}
/*!
\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 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 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);
}
// Применение изменений по вращении колеса мыши
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 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;
}
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 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 imageCompareBase::eventFilter(QObject* watched, QEvent* event) {
// make sure we setCur on an image click
if (event->type() == QEvent::FocusIn) {
if (watched == leftScroll_) {
setCur(leftImage());
}
else {
setCur(rightImage());
}
}
else if (event->type() == QEvent::KeyPress) {
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
return filterKeyEvent(keyEvent);
}
else if (event->type() == QEvent::Wheel) {
QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event);
// shift scroll should give a horizontal scroll
if (wheelEvent->modifiers() == Qt::ShiftModifier) {
// must check both the scroll and its viewport
if (watched == rightScroll_ || watched == rightScroll_->viewport()) {
rightScroll_->horizontalScrollBar()->event(event);
return true;
}
else if (watched == leftScroll_ || watched == leftScroll_->viewport()) {
leftScroll_->horizontalScrollBar()->event(event);
return true;
}
}
}
return imageSaverWindow::eventFilter(watched, event);
}
// 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_Out_triggered(){
QWheelEvent *event;
double scaleFactor = 1.15;
if(event->delta() > 0) {
// Zoom out
graphicsView->scale(1.0 / scaleFactor, 1.0 / scaleFactor);
}
}
void MainWindow::on_actionZoom_In_triggered(){
QWheelEvent *event;
double scaleFactor = 1.15;
if(event->delta() > 0) {
// Zoom in
graphicsView->scale(scaleFactor, scaleFactor);
}
}
bool Widget::eventFilter(QObject *, QEvent *event)
{
if (event->type() == QEvent::Wheel)
{
QWheelEvent * whlEvnt = static_cast< QWheelEvent * >( event );
whlEvnt->angleDelta().setX(0);
}
return false;
}
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 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 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 );
}
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;
}
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 MainWindow::eventFilter(QObject *target, QEvent *event)
{
switch(event->type())
{
case QEvent::Wheel:
if(target == &songWindow)
{
QWheelEvent* wEvent = (QWheelEvent*)event;
long timeRange = settings->getViewTimeRange() - wEvent->delta();
timeRange = timeRange < 1000 ? 1000 : timeRange > 10000 ? 10000 : timeRange;
settings->setViewTimeRange(timeRange);
settingsWindow.refresh();
return true;
}
break;
case QEvent::KeyPress:
keyPressEvent((QKeyEvent*)event);
break;
case QEvent::ApplicationActivate:
bringToTop();
return true;
case QEvent::Hide:
if(target == &songWindow) ui->songCheckbox->setChecked(false);
else if(target == & playlist) ui->playlistCheckbox->setChecked(false);
else if(target == & outputSettings) ui->outputCheckbox->setChecked(false);
else if(target == & settingsWindow) ui->settingsCheckbox->setChecked(false);
else if(target == & tutorial) ui->tutorialCheckbox->setChecked(false);
else if(target == & songSearch) ui->songSearchCheckbox->setChecked(false);
break;
case QEvent::Show:
if(target == &songWindow) ui->songCheckbox->setChecked(true);
else if(target == &playlist) ui->playlistCheckbox->setChecked(true);
else if(target == &outputSettings) ui->outputCheckbox->setChecked(true);
else if(target == &settingsWindow) ui->settingsCheckbox->setChecked(true);
else if(target == & tutorial) ui->tutorialCheckbox->setChecked(true);
else if(target == & songSearch) ui->songSearchCheckbox->setChecked(true);
if(target == &songWindow || target == &playlist || target == &outputSettings ||
target == &songSearch || target == &settingsWindow)
((QWidget*)target)->setFocus();
break;
default:
return false;
}
return false;
}
/******************************************************************************
* Receives events destined for the spin widget or for the edit field.
*/
bool SpinBox::eventFilter(QObject* obj, QEvent* e)
{
if (obj == lineEdit())
{
int step = 0;
switch (e->type())
{
case QEvent::KeyPress:
{
// Up and down arrow keys step the value
QKeyEvent* ke = (QKeyEvent*)e;
int key = ke->key();
if (key == Qt::Key_Up)
step = 1;
else if (key == Qt::Key_Down)
step = -1;
break;
}
case QEvent::Wheel:
{
QWheelEvent* we = (QWheelEvent*)e;
step = (we->delta() > 0) ? 1 : -1;
break;
}
default:
break;
}
if (step)
{
if (mReadOnly)
return true; // discard up/down arrow keys
QInputEvent* ie = (QInputEvent*)e;
if ((ie->modifiers() & (Qt::ShiftModifier | Qt::AltModifier)) == Qt::ShiftModifier)
{
// Shift stepping
int val = value();
if (step > 0)
step = mLineShiftStep - val % mLineShiftStep;
else
step = - ((val + mLineShiftStep - 1) % mLineShiftStep + 1);
}
else
step = (step > 0) ? mLineStep : -mLineStep;
addValue(step, false);
return true;
}
}
return QSpinBox::eventFilter(obj, e);
}
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 qtDLGHexView::wheelEvent(QWheelEvent *event)
{
QWheelEvent *pWheel = (QWheelEvent*)event;
if(pWheel->delta() > 0)
{
memoryScroll->setValue(memoryScroll->value() - 1);
InsertDataFrom(-1);
}
else
{
memoryScroll->setValue(memoryScroll->value() + 1);
InsertDataFrom(1);
}
}
void qtDLGFunctions::wheelEvent(QWheelEvent *event)
{
QWheelEvent *pWheel = (QWheelEvent*)event;
if(pWheel->delta() > 0)
{
functionScroll->setValue(functionScroll->value() - 1);
InsertDataFrom(-1);
}
else
{
functionScroll->setValue(functionScroll->value() + 1);
InsertDataFrom(1);
}
}
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);
}
