void
QGuiApplicationPrivate
::
processWindowSystemEvent
(
QWindowSystemInterfacePrivate
::
WindowSystemEvent
*
e
)
{
Q_TRACE_SCOPE
(
QGuiApplicationPrivate_processWindowSystemEvent
,
e
->
type
)
;
switch
(
e
->
type
)
{
case
QWindowSystemInterfacePrivate
::
Mouse
:
QGuiApplicationPrivate
::
processMouseEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Wheel
:
QGuiApplicationPrivate
::
processWheelEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Key
:
QGuiApplicationPrivate
::
processKeyEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Touch
:
QGuiApplicationPrivate
::
processTouchEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
GeometryChange
:
QGuiApplicationPrivate
::
processGeometryChangeEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Enter
:
QGuiApplicationPrivate
::
processEnterEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Leave
:
QGuiApplicationPrivate
::
processLeaveEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ActivatedWindow
:
QGuiApplicationPrivate
::
processActivatedEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
WindowStateChanged
:
QGuiApplicationPrivate
::
processWindowStateChangedEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
WindowScreenChanged
:
QGuiApplicationPrivate
::
processWindowScreenChangedEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
SafeAreaMarginsChanged
:
QGuiApplicationPrivate
::
processSafeAreaMarginsChangedEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ApplicationStateChanged
:
{
QWindowSystemInterfacePrivate
::
ApplicationStateChangedEvent
*
changeEvent
=
static_cast

(
e
)
;
QGuiApplicationPrivate
::
setApplicationState
(
changeEvent
->
newState
,
changeEvent
->
forcePropagate
)
;
}
break
;
case
QWindowSystemInterfacePrivate
::
FlushEvents
:
{
QWindowSystemInterfacePrivate
::
FlushEventsEvent
*
flushEventsEvent
=
static_cast

(
e
)
;
QWindowSystemInterface
::
deferredFlushWindowSystemEvents
(
flushEventsEvent
->
flags
)
;
}
break
;
case
QWindowSystemInterfacePrivate
::
Close
:
QGuiApplicationPrivate
::
processCloseEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ScreenOrientation
:
QGuiApplicationPrivate
::
processScreenOrientationChange
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ScreenGeometry
:
QGuiApplicationPrivate
::
processScreenGeometryChange
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ScreenLogicalDotsPerInch
:
QGuiApplicationPrivate
::
processScreenLogicalDotsPerInchChange
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ScreenRefreshRate
:
QGuiApplicationPrivate
::
processScreenRefreshRateChange
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
ThemeChange
:
QGuiApplicationPrivate
::
processThemeChanged
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Expose
:
QGuiApplicationPrivate
::
processExposeEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
Tablet
:
QGuiApplicationPrivate
::
processTabletEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
TabletEnterProximity
:
QGuiApplicationPrivate
::
processTabletEnterProximityEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
TabletLeaveProximity
:
QGuiApplicationPrivate
::
processTabletLeaveProximityEvent
(
static_cast

(
e
)
)
;
break
;
#ifndef QT_NO_GESTURES
case
QWindowSystemInterfacePrivate
::
Gesture
:
QGuiApplicationPrivate
::
processGestureEvent
(
static_cast

(
e
)
)
;
break
;
#endif
case
QWindowSystemInterfacePrivate
::
PlatformPanel
:
QGuiApplicationPrivate
::
processPlatformPanelEvent
(
static_cast

(
e
)
)
;
break
;
case
QWindowSystemInterfacePrivate
::
FileOpen
:
QGuiApplicationPrivate
::
processFileOpenEvent
(
static_cast

(
e
)
)
;
break
;
#ifndef QT_NO_CONTEXTMENU
case
QWindowSystemInterfacePrivate
::
ContextMenu
:
QGuiApplicationPrivate
::
processContextMenuEvent
(
static_cast

(
e
)
)
;
break
;
#endif
case
QWindowSystemInterfacePrivate
::
EnterWhatsThisMode
:
QGuiApplication
::
postEvent
(
QGuiApplication
::
instance
(
)
,
new
QEvent
(
QEvent
::
EnterWhatsThisMode
)
)
;
break
;
default
:
qWarning
(
)

type
;
break
;
}
}

void
QGuiApplicationPrivate
::
processMouseEvent
(
QWindowSystemInterfacePrivate
::
MouseEvent
*
e
)
{
QEvent
::
Type type
=
QEvent
::
None
;
Qt
::
MouseButton button
=
Qt
::
NoButton
;
QWindow
*
window
=
e
->
window
.
data
(
)
;
bool
positionChanged
=
QGuiApplicationPrivate
::
lastCursorPosition
!=
e
->
globalPos
;
bool
mouseMove
=
false
;
bool
mousePress
=
false
;
if
(
e
->
enhancedMouseEvent
(
)
)
{
type
=
e
->
buttonType
;
button
=
e
->
button
;
if
(
type
==
QEvent
::
NonClientAreaMouseMove
||
type
==
QEvent
::
MouseMove
)
mouseMove
=
true
;
else
if
(
type
==
QEvent
::
NonClientAreaMouseButtonPress
||
type
==
QEvent
::
MouseButtonPress
)
mousePress
=
true
;
if
(
!
mouseMove
&&
positionChanged
)
{
QWindowSystemInterfacePrivate
::
MouseEvent
moveEvent
(
window
,
e
->
timestamp
,
e
->
localPos
,
e
->
globalPos
,
e
->
buttons
^
button
,
e
->
modifiers
,
Qt
::
NoButton
,
e
->
nonClientArea
?
QEvent
::
NonClientAreaMouseMove
:
QEvent
::
MouseMove
,
e
->
source
,
e
->
nonClientArea
)
;
if
(
e
->
synthetic
(
)
)
moveEvent
.
flags
|=
QWindowSystemInterfacePrivate
::
WindowSystemEvent
::
Synthetic
;
processMouseEvent
(
&
moveEvent
)
;
// mouse move excluding state change
processMouseEvent
(
e
)
;
// the original mouse event
return
;
}
}
else
{
Qt
::
MouseButtons stateChange
=
e
->
buttons
^
mouse_buttons
;
if
(
positionChanged
&&
(
stateChange
!=
Qt
::
NoButton
)
)
{
QWindowSystemInterfacePrivate
::
MouseEvent
moveEvent
(
window
,
e
->
timestamp
,
e
->
localPos
,
e
->
globalPos
,
mouse_buttons
,
e
->
modifiers
,
Qt
::
NoButton
,
QEvent
::
None
,
e
->
source
,
e
->
nonClientArea
)
;
if
(
e
->
synthetic
(
)
)
moveEvent
.
flags
|=
QWindowSystemInterfacePrivate
::
WindowSystemEvent
::
Synthetic
;
processMouseEvent
(
&
moveEvent
)
;
// mouse move excluding state change
processMouseEvent
(
e
)
;
// the original mouse event
return
;
}
// In the compatibility path we deduce event type and button that caused the event
if
(
positionChanged
)
{
mouseMove
=
true
;
type
=
e
->
nonClientArea
?
QEvent
::
NonClientAreaMouseMove
:
QEvent
::
MouseMove
;
}
else
{
// Check to see if a new button has been pressed/released.
for
(
uint mask
=
Qt
::
LeftButton
;
mask

buttons
)
{
mousePress
=
true
;
type
=
e
->
nonClientArea
?
QEvent
::
NonClientAreaMouseButtonPress
:
QEvent
::
MouseButtonPress
;
}
else
{
type
=
e
->
nonClientArea
?
QEvent
::
NonClientAreaMouseButtonRelease
:
QEvent
::
MouseButtonRelease
;
}
}
}
modifier_buttons
=
e
->
modifiers
;
QPointF localPoint
=
e
->
localPos
;
QPointF globalPoint
=
e
->
globalPos
;
bool
doubleClick
=
false
;
if
(
mouseMove
)
{
QGuiApplicationPrivate
::
lastCursorPosition
=
globalPoint
;
const
auto
doubleClickDistance
=
e
->
source
==
Qt
::
MouseEventNotSynthesized
?
mouseDoubleClickDistance
:
touchDoubleTapDistance
;
if
(
qAbs
(
globalPoint
.
x
(
)
-
mousePressX
)
>
doubleClickDistance
||
qAbs
(
globalPoint
.
y
(
)
-
mousePressY
)
>
doubleClickDistance
)
mousePressButton
=
Qt
::
NoButton
;
}
else
{
mouse_buttons
=
e
->
buttons
;
if
(
mousePress
)
{
ulong doubleClickInterval
=
static_cast

(
QGuiApplication
::
styleHints
(
)
->
mouseDoubleClickInterval
(
)
)
;
doubleClick
=
e
->
timestamp
-
mousePressTime

timestamp
;
mousePressButton
=
button
;
const
QPoint point
=
QGuiApplicationPrivate
::
lastCursorPosition
.
toPoint
(
)
;
mousePressX
=
point
.
x
(
)
;
mousePressY
=
point
.
y
(
)
;
}
}
if
(
e
->
nullWindow
(
)
)
{
window
=
QGuiApplication
::
topLevelAt
(
globalPoint
.
toPoint
(
)
)
;
if
(
window
)
{
// Moves and the release following a press must go to the same
// window, even if the cursor has moved on over another window.
if
(
e
->
buttons
!=
Qt
::
NoButton
)
{
if
(
!
currentMousePressWindow
)
currentMousePressWindow
=
window
;
else
window
=
currentMousePressWindow
;
}
else
if
(
currentMousePressWindow
)
{
window
=
currentMousePressWindow
;
currentMousePressWindow
=
0
;
}
QPointF delta
=
globalPoint
-
globalPoint
.
toPoint
(
)
;
localPoint
=
window
->
mapFromGlobal
(
globalPoint
.
toPoint
(
)
)
+
delta
;
}
}
if
(
!
window
)
return
;
#ifndef QT_NO_CURSOR
if
(
!
e
->
synthetic
(
)
)
{
if
(
const
QScreen
*
screen
=
window
->
screen
(
)
)
if
(
QPlatformCursor
*
cursor
=
screen
->
handle
(
)
->
cursor
(
)
)
{
const
QPointF nativeLocalPoint
=
QHighDpi
::
toNativePixels
(
localPoint
,
screen
)
;
const
QPointF nativeGlobalPoint
=
QHighDpi
::
toNativePixels
(
globalPoint
,
screen
)
;
QMouseEvent
ev
(
type
,
nativeLocalPoint
,
nativeLocalPoint
,
nativeGlobalPoint
,
button
,
e
->
buttons
,
e
->
modifiers
,
e
->
source
)
;
ev
.
setTimestamp
(
e
->
timestamp
)
;
cursor
->
pointerEvent
(
ev
)
;
}
}
#endif
QMouseEvent
ev
(
type
,
localPoint
,
localPoint
,
globalPoint
,
button
,
e
->
buttons
,
e
->
modifiers
,
e
->
source
)
;
ev
.
setTimestamp
(
e
->
timestamp
)
;
if
(
window
->
d_func
(
)
->
blockedByModalWindow
&&
!
qApp
->
d_func
(
)
->
popupActive
(
)
)
{
// a modal window is blocking this window, don't allow mouse events through
return
;
}
if
(
doubleClick
&&
(
ev
.
type
(
)
==
QEvent
::
MouseButtonPress
)
)
{
// QtBUG-25831, used to suppress delivery in qwidgetwindow.cpp
setMouseEventFlags
(
&
ev
,
ev
.
flags
(
)
|
Qt
::
MouseEventCreatedDoubleClick
)
;
}
QGuiApplication
::
sendSpontaneousEvent
(
window
,
&
ev
)
;
e
->
eventAccepted
=
ev
.
isAccepted
(
)
;
if
(
!
e
->
synthetic
(
)
&&
!
ev
.
isAccepted
(
)
&&
!
e
->
nonClientArea
&&
qApp
->
testAttribute
(
Qt
::
AA_SynthesizeTouchForUnhandledMouseEvents
)
)
{
if
(
!
m_fakeTouchDevice
)
{
m_fakeTouchDevice
=
new
QTouchDevice
;
QWindowSystemInterface
::
registerTouchDevice
(
m_fakeTouchDevice
)
;
}
QList

points
;
QWindowSystemInterface
::
TouchPoint point
;
point
.
id
=
1
;
point
.
area
=
QRectF
(
globalPoint
.
x
(
)
-
2
,
globalPoint
.
y
(
)
-
2
,
4
,
4
)
;
// only translate left button related events to
// avoid strange touch event sequences when several
// buttons are pressed
if
(
type
==
QEvent
::
MouseButtonPress
&&
button
==
Qt
::
LeftButton
)
{
point
.
state
=
Qt
::
TouchPointPressed
;
}
else
if
(
type
==
QEvent
::
MouseButtonRelease
&&
button
==
Qt
::
LeftButton
)
{
point
.
state
=
Qt
::
TouchPointReleased
;
}
else
if
(
type
==
QEvent
::
MouseMove
&&
(
e
->
buttons
&
Qt
::
LeftButton
)
)
{
point
.
state
=
Qt
::
TouchPointMoved
;
}
else
{
return
;
}
points

touchPoints
=
QWindowSystemInterfacePrivate
::
fromNativeTouchPoints
(
points
,
window
,
QTouchDevicePrivate
::
get
(
m_fakeTouchDevice
)
->
id
,
&
type
)
;
QWindowSystemInterfacePrivate
::
TouchEvent
fake
(
window
,
e
->
timestamp
,
type
,
m_fakeTouchDevice
,
touchPoints
,
e
->
modifiers
)
;
fake
.
flags
|=
QWindowSystemInterfacePrivate
::
WindowSystemEvent
::
Synthetic
;
processTouchEvent
(
&
fake
)
;
}
if
(
doubleClick
)
{
mousePressButton
=
Qt
::
NoButton
;
if
(
!
e
->
window
.
isNull
(
)
||
e
->
nullWindow
(
)
)
{
// QTBUG-36364, check if window closed in response to press
const
QEvent
::
Type doubleClickType
=
e
->
nonClientArea
?
QEvent
::
NonClientAreaMouseButtonDblClick
:
QEvent
::
MouseButtonDblClick
;
QMouseEvent
dblClickEvent
(
doubleClickType
,
localPoint
,
localPoint
,
globalPoint
,
button
,
e
->
buttons
,
e
->
modifiers
,
e
->
source
)
;
dblClickEvent
.
setTimestamp
(
e
->
timestamp
)
;
QGuiApplication
::
sendSpontaneousEvent
(
window
,
&
dblClickEvent
)
;
}
}
}