This function sends a shortcut override through the shortcut system and
returns the result of the event. This will be used in platform plugins
(such as the Cocoa plugin) to make sure that shortcuts work when the
user presses a dead-key combination that normally would go through an
input method to produce text.
An extended overload taking native scan code, virtual key, and modifiers
has also been added.
Change-Id: Ia3836229ab0c66d2fb6f310e72b6f4d6dfa9ead9
Reviewed-by: Morten Johan Sørvig <morten.sorvig@nokia.com>
QWindowSystemInterfacePrivate::eventTime.start() is never called,
resulting in all calls to
QWindowSystemInterfacePrivate::eventTime.elapsed() within
qwindowsysteminterface_qpa.cpp to return 0. This could cause events
to be lost, such as mouse button press events from the evdevmouse
input plugin.
Change-Id: Iba9d23b51af80e8532d24ccf382e9077c06bb4be
Reviewed-by: Laszlo Agocs <laszlo.p.agocs@nokia.com>
- Give QPlatformDrag a synchronous drag() function returning
the Qt::DropAction
- Move the base functionality for asynchronous event handling
to the platformsupport library as QBasicDrag (extendable base class
handling drag icon and providing new virtuals) and QSimpleDrag
(sample implementation for drag within the Qt application).
- Change the Windows implementation accordingly.
- Change XCB to be based on QBasicDrag.
- Clean up QDragManager.
Change-Id: I654f76f0e55a385ba189bd74f3ceaded6a8fe318
Reviewed-by: Morten Johan Sørvig <morten.sorvig@nokia.com>
Support pixel-based deltas as well as sending
dx and dy values in the same event. Keep source and
behavior compatibility with Qt 4.
New API:
QPoint pixelDelta() const
QPoint angleDelta() const
Deprecate delta() and orientation().
Both pixel-based deltas and combined updates are
necessary for smooth trackpad-based scrolling on
OS X.
Qt 4 compatible behavior is achieved by sending an
extra wheel event in cases where the initial event
has a combined dx and dy update. This extra event
sends dx in delta() and orientation(), with pixelDelta()
and angleDelta() set to null.
Modify the Cocoa implementation to provide pixel
deltas. It is expected that not all platforms can
provide these. Angle deltas will always be available.
Change-Id: I20c10f0df338ddcd6a3f7a4d40949ed5ae3b4795
Reviewed-by: Morten Johan Sørvig <morten.sorvig@nokia.com>
- Pass it from QWindowSystemInterface via QWindow to the widgets.
- Add handler code from 4.8 / qapplication_win.cpp to qwidget.cpp.
Change-Id: Ic759563aa00cb93fe014c1bf41020446c1927dec
Reviewed-by: Morten Johan Sørvig <morten.sorvig@nokia.com>
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
As in the past, to avoid rewriting various autotests that contain
line-number information, an extra blank line has been inserted at the
end of the license text to ensure that this commit does not change the
total number of lines in the license header.
Change-Id: I311e001373776812699d6efc045b5f742890c689
Reviewed-by: Rohan McGovern <rohan.mcgovern@nokia.com>
The current way we do it of having the platform or touch plugin send
both mouse and touch events is not ideal. There's no good way to write
an application that works sanely both on a touch-only device and on a
desktop except by restricting yourself to only handling mouse events. If
you try to handle touch events you don't get any events at all on
desktop, and if you try to handle both, you end up getting duplicate
events on touch devices.
Instead, we should get rid of the code in the plugins that automatically
sends mouse events translated from touch events. This change enables
that by making the behaviour fully configurable in QtGui.
Two new application attributes are added to explicitly say whether
unhandled touch events should be sent as synthesized mouse events and
vice versa, and no duplicates are automatically sent as the current
situation. Synthesized mouse events are enabled by default.
We also get rid of the QTouchEvent::TouchPoint::Primary flag, which
was only used to signal that the windowing system automatically
generated mouse events for that touch point. Now we only generate mouse
events from the first touch point in the list.
Change-Id: I8e20f3480407ca8c31b42de0a4d2b319e1346b65
Reviewed-by: Laszlo Agocs <laszlo.p.agocs@nokia.com>
Reviewed-by: Jocelyn Turcotte <jocelyn.turcotte@nokia.com>
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@nokia.com>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Reviewed-by: Denis Dzyubenko <denis.dzyubenko@nokia.com>
This makes it possible for platform plugin independent code (such as
generic plugins) to report changes to screen properties. An example
would be an accelerometer plugin that reports orientation changes
without knowing anything about the windowing system.
Change-Id: I984984b6d064327772c264bc942269422451da37
Reviewed-by: Jørgen Lind <jorgen.lind@nokia.com>
For some reason the primary bit has previously been encoded in the
touch point state, even though it has nothing to do with the regular
states like Pressed, Released, etc.
The value is now stored in the recently introduced flags member of the
touch points. This also reduces the need for error-prone internal
masking of the state value.
The structure used by QWindowSystemInterface::handleTouchEvent also
becomes cleaner because the primary status can now be set in the flags
member and the isPrimary bool can be dropped.
Change-Id: I1da2cb99154afd97e1e3a5943ab115cae3a8232f
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
Requiring platform and generic plug-ins to pass TouchBegin,
TouchUpdate, or TouchEnd is unnecessary. The type can be easily
deduced from the touch point states. In fact handleTouchEvent already
collected the combined point states, it was just not utilized until
now.
Change-Id: Icf3c787fefdebc51609a763bc4286c18a0b6aac2
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
The capability flags indicate which information is valid in the touch
points. Previously there was no way to tell if e.g. the value returned
by pressure() is actually the value provided by the driver/device or
it is just something bogus due to pressure not being supported.
The points' flags return information about the individual touch
points. One use case is to differentiate between touches made by
finger and pen.
Velocity, if available, is now also exposed.
Each touch point can now contain an additional list of "raw"
positions. These points are not reported individually but are taken
into account in some way by the underlying device and drivers to
generate the final, "accurate" touch point. In case the underlying
drivers expose these additional positions, they are made available in
the lists returned by the touch points' rawScreenPosition().
The raw positions are only available in screen coordinates to prevent
wasting time with mapping from global positions in applications that
do not use this data. Instead, apps can query the QWindow to which the
touch event was sent via QTouchEvent::window() and can call
mapFromGlobal() manually if they need local raw positions.
The capability and device type information is now held in a new
QTouchDevice class. Each touch event will contain only a pointer to
one of the global QTouchDevice instances. On top of type and
capability, the new class also contains a name which can be used to
differentiate between multiple touch input devices (i.e. to tell from
which one a given QTouchEvent originates from).
The introduction of QTouchDevice has three implications: The
QTouchEvent constructor and QWindowSystemInterface::handleTouchEvent
need to be changed (to pass a QTouchDevice pointer instead of merely a
device type value), and each platform or generic plug-in is now
responsible for registering one or more devices using the new API
QWindowSystemInterface::registerTouchDevice.
Change-Id: Ic1468d3e43933d8b5691d75aa67c43e1bc7ffe3e
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Logical DPI is independent from geometry and physical DPI.
Change-Id: Ice487f61e1bda9e6791e2adf6998ebf61cdbaef2
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Reviewed-by: Jørgen Lind <jorgen.lind@nokia.com>
And use it from the Cocoa backend.
In general, for threaded GL rendering to work, any function that
affect the surface must be synchronous, so the implementor (such as
QQuickCanvas) can pick it up and block until the GL context has
released the surface. Otherwise, we will crash.
Change-Id: Id8484dac7452fe96fa80ade4ea321145f32124b4
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
processWindowSystemEvent does not delete the event, so
allocate it on the stack instead.
Change-Id: Iffda940ffc86ef1fabfbf101e08956fa07c49689
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
QScreen now has a primary and current orientation, and a QWindow can set
its orientation as well. The current screen orientation is just a hint
to the application.
Change-Id: I4635982cfac2d16634d4edd5c6ab78e9d0ac55a4
Reviewed-on: http://codereview.qt-project.org/5988
Reviewed-by: Paul Olav Tvete <paul.tvete@nokia.com>
Sanity-Review: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
The modifiers are provided by X and need to be propagated through the
QWindowSystemInterface.
Change-Id: I127d0b6e9918b558ca15d9302c4cc0cbd94eb757
Reviewed-on: http://codereview.qt-project.org/6244
Reviewed-by: Laszlo Agocs <laszlo.p.agocs@nokia.com>
Sanity-Review: Samuel Rødal <samuel.rodal@nokia.com>
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
Sanity-Review: Qt Sanity Bot <qt_sanity_bot@ovi.com>
252d1b34b2 introduces a mapFromGlobal
call in QWindowSystemInterface::handleTouchEvent. This has two issues:
It ignores the fact that the tlw parameter can be null, resulting in
an instant crash with the touch support of some platforms, and the
mapping itself is unneccessary because
QGuiApplication::processTouchEvent() will perform the same, the
rect set via setRect() is basically ignored due to the touchPoint.d.rect
= ... just before sending the final event to the widget in qguiapplication.cpp.
Using setScreenRect instead of setRect is a valid fix from the
previous patch, but the parts for the mapping need to be removed.
Change-Id: I0bb40c7d647fb062106b151e5987f9970d6ab2c8
Reviewed-on: http://codereview.qt-project.org/5448
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Bjørn Erik Nilsen <bjorn.nilsen@nokia.com>
QTouchEvent::TouchPoint assumes the rect() is in local coordinates,
whereas QWindowSystemInterface::TouchPoint uses screen coordinates.
We must therefore use QWindowSystemInterface::TouchPoint::area as the
screenRect() rather that the rect() and then use the screen coordinate
to calculate the local coordinate by using mapFromGlobal.
Change-Id: If7a52f5668c3938f46bdd38a5ea82b5313d6b626
Reviewed-on: http://codereview.qt-project.org/5253
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Bjørn Erik Nilsen <bjorn.nilsen@nokia.com>
The SG render thread was racing window creation in
the GUI thread, which would cause flicker if the
window won the race and was shown before the SG
thread had a frame ready.
Send a synchronous expose event before showing the
window - this will wait for the SG render thread.
In addition, don't defer NSwindow creation. The GL
context setup is done before the window is shown
and needs a fully created window.
New API: QWindowSystemInterface::handleSynchronousExposeEvent
Retire: QWindowSystemInterface::handleExposeEvent
Change-Id: I0bb46089d16ec4882aaac8db67b57d15e0f51531
Reviewed-on: http://codereview.qt.nokia.com/3399
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Gunnar Sletta <gunnar.sletta@nokia.com>
Reviewed-by: Richard Moe Gustavsen <richard.gustavsen@nokia.com>
During window resizing the geometry change events
must be processed before returning from the event
handler.
New API: QWindowSystemInterface::handleSynchronousGeometryChange,
similar to handleGeometryChange but sends the event
immediately instead of queueing it.
Change-Id: I7dc809b3fd2e8a933c100fef3f5144972f46e363
Reviewed-on: http://codereview.qt.nokia.com/2993
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Paul Olav Tvete <paul.tvete@nokia.com>
At least QMouseEvent already uses QPointF so there is no reason to
restrict handleMouseEvent to integer positions.
Change-Id: I9c72d2e0e99518b40a1898aec9ad2b3421a3e9e2
Reviewed-on: http://codereview.qt.nokia.com/2739
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
For non-desktop platforms these are better suited and are more
QPA style than relying purely on QDragManager/QSimpleDrag/sending
drag events directly to the windows.
Change-Id: Id466830cf83427b3d86925602086a858e8f713e5
Reviewed-on: http://codereview.qt.nokia.com/2084
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Samuel Rødal <samuel.rodal@nokia.com>
Add QWindowSystemInterface::sendWindowSystemEvents,
which contains the canonical "empty and send queued
window system events" implementation.
Make the Cocoa, QPA, and GLIB dispatchers use the
new implementation. Cocoa now no longer inherits
from QPA.
This requires adding a couple of window system interface events, namely
Map, Unmap, and Expose. When a widget is minimized on X11 it is
unmapped, and thus update requests should not be delivered. Instead the
event will delivered when the widget is mapped, which causes an Expose
event to be sent. The Unmap and Expose event thus need to be handled in
QWidgetWindow, and Map is also added for the purpose of API symmetry
(and for future needs).
Create a guikernel/ directory that contains the files that'll go
into libQtGui. What remains in kernel/ will go into QtWidgets.
In addition to that image/, painting/ and text will end up
int QtGui.
This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:
http://qt.gitorious.org/qt/pages/GitIntroductionWithQt
If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.
Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12
Bradley T. Hughes
Laszlo Agocs
Jon Trulson
Friedemann Kleint
Morten Johan Sorvig
Jason McDonald
Samuel Rødal
Gunnar Sletta
Simon Hausmann
Bjørn Erik Nilsen
Lars Knoll
Paul Olav Tvete
Jyri Tahtela
Qt by Nokia