RMouseEvent::RMouseEvent(const QMouseEvent& mouseEvent, RGraphicsScene& s,
RGraphicsView& v, qreal devicePixelRatio) :
QMouseEvent(mouseEvent),
RInputEvent(RVector(mouseEvent.posF().x(), mouseEvent.posF().y()), s, v, devicePixelRatio) {
setAccepted(mouseEvent.isAccepted());
}
bool CaptureWgt::eventFilter( QObject * o, QEvent * e )
{
if ( e->type() == QEvent::MouseButtonPress )
{
QMouseEvent * m = reinterpret_cast<QMouseEvent *>( e );
pd->crossPos( this, m->posF() );
}
return false;
}
bool KisToolProxy::forwardEvent(ActionState state, KisTool::ToolAction action, QEvent *event, QEvent *originalEvent, QTabletEvent *lastTabletEvent, const QPoint &canvasOriginWorkaround)
{
bool retval = true;
QTabletEvent *tabletEvent = dynamic_cast<QTabletEvent*>(event);
QTouchEvent *touchEvent = dynamic_cast<QTouchEvent*>(event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
if (tabletEvent) {
QPointF docPoint = tabletToDocument(tabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
tabletEvent->accept();
this->tabletEvent(tabletEvent, docPoint);
forwardToTool(state, action, tabletEvent, docPoint);
retval = tabletEvent->isAccepted();
} else if (touchEvent) {
if (state == END && touchEvent->type() != QEvent::TouchEnd) {
//Fake a touch end if we are "upgrading" a single-touch gesture to a multi-touch gesture.
QTouchEvent fakeEvent(QEvent::TouchEnd, touchEvent->deviceType(), touchEvent->modifiers(), touchEvent->touchPointStates(), touchEvent->touchPoints());
this->touchEvent(&fakeEvent);
} else {
this->touchEvent(touchEvent);
}
} else if (mouseEvent) {
if (lastTabletEvent) {
QPointF docPoint = tabletToDocument(lastTabletEvent->hiResGlobalPos(), canvasOriginWorkaround);
lastTabletEvent->accept();
this->tabletEvent(lastTabletEvent, docPoint);
forwardToTool(state, action, lastTabletEvent, docPoint);
retval = lastTabletEvent->isAccepted();
} else {
QPointF docPoint = widgetToDocument(mouseEvent->posF());
mouseEvent->accept();
if (mouseEvent->type() == QEvent::MouseButtonPress) {
mousePressEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonDblClick) {
mouseDoubleClickEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseButtonRelease) {
mouseReleaseEvent(mouseEvent, docPoint);
} else if (mouseEvent->type() == QEvent::MouseMove) {
mouseMoveEvent(mouseEvent, docPoint);
}
forwardToTool(state, action, originalEvent, docPoint);
retval = mouseEvent->isAccepted();
}
} else if(event->type() == QEvent::KeyPress) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyPressEvent(kevent);
} else if(event->type() == QEvent::KeyRelease) {
QKeyEvent* kevent = static_cast<QKeyEvent*>(event);
keyReleaseEvent(kevent);
}
return retval;
}
bool CaptureWgt::eventFilter( QObject * o, QEvent * e )
{
if ( e->type() == QEvent::MouseButtonPress )
{
QMouseEvent * m = reinterpret_cast<QMouseEvent *>( e );
if ( pd->ui.cross->isChecked() )
{
pd->crossPos( this, m->posF() );
// Save to file if checked.
if ( pd->ui.cross->isChecked() )
updateCrossPos( true );
}
if ( pd->modifyLaserPos )
{
pd->laserPos( this, m->posF() );
// Always save it to a file.
updateCrossPos( true );
}
}
return false;
}
dmz::V8Value
dmz::JsModuleUiV8QtBasic::_mouse_event_posf (const v8::Arguments &Args) {
v8::HandleScope scope;
V8Object result;
JsModuleUiV8QtBasic *self = _to_self (Args);
if (self) {
QMouseEvent *event = (QMouseEvent *)self->_to_qevent (Args.This ());
if (event) {
QPointF pos = event->posF ();
result = v8::Object::New ();
result->Set(v8::String::NewSymbol ("x"), v8::Number::New (pos.x ()));
result->Set(v8::String::NewSymbol ("y"), v8::Number::New (pos.y ()));
}
}
return scope.Close (result);
}
void KisToolProxy::forwardHoverEvent(QEvent *event)
{
switch (event->type()) {
case QEvent::TabletMove: {
QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
QPointF docPoint = widgetToDocument(tabletEvent->posF());
this->tabletEvent(tabletEvent, docPoint);
return;
}
case QEvent::MouseMove: {
QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
QPointF docPoint = widgetToDocument(mouseEvent->posF());
mouseMoveEvent(mouseEvent, docPoint);
return;
}
default: {
qWarning() << "forwardHoverEvent encountered unknown event type.";
return;
}
}
}
RMouseEvent::RMouseEvent(const QMouseEvent& mouseEvent, RGraphicsScene& s,
RGraphicsView& v) :
QMouseEvent(mouseEvent),
RInputEvent(RVector(mouseEvent.posF().x(), mouseEvent.posF().y()), s, v) {
}
QGestureRecognizer::Result SingleClickGestureRecognizer::recognize (QGesture* gesture, QObject* watched, QEvent* event)
{
//g_message("%s", __PRETTY_FUNCTION__);
QGestureRecognizer::Result result = QGestureRecognizer::Ignore;
SingleClickGesture* singleClickGesture = static_cast<SingleClickGesture*>(gesture);
static int s_tapRadius = -1;
if (G_UNLIKELY(s_tapRadius < 0))
s_tapRadius = Settings::LunaSettings()->tapRadius;
static uint32_t s_lastDblClickTime = 0;
if (watched == singleClickGesture && event->type() == QEvent::Timer) {
singleClickGesture->stopSingleClickTimer();
if (singleClickGesture->state() != Qt::GestureCanceled
&& singleClickGesture->state() != Qt::GestureFinished)
{
if (!singleClickGesture->m_mouseDown) {
result = QGestureRecognizer::FinishGesture | QGestureRecognizer::ConsumeEventHint;
}
else {
result |= QGestureRecognizer::ConsumeEventHint;
singleClickGesture->m_triggerSingleClickOnRelease = true;
}
// if finger down at the same location for longer than the timer,
// the single tap has to be triggered after the release
}
return result;
}
switch (event->type()) {
case QEvent::TouchBegin:
case QEvent::TouchUpdate:
case QEvent::TouchEnd:
{
if (singleClickGesture->state() == Qt::GestureStarted
|| singleClickGesture->state() == Qt::GestureUpdated)
{
QTouchEvent* touchEvent = static_cast<const QTouchEvent *>(event);
// this starts the gesture, so dont check existing state
if (touchEvent->touchPoints().size() > 1) {
singleClickGesture->m_triggerSingleClickOnRelease = false;
singleClickGesture->stopSingleClickTimer();
result = QGestureRecognizer::CancelGesture;
}
}
break;
}
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
case QEvent::MouseButtonPress:
{
QMouseEvent* mouseEvent = static_cast<const QMouseEvent *>(event);
singleClickGesture->stopSingleClickTimer();
singleClickGesture->m_penDownPos = mouseEvent->posF();
singleClickGesture->setHotSpot (mouseEvent->globalPos());
singleClickGesture->m_mouseDown = true;
singleClickGesture->m_triggerSingleClickOnRelease = false;
singleClickGesture->m_modifiers = mouseEvent->modifiers();
result = QGestureRecognizer::TriggerGesture;
singleClickGesture->startSingleClickTimer();
break;
}
case QEvent::MouseMove:
if (singleClickGesture->state() == Qt::GestureStarted
|| singleClickGesture->state() == Qt::GestureUpdated)
{
QMouseEvent* mouseEvent = static_cast<const QMouseEvent *>(event);
int moveDistance = (int) qAbs(QLineF (mouseEvent->posF(), singleClickGesture->m_penDownPos).length());
if (moveDistance > s_tapRadius)
{
// move is outside tap radius or multiple fingers are down, so this is not a tap
singleClickGesture->stopSingleClickTimer();
singleClickGesture->m_triggerSingleClickOnRelease = false;
result = QGestureRecognizer::CancelGesture;
}
}
break;
case QEvent::MouseButtonRelease:
if (singleClickGesture->state() == Qt::GestureStarted
|| singleClickGesture->state() == Qt::GestureUpdated) {
singleClickGesture->m_mouseDown = false;
if (singleClickGesture->m_triggerSingleClickOnRelease) {
result = QGestureRecognizer::FinishGesture;
singleClickGesture->m_triggerSingleClickOnRelease = false;
}
}
if(G_UNLIKELY(g_logSingleClick)){
g_message("SYSMGR PERF: Single Click Occurred time:%d", Time::curTimeMs());
}
break;
case QEvent::MouseButtonDblClick:
if (singleClickGesture->state() == Qt::GestureStarted
|| singleClickGesture->state() == Qt::GestureUpdated)
{
singleClickGesture->stopSingleClickTimer();
singleClickGesture->m_triggerSingleClickOnRelease = false;
result = QGestureRecognizer::CancelGesture;
}
break;
#endif // QT_VERSION < 5.0.0
default:
break;
}
return result;
}
bool KisMirrorAxis::eventFilter(QObject* target, QEvent* event)
{
if(event->type() == QEvent::MouseButtonPress || event->type() == QEvent::TabletPress) {
QMouseEvent* me = static_cast<QMouseEvent*>(event);
if(d->mirrorHorizontal && d->horizontalHandle.contains(me->posF())) {
d->xActive = true;
QApplication::setOverrideCursor(Qt::ClosedHandCursor);
event->accept();
return true;
}
if(d->mirrorVertical && d->verticalHandle.contains(me->posF())) {
d->yActive = true;
QApplication::setOverrideCursor(Qt::ClosedHandCursor);
event->accept();
return true;
}
}
if(event->type() == QEvent::MouseMove || event->type() == QEvent::TabletMove) {
QMouseEvent* me = static_cast<QMouseEvent*>(event);
if(d->xActive) {
float axisX = view()->viewConverter()->widgetToImage<QPoint>(me->pos()).x();
d->setAxisPosition(axisX, d->axisPosition.y());
d->horizontalHandlePosition = KisAlgebra2D::dotProduct<QPointF>(me->pos() - d->horizontalAxis.p1(), d->horizontalAxis.unitVector().p2() - d->horizontalAxis.p1());
event->accept();
return true;
}
if(d->yActive) {
float axisY = view()->viewConverter()->widgetToImage<QPoint>(me->pos()).y();
d->setAxisPosition(d->axisPosition.x(), axisY);
d->verticalHandlePosition = KisAlgebra2D::dotProduct<QPointF>(me->pos() - d->verticalAxis.p1(), d->verticalAxis.unitVector().p2() - d->verticalAxis.p1());
event->accept();
return true;
}
if(d->mirrorHorizontal) {
if(d->horizontalHandle.contains(me->posF())) {
if(!d->horizontalContainsCursor) {
QApplication::setOverrideCursor(Qt::OpenHandCursor);
d->horizontalContainsCursor = true;
}
} else if(d->horizontalContainsCursor) {
QApplication::restoreOverrideCursor();
d->horizontalContainsCursor = false;
}
}
if(d->mirrorVertical) {
if(d->verticalHandle.contains(me->posF())) {
if(!d->verticalContainsCursor) {
QApplication::setOverrideCursor(Qt::OpenHandCursor);
d->verticalContainsCursor = true;
}
} else if(d->verticalContainsCursor) {
QApplication::restoreOverrideCursor();
d->verticalContainsCursor = false;
}
}
}
if(event->type() == QEvent::MouseButtonRelease || event->type() == QEvent::TabletRelease) {
QApplication::restoreOverrideCursor();
if(d->xActive) {
d->xActive = false;
event->accept();
return true;
}
if(d->yActive) {
d->yActive = false;
event->accept();
return true;
}
}
return QObject::eventFilter(target, event);
}
void KisChangePrimarySettingAction::end(QEvent *event)
{
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ShiftModifier);
inputManager()->toolProxy()->mouseReleaseEvent(&targetEvent, inputManager()->widgetToPixel(mouseEvent->posF()));
KisAbstractInputAction::end(event);
}
void KisChangePrimarySettingAction::begin(int shortcut, QEvent *event)
{
KisAbstractInputAction::begin(shortcut, event);
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(QEvent::MouseButtonPress, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ShiftModifier);
inputManager()->toolProxy()->mousePressEvent(&targetEvent, inputManager()->widgetToPixel(mouseEvent->posF()));
}
void KisAlternateInvocationAction::end(QEvent *event)
{
QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
QMouseEvent targetEvent(*mouseEvent);
switch (m_savedShortcut) {
case PrimaryAlternateToggleShortcut:
targetEvent = QMouseEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier);
break;
case SecondaryAlternateToggleShortcut:
targetEvent = QMouseEvent(QEvent::MouseButtonRelease, mouseEvent->pos(), Qt::LeftButton, Qt::LeftButton, Qt::ControlModifier | Qt::AltModifier);
break;
}
inputManager()->toolProxy()->mouseReleaseEvent(&targetEvent, inputManager()->widgetToPixel(mouseEvent->posF()));
KisAbstractInputAction::end(event);
}
