whytofly
/
qt6-bb10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of git://scm.dev.nokia.troll.no/qt/qtbase

bb10
Simo Fält 2012-03-29 13:35:50 +03:00
parent 064dc31b19 4451010026
commit ca572c0b80
30 changed files with 805 additions and 639 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
configure vendored
View File

@ -2538,15 +2538,10 @@ if [ "$XPLATFORM_SYMBIAN_SBSV2" = "no" ]; then
fi
fi
SYSROOT_FLAG=
if [ -n "$CFG_SYSROOT" ]; then
if compilerSupportsFlag --sysroot="$CFG_SYSROOT"; then
[ "$OPT_VERBOSE" = "yes" ] && echo "Setting sysroot to: $CFG_SYSROOT"
SYSROOT_FLAG="--sysroot=$CFG_SYSROOT"
else
echo >&2 "The compiler doesn't support the --sysroot flag, I can't set the sysroot"
exit 1
fi
SYSROOT_FLAG="--sysroot=$CFG_SYSROOT"
else
SYSROOT_FLAG=
fi
export SYSROOT_FLAG # used by config.tests/unix/compile.test
@ -3185,6 +3180,8 @@ Additional options:
-xplatform target ... The target platform when cross-compiling.
-sysroot <dir> ...... Sets <dir> as the target compiler's and qmake's sysroot.
-no-feature-<feature> Do not compile in <feature>.
-feature-<feature> .. Compile in <feature>. The available features
are described in src/corelib/global/qfeatures.txt

6
qmake/project.cpp
View File

@ -1721,7 +1721,8 @@ QMakeProject::doProjectExpand(QString func, QList<QStringList> args_list,
function_blocks.push(defined);
QStringList ret;
defined->exec(args_list, this, place, ret);
Q_ASSERT(function_blocks.pop() == defined);
bool correct = function_blocks.pop() == defined;
Q_ASSERT(correct); Q_UNUSED(correct);
return ret;
}
@ -2206,7 +2207,8 @@ QMakeProject::doProjectTest(QString func, QList<QStringList> args_list, QHash<QS
QStringList ret;
function_blocks.push(defined);
defined->exec(args_list, this, place, ret);
Q_ASSERT(function_blocks.pop() == defined);
bool correct = function_blocks.pop() == defined;
Q_ASSERT(correct); Q_UNUSED(correct);
if(ret.isEmpty()) {
return true;

9
src/corelib/kernel/qobjectdefs.h
View File

@ -140,6 +140,13 @@ template <typename T1, typename T2>
inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}
#endif // QT_NO_QOBJECT_CHECK
#if defined(Q_CC_INTEL)
// Cannot redefine the visibility of a method in an exported class
# define Q_DECL_HIDDEN_STATIC_METACALL
#else
# define Q_DECL_HIDDEN_STATIC_METACALL Q_DECL_HIDDEN
#endif
/* tmake ignore Q_OBJECT */
#define Q_OBJECT \
public: \
@ -151,7 +158,7 @@ public: \
virtual int qt_metacall(QMetaObject::Call, int, void **); \
private: \
Q_DECL_HIDDEN static const QMetaObjectExtraData staticMetaObjectExtraData; \
Q_DECL_HIDDEN static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
/* tmake ignore Q_OBJECT */
#define Q_OBJECT_FAKE Q_OBJECT

7
src/corelib/thread/qthread_unix.cpp
View File

@ -90,7 +90,7 @@
# endif
#endif
#if defined(Q_OS_LINUX)
#if defined(Q_OS_LINUX) && !defined(QT_LINUXBASE)
#include <sys/prctl.h>
#endif
@ -110,7 +110,8 @@ QT_BEGIN_NAMESPACE
enum { ThreadPriorityResetFlag = 0x80000000 };
#if defined(Q_OS_LINUX) && defined(__GLIBC__) && (defined(Q_CC_GNU) || defined(Q_CC_INTEL))
#if defined(Q_OS_LINUX) && defined(__GLIBC__) && (defined(Q_CC_GNU) || defined(Q_CC_INTEL)) && !defined(QT_LINUXBASE)
/* LSB doesn't have __thread, https://lsbbugs.linuxfoundation.org/show_bug.cgi?id=993 */
#define HAVE_TLS
#endif
#if defined(Q_CC_XLC) || defined (Q_CC_SUN)
@ -294,7 +295,7 @@ void *QThreadPrivate::start(void *arg)
if (objectName.isEmpty())
objectName = thr->metaObject()->className();
#if defined(Q_OS_LINUX)
#if defined(Q_OS_LINUX) && !defined(QT_LINUXBASE)
prctl(PR_SET_NAME, (unsigned long)objectName.constData(), 0, 0, 0);
#elif defined(Q_OS_MAC)
pthread_setname_np(objectName.constData());

9
src/gui/kernel/qguiapplication.cpp
View File

@ -52,6 +52,7 @@
#include "qplatformintegration_qpa.h"
#include <QtCore/QAbstractEventDispatcher>
#include <QtCore/QVariant>
#include <QtCore/private/qcoreapplication_p.h>
#include <QtCore/private/qabstracteventdispatcher_p.h>
#include <QtCore/qmutex.h>
@ -143,6 +144,8 @@ static QBasicMutex applicationFontMutex;
QFont *QGuiApplicationPrivate::app_font = 0;
bool QGuiApplicationPrivate::obey_desktop_settings = true;
static qreal fontSmoothingGamma = 1.7;
extern void qRegisterGuiVariant();
extern void qUnregisterGuiVariant();
extern void qInitDrawhelperAsm();
@ -579,13 +582,13 @@ static void init_platform(const QString &pluginArgument, const QString &platform
nativeInterface->setProperty(name.constData(), value);
}
}
fontSmoothingGamma = QGuiApplicationPrivate::platformIntegration()->styleHint(QPlatformIntegration::FontSmoothingGamma).toReal();
}
static void init_plugins(const QList<QByteArray> &pluginList)
{
for (int i = 0; i < pluginList.count(); ++i) {
QByteArray pluginSpec = pluginList.at(i);
qDebug() << "init_plugins" << i << pluginSpec;
int colonPos = pluginSpec.indexOf(':');
QObject *plugin;
if (colonPos < 0)
@ -593,7 +596,6 @@ static void init_plugins(const QList<QByteArray> &pluginList)
else
plugin = QGenericPluginFactory::create(QLatin1String(pluginSpec.mid(0, colonPos)),
QLatin1String(pluginSpec.mid(colonPos+1)));
qDebug() << " created" << plugin;
if (plugin)
QGuiApplicationPrivate::generic_plugin_list.append(plugin);
}
@ -2176,8 +2178,7 @@ const QDrawHelperGammaTables *QGuiApplicationPrivate::gammaTables()
{
QDrawHelperGammaTables *result = m_gammaTables.load();
if (!result){
const qreal smoothing = qApp->styleHints()->fontSmoothingGamma();
QDrawHelperGammaTables *tables = new QDrawHelperGammaTables(smoothing);
QDrawHelperGammaTables *tables = new QDrawHelperGammaTables(fontSmoothingGamma);
if (!m_gammaTables.testAndSetRelease(0, tables))
delete tables;
result = m_gammaTables.load();

9
src/gui/painting/qdrawhelper.cpp
View File

@ -39,6 +39,15 @@
**
****************************************************************************/
#if defined(__OPTIMIZE__) && !defined(__INTEL_COMPILER) && defined(__GNUC__) \
&& (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)
// GCC 4.4 supports #pragma GCC optimize and #pragma GCC target
# pragma GCC optimize "O3"
# if defined(__i386__) && defined(__SSE2__) && !defined(__SSE2_MATH__)
# pragma GCC target "fpmath=sse"
# endif
#endif
#include <qstylehints.h>
#include <qguiapplication.h>
#include <qatomic.h>

2
src/gui/painting/qpaintengine_raster.cpp
View File

@ -737,7 +737,7 @@ void QRasterPaintEngine::updatePen(const QPen &pen)
s->flags.fast_pen = pen_style > Qt::NoPen
&& s->penData.blend
&& ((pen.isCosmetic() && penWidth <= 1)
|| (s->flags.tx_noshear && penWidth * s->txscale <= 1));
|| (!pen.isCosmetic() && s->flags.tx_noshear && penWidth * s->txscale <= 1));
s->flags.non_complex_pen = qpen_capStyle(s->lastPen) <= Qt::SquareCap && s->flags.tx_noshear;

7
src/plugins/platforms/qnx/qnx.pro
View File

@ -20,6 +20,7 @@ QT += opengl opengl-private platformsupport platformsupport-private widgets-priv
#DEFINES += QQNXRASTERBACKINGSTORE_DEBUG
#DEFINES += QQNXROOTWINDOW_DEBUG
#DEFINES += QQNXSCREEN_DEBUG
#DEFINES += QQNXSCREENEVENT_DEBUG
#DEFINES += QQNXVIRTUALKEYBOARD_DEBUG
#DEFINES += QQNXWINDOW_DEBUG
@ -35,7 +36,8 @@ SOURCES = main.cpp \
qqnxrasterbackingstore.cpp \
qqnxvirtualkeyboard.cpp \
qqnxclipboard.cpp \
qqnxrootwindow.cpp
qqnxrootwindow.cpp \
qqnxscreeneventhandler.cpp
HEADERS = qqnxbuffer.h \
@ -50,7 +52,8 @@ HEADERS = qqnxbuffer.h \
qqnxrasterbackingstore.h \
qqnxvirtualkeyboard.h \
qqnxclipboard.h \
qqnxrootwindow.h
qqnxrootwindow.h \
qqnxscreeneventhandler.h
CONFIG(blackberry) {
SOURCES += qqnxservices.cpp

6
src/plugins/platforms/qnx/qqnxclipboard.h
View File

@ -51,9 +51,9 @@ class QQnxClipboard : public QPlatformClipboard
{
public:
QQnxClipboard();
virtual ~QQnxClipboard();
virtual QMimeData *mimeData(QClipboard::Mode mode = QClipboard::Clipboard);
virtual void setMimeData(QMimeData *data, QClipboard::Mode mode = QClipboard::Clipboard);
~QQnxClipboard();
QMimeData *mimeData(QClipboard::Mode mode = QClipboard::Clipboard);
void setMimeData(QMimeData *data, QClipboard::Mode mode = QClipboard::Clipboard);
private:
class MimeData;

473
src/plugins/platforms/qnx/qqnxeventthread.cpp
View File

@ -40,53 +40,20 @@
****************************************************************************/
#include "qqnxeventthread.h"
#include "qqnxintegration.h"
#include "qqnxkeytranslator.h"
#if defined(QQNX_IMF)
#include "qqnxinputcontext_imf.h"
#else
#include "qqnxinputcontext_noimf.h"
#endif
#include <QtGui/QWindow>
#include <QtGui/QPlatformScreen>
#include <QtGui/QGuiApplication>
#include "qqnxscreeneventhandler.h"
#include <QtCore/QDebug>
#include <errno.h>
#include <unistd.h>
#include <sys/keycodes.h>
#include <cctype>
QQnxEventThread::QQnxEventThread(screen_context_t context, QPlatformScreen& screen)
QQnxEventThread::QQnxEventThread(screen_context_t context)
: QThread(),
m_screenContext(context),
m_platformScreen(screen),
m_quit(false),
m_lastButtonState(Qt::NoButton),
m_lastMouseWindow(0)
m_quit(false)
{
// Create a touch device
m_touchDevice = new QTouchDevice;
m_touchDevice->setType(QTouchDevice::TouchScreen);
m_touchDevice->setCapabilities(QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::Pressure | QTouchDevice::NormalizedPosition);
QWindowSystemInterface::registerTouchDevice(m_touchDevice);
// initialize array of touch points
for (int i = 0; i < MaximumTouchPoints; i++) {
// map array index to id
m_touchPoints[i].id = i;
// pressure is not supported - use default
m_touchPoints[i].pressure = 1.0;
// nothing touching
m_touchPoints[i].state = Qt::TouchPointReleased;
}
}
QQnxEventThread::~QQnxEventThread()
@ -95,16 +62,21 @@ QQnxEventThread::~QQnxEventThread()
shutdown();
}
void QQnxEventThread::injectKeyboardEvent(int flags, int sym, int mod, int scan, int cap)
{
QQnxScreenEventHandler::injectKeyboardEvent(flags, sym, mod, scan, cap);
}
void QQnxEventThread::run()
{
QQnxScreenEventHandler eventHandler;
screen_event_t event;
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result) {
if (result)
qFatal("QQNX: failed to create event, errno=%d", errno);
}
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: event loop started";
@ -116,12 +88,26 @@ void QQnxEventThread::run()
// block until screen event is available
errno = 0;
result = screen_get_event(m_screenContext, event, -1);
if (result) {
if (result)
qFatal("QQNX: failed to get event, errno=%d", errno);
}
// process received event
dispatchEvent(event);
// get the event type
errno = 0;
int qnxType;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &qnxType);
if (result)
qFatal("QQNX: failed to query event type, errno=%d", errno);
if (qnxType == SCREEN_EVENT_USER) {
// treat all user events as shutdown requests
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: QNX user event";
#endif
m_quit = true;
} else {
eventHandler.handleEvent(event, qnxType);
}
}
#if defined(QQNXEVENTTHREAD_DEBUG)
@ -139,26 +125,23 @@ void QQnxEventThread::shutdown()
// create screen event
errno = 0;
int result = screen_create_event(&event);
if (result) {
if (result)
qFatal("QQNX: failed to create event, errno=%d", errno);
}
// set the event type as user
errno = 0;
int type = SCREEN_EVENT_USER;
result = screen_set_event_property_iv(event, SCREEN_PROPERTY_TYPE, &type);
if (result) {
if (result)
qFatal("QQNX: failed to set event type, errno=%d", errno);
}
// NOTE: ignore SCREEN_PROPERTY_USER_DATA; treat all user events as shutdown events
// post event to event loop so it will wake up and die
errno = 0;
result = screen_send_event(m_screenContext, event, getpid());
if (result) {
if (result)
qFatal("QQNX: failed to set event type, errno=%d", errno);
}
// cleanup
screen_destroy_event(event);
@ -174,399 +157,3 @@ void QQnxEventThread::shutdown()
qDebug() << "QQNX: event loop shutdown end";
#endif
}
void QQnxEventThread::dispatchEvent(screen_event_t event)
{
// get the event type
errno = 0;
int qnxType;
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &qnxType);
if (result) {
qFatal("QQNX: failed to query event type, errno=%d", errno);
}
switch (qnxType) {
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
case SCREEN_EVENT_MTOUCH_RELEASE:
handleTouchEvent(event, qnxType);
break;
case SCREEN_EVENT_KEYBOARD:
handleKeyboardEvent(event);
break;
case SCREEN_EVENT_POINTER:
handlePointerEvent(event);
break;
case SCREEN_EVENT_CLOSE:
handleCloseEvent(event);
break;
case SCREEN_EVENT_USER:
// treat all user events as shutdown requests
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: QNX user event";
#endif
m_quit = true;
break;
default:
// event ignored
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: QNX unknown event";
#endif
break;
}
}
void QQnxEventThread::handleKeyboardEvent(screen_event_t event)
{
// get flags of key event
errno = 0;
int flags;
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_FLAGS, &flags);
if (result) {
qFatal("QQNX: failed to query event flags, errno=%d", errno);
}
// get key code
errno = 0;
int sym;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SYM, &sym);
if (result) {
qFatal("QQNX: failed to query event sym, errno=%d", errno);
}
int modifiers;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_MODIFIERS, &modifiers);
if (result) {
qFatal("QQNX: failed to query event modifiers, errno=%d", errno);
}
int scan;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SCAN, &scan);
if (result) {
qFatal("QQNX: failed to query event modifiers, errno=%d", errno);
}
int cap;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_CAP, &cap);
if (result) {
qFatal("QQNX: failed to query event cap, errno=%d", errno);
}
injectKeyboardEvent(flags, sym, modifiers, scan, cap);
}
void QQnxEventThread::injectKeyboardEvent(int flags, int sym, int modifiers, int scan, int cap)
{
Q_UNUSED(scan);
Qt::KeyboardModifiers qtMod = Qt::NoModifier;
if (modifiers & KEYMOD_SHIFT)
qtMod |= Qt::ShiftModifier;
if (modifiers & KEYMOD_CTRL)
qtMod |= Qt::ControlModifier;
if (modifiers & KEYMOD_ALT)
qtMod |= Qt::AltModifier;
// determine event type
QEvent::Type type = (flags & KEY_DOWN) ? QEvent::KeyPress : QEvent::KeyRelease;
// Check if the key cap is valid
if (flags & KEY_CAP_VALID) {
Qt::Key key;
QString keyStr;
if (cap >= 0x20 && cap <= 0x0ff) {
key = Qt::Key(std::toupper(cap)); // Qt expects the CAP to be upper case.
if ( qtMod & Qt::ControlModifier ) {
keyStr = QChar((int)(key & 0x3f));
} else {
if (flags & KEY_SYM_VALID) {
keyStr = QChar(sym);
}
}
} else if ((cap > 0x0ff && cap < UNICODE_PRIVATE_USE_AREA_FIRST) || cap > UNICODE_PRIVATE_USE_AREA_LAST) {
key = (Qt::Key)cap;
keyStr = QChar(sym);
} else {
if (isKeypadKey(cap))
qtMod |= Qt::KeypadModifier; // Is this right?
key = keyTranslator(cap);
}
QWindowSystemInterface::handleKeyEvent(QGuiApplication::focusWindow(), type, key, qtMod, keyStr);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt key t=" << type << ", k=" << key << ", s=" << keyStr;
#endif
}
}
void QQnxEventThread::handlePointerEvent(screen_event_t event)
{
errno = 0;
// Query the window that was clicked
screen_window_t qnxWindow;
void *handle;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
qnxWindow = static_cast<screen_window_t>(handle);
// Query the button states
int buttonState = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_BUTTONS, &buttonState);
if (result) {
qFatal("QQNX: failed to query event button state, errno=%d", errno);
}
// Query the window position
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QQNX: failed to query event window position, errno=%d", errno);
}
// Query the screen position
int pos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QQNX: failed to query event position, errno=%d", errno);
}
// Query the wheel delta
int wheelDelta = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_MOUSE_WHEEL, &wheelDelta);
if (result) {
qFatal("QQNX: failed to query event wheel delta, errno=%d", errno);
}
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
// Generate enter and leave events as needed.
if (qnxWindow != m_lastMouseWindow) {
QWindow *wOld = QQnxIntegration::window(m_lastMouseWindow);
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt leave, w=" << wOld;
#endif
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt enter, w=" << w;
#endif
}
}
m_lastMouseWindow = qnxWindow;
// Apply scaling to wheel delta and invert value for Qt. We'll probably want to scale
// this via a system preference at some point. But for now this is a sane value and makes
// the wheel usable.
wheelDelta *= -10;
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// Convert buttons.
// Some QNX header files invert 'Right Button versus "Left Button' ('Right' == 0x01). But they also offer a 'Button Swap' bit,
// so we may receive events as shown. (If this is wrong, the fix is easy.)
// QNX Button mask is 8 buttons wide, with a maximum value of x080.
Qt::MouseButtons buttons = Qt::NoButton;
if (buttonState & 0x01)
buttons |= Qt::LeftButton;
if (buttonState & 0x02)
buttons |= Qt::MidButton;
if (buttonState & 0x04)
buttons |= Qt::RightButton;
if (buttonState & 0x08)
buttons |= Qt::ExtraButton1; // AKA 'Qt::BackButton'
if (buttonState & 0x10)
buttons |= Qt::ExtraButton2; // AKA 'Qt::ForwardButton'
if (buttonState & 0x20)
buttons |= Qt::ExtraButton3;
if (buttonState & 0x40)
buttons |= Qt::ExtraButton4;
if (buttonState & 0x80)
buttons |= Qt::ExtraButton5;
if (w) {
// Inject mouse event into Qt only if something has changed.
if (m_lastGlobalMousePoint != globalPoint ||
m_lastLocalMousePoint != localPoint ||
m_lastButtonState != buttons) {
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << static_cast<int>(buttons);
#endif
}
if (wheelDelta) {
// Screen only supports a single wheel, so we will assume Vertical orientation for
// now since that is pretty much standard.
QWindowSystemInterface::handleWheelEvent(w, localPoint, globalPoint, wheelDelta, Qt::Vertical);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt wheel, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), d=" << static_cast<int>(wheelDelta);
#endif
}
}
m_lastGlobalMousePoint = globalPoint;
m_lastLocalMousePoint = localPoint;
m_lastButtonState = buttons;
}
void QQnxEventThread::handleTouchEvent(screen_event_t event, int qnxType)
{
// get display coordinates of touch
errno = 0;
int pos[2];
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QQNX: failed to query event position, errno=%d", errno);
}
// get window coordinates of touch
errno = 0;
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QQNX: failed to query event window position, errno=%d", errno);
}
// determine which finger touched
errno = 0;
int touchId;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TOUCH_ID, &touchId);
if (result) {
qFatal("QQNX: failed to query event touch id, errno=%d", errno);
}
// determine which window was touched
errno = 0;
void *handle;
result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
screen_window_t qnxWindow = static_cast<screen_window_t>(handle);
// check if finger is valid
if (touchId < MaximumTouchPoints) {
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
// Generate enter and leave events as needed.
if (qnxWindow != m_lastMouseWindow) {
QWindow *wOld = QQnxIntegration::window(m_lastMouseWindow);
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt leave, w=" << wOld;
#endif
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt enter, w=" << w;
#endif
}
}
m_lastMouseWindow = qnxWindow;
if (w) {
// convert primary touch to mouse event
if (touchId == 0) {
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// map touch state to button state
Qt::MouseButtons buttons = (qnxType == SCREEN_EVENT_MTOUCH_RELEASE) ? Qt::NoButton : Qt::LeftButton;
// inject event into Qt
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << buttons;
#endif
}
// get size of screen which contains window
QPlatformScreen *platformScreen = QPlatformScreen::platformScreenForWindow(w);
QSizeF screenSize = platformScreen->physicalSize();
// update cached position of current touch point
m_touchPoints[touchId].normalPosition = QPointF( static_cast<qreal>(pos[0]) / screenSize.width(), static_cast<qreal>(pos[1]) / screenSize.height() );
m_touchPoints[touchId].area = QRectF( pos[0], pos[1], 0.0, 0.0 );
// determine event type and update state of current touch point
QEvent::Type type = QEvent::None;
switch (qnxType) {
case SCREEN_EVENT_MTOUCH_TOUCH:
m_touchPoints[touchId].state = Qt::TouchPointPressed;
type = QEvent::TouchBegin;
break;
case SCREEN_EVENT_MTOUCH_MOVE:
m_touchPoints[touchId].state = Qt::TouchPointMoved;
type = QEvent::TouchUpdate;
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
m_touchPoints[touchId].state = Qt::TouchPointReleased;
type = QEvent::TouchEnd;
break;
}
// build list of active touch points
QList<QWindowSystemInterface::TouchPoint> pointList;
for (int i = 0; i < MaximumTouchPoints; i++) {
if (i == touchId) {
// current touch point is always active
pointList.append(m_touchPoints[i]);
} else if (m_touchPoints[i].state != Qt::TouchPointReleased) {
// finger is down but did not move
m_touchPoints[i].state = Qt::TouchPointStationary;
pointList.append(m_touchPoints[i]);
}
}
// inject event into Qt
QWindowSystemInterface::handleTouchEvent(w, m_touchDevice, pointList);
#if defined(QQNXEVENTTHREAD_DEBUG)
qDebug() << "QQNX: Qt touch, w=" << w << ", p=(" << pos[0] << "," << pos[1] << "), t=" << type;
#endif
}
}
}
void QQnxEventThread::handleCloseEvent(screen_event_t event)
{
// Query the window that was closed
void *handle;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result != 0) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
screen_window_t qnxWindow = static_cast<screen_window_t>(handle);
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
if (w != 0) {
QWindowSystemInterface::handleCloseEvent(w);
}
}

23
src/plugins/platforms/qnx/qqnxeventthread.h
View File

@ -44,9 +44,6 @@
#include <QtCore/QThread>
#include <QtGui/QPlatformScreen>
#include <QtGui/QWindowSystemInterface>
#include <screen/screen.h>
QT_BEGIN_NAMESPACE
@ -54,35 +51,19 @@ QT_BEGIN_NAMESPACE
class QQnxEventThread : public QThread
{
public:
QQnxEventThread(screen_context_t context, QPlatformScreen& screen);
explicit QQnxEventThread(screen_context_t context);
virtual ~QQnxEventThread();
static void injectKeyboardEvent(int flags, int sym, int mod, int scan, int cap);
protected:
virtual void run();
void run();
private:
enum {
MaximumTouchPoints = 10
};
void shutdown();
void dispatchEvent(screen_event_t event);
void handleKeyboardEvent(screen_event_t event);
void handlePointerEvent(screen_event_t event);
void handleTouchEvent(screen_event_t event, int type);
void handleCloseEvent(screen_event_t event);
screen_context_t m_screenContext;
QPlatformScreen& m_platformScreen;
bool m_quit;
QPoint m_lastGlobalMousePoint;
QPoint m_lastLocalMousePoint;
Qt::MouseButtons m_lastButtonState;
screen_window_t m_lastMouseWindow;
QTouchDevice *m_touchDevice;
QWindowSystemInterface::TouchPoint m_touchPoints[MaximumTouchPoints];
};
QT_END_NAMESPACE

20
src/plugins/platforms/qnx/qqnxglbackingstore.h
View File

@ -58,11 +58,11 @@ class QQnxGLPaintDevice : public QGLPaintDevice
{
public:
QQnxGLPaintDevice(QWindow *window);
virtual ~QQnxGLPaintDevice();
~QQnxGLPaintDevice();
virtual QPaintEngine *paintEngine() const;
virtual QSize size() const;
virtual QGLContext *context() const { return m_glContext; }
QPaintEngine *paintEngine() const;
QSize size() const;
QGLContext *context() const { return m_glContext; }
private:
QQnxWindow *m_window;
@ -73,13 +73,13 @@ class QQnxGLBackingStore : public QPlatformBackingStore
{
public:
QQnxGLBackingStore(QWindow *window);
virtual ~QQnxGLBackingStore();
~QQnxGLBackingStore();
virtual QPaintDevice *paintDevice() { return m_paintDevice; }
virtual void flush(QWindow *window, const QRegion &region, const QPoint &offset);
virtual void resize(const QSize &size, const QRegion &staticContents);
virtual void beginPaint(const QRegion &region);
virtual void endPaint(const QRegion &region);
QPaintDevice *paintDevice() { return m_paintDevice; }
void flush(QWindow *window, const QRegion &region, const QPoint &offset);
void resize(const QSize &size, const QRegion &staticContents);
void beginPaint(const QRegion &region);
void endPaint(const QRegion &region);
void resizeSurface(const QSize &size);

8
src/plugins/platforms/qnx/qqnxglcontext.h
View File

@ -61,10 +61,10 @@ public:
static void initialize();
static void shutdown();
virtual bool makeCurrent(QPlatformSurface *surface);
virtual void doneCurrent();
virtual void swapBuffers(QPlatformSurface *surface);
virtual QFunctionPointer getProcAddress(const QByteArray &procName);
bool makeCurrent(QPlatformSurface *surface);
void doneCurrent();
void swapBuffers(QPlatformSurface *surface);
QFunctionPointer getProcAddress(const QByteArray &procName);
virtual QSurfaceFormat format() const { return m_windowFormat; }

24
src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
View File

@ -674,12 +674,15 @@ static bool imfAvailable()
return s_imfReady;
}
QQnxInputContext::QQnxInputContext():
QT_BEGIN_NAMESPACE
QQnxInputContext::QQnxInputContext(QQnxVirtualKeyboard &keyboard):
QPlatformInputContext(),
m_lastCaretPos(0),
m_isComposing(false),
m_inputPanelVisible(false),
m_inputPanelLocale(QLocale::c())
m_inputPanelLocale(QLocale::c()),
m_virtualKeyboad(keyboard)
{
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << Q_FUNC_INFO;
@ -697,7 +700,6 @@ QQnxInputContext::QQnxInputContext():
// p_vkb_init_selection_service();
QQnxVirtualKeyboard &keyboard = QQnxVirtualKeyboard::instance();
connect(&keyboard, SIGNAL(visibilityChanged(bool)), this, SLOT(keyboardVisibilityChanged(bool)));
connect(&keyboard, SIGNAL(localeChanged(QLocale)), this, SLOT(keyboardLocaleChanged(QLocale)));
keyboardVisibilityChanged(keyboard.isVisible());
@ -959,7 +961,7 @@ bool QQnxInputContext::hasSelectedText()
bool QQnxInputContext::dispatchRequestSoftwareInputPanel()
{
QQnxVirtualKeyboard::instance().showKeyboard();
m_virtualKeyboard.showKeyboard();
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << "QQNX: requesting virtual keyboard";
#endif
@ -986,7 +988,7 @@ bool QQnxInputContext::dispatchRequestSoftwareInputPanel()
bool QQnxInputContext::dispatchCloseSoftwareInputPanel()
{
QQnxVirtualKeyboard::instance().hideKeyboard();
m_virtualKeyboard.hideKeyboard();
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << "QQNX: hiding virtual keyboard";
#endif
@ -1685,12 +1687,14 @@ void QQnxInputContext::inputItemChanged()
if (m_inputPanelVisible)
hideInputPanel();
} else {
if (qobject_cast<QAbstractSpinBox*>(inputItem)) {
QQnxVirtualKeyboard::instance().setKeyboardMode(QQnxVirtualKeyboard::NumPunc);
} else {
QQnxVirtualKeyboard::instance().setKeyboardMode(QQnxVirtualKeyboard::Default);
}
if (qobject_cast<QAbstractSpinBox*>(inputItem))
m_virtualKeyboard.setKeyboardMode(QQnxVirtualKeyboard::Phone);
else
m_virtualKeyboard.setKeyboardMode(QQnxVirtualKeyboard::Default);
if (!m_inputPanelVisible)
showInputPanel();
}
}
QT_END_NAMESPACE

21
src/plugins/platforms/qnx/qqnxinputcontext_imf.h
View File

@ -53,25 +53,27 @@
QT_BEGIN_NAMESPACE
class QQnxVirtualKeyboard;
class QQnxInputContext : public QPlatformInputContext
{
Q_OBJECT
public:
QQnxInputContext();
QQnxInputContext(QQnxVirtualKeyboard &keyboard);
~QQnxInputContext();
virtual bool isValid() const;
bool isValid() const;
virtual bool filterEvent(const QEvent *event);
virtual void reset();
virtual void update(Qt::InputMethodQueries);
bool filterEvent(const QEvent *event);
void reset();
void update(Qt::InputMethodQueries);
bool handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap);
virtual void showInputPanel();
virtual void hideInputPanel();
virtual bool isInputPanelVisible() const;
void showInputPanel();
void hideInputPanel();
bool isInputPanelVisible() const;
virtual QLocale locale() const;
QLocale locale() const;
protected:
// Filters only for IMF events.
@ -123,6 +125,7 @@ private:
QString m_composingText;
bool m_inputPanelVisible;
QLocale m_inputPanelLocale;
QQnxVirtualKeyboard &m_virtualKeyboad;
};
Q_DECLARE_METATYPE(extracted_text_t*)

28
src/plugins/platforms/qnx/qqnxinputcontext_noimf.cpp
View File

@ -46,12 +46,14 @@
#include <QtGui/QGuiApplication>
#include <QtWidgets/QAbstractSpinBox>
QQnxInputContext::QQnxInputContext() :
QT_BEGIN_NAMESPACE
QQnxInputContext::QQnxInputContext(QQnxVirtualKeyboard &keyboard) :
QPlatformInputContext(),
m_inputPanelVisible(false),
m_inputPanelLocale(QLocale::c())
m_inputPanelLocale(QLocale::c()),
m_virtualKeyboard(keyboard)
{
QQnxVirtualKeyboard &keyboard = QQnxVirtualKeyboard::instance();
connect(&keyboard, SIGNAL(visibilityChanged(bool)), this, SLOT(keyboardVisibilityChanged(bool)));
connect(&keyboard, SIGNAL(localeChanged(QLocale)), this, SLOT(keyboardLocaleChanged(QLocale)));
keyboardVisibilityChanged(keyboard.isVisible());
@ -86,7 +88,7 @@ bool QQnxInputContext::filterEvent( const QEvent *event )
return false;
if (event->type() == QEvent::CloseSoftwareInputPanel) {
QQnxVirtualKeyboard::instance().hideKeyboard();
m_virtualKeyboard.hideKeyboard();
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << "QQNX: hiding virtual keyboard";
#endif
@ -94,7 +96,7 @@ bool QQnxInputContext::filterEvent( const QEvent *event )
}
if (event->type() == QEvent::RequestSoftwareInputPanel) {
QQnxVirtualKeyboard::instance().showKeyboard();
m_virtualKeyboard.showKeyboard();
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << "QQNX: requesting virtual keyboard";
#endif
@ -120,7 +122,7 @@ void QQnxInputContext::showInputPanel()
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << Q_FUNC_INFO;
#endif
QQnxVirtualKeyboard::instance().showKeyboard();
m_virtualKeyboard.showKeyboard();
}
void QQnxInputContext::hideInputPanel()
@ -128,7 +130,7 @@ void QQnxInputContext::hideInputPanel()
#if defined(QQNXINPUTCONTEXT_DEBUG)
qDebug() << Q_FUNC_INFO;
#endif
QQnxVirtualKeyboard::instance().hideKeyboard();
m_virtualKeyboard.hideKeyboard();
}
bool QQnxInputContext::isInputPanelVisible() const
@ -176,12 +178,14 @@ void QQnxInputContext::inputItemChanged()
if (m_inputPanelVisible)
hideInputPanel();
} else {
if (qobject_cast<QAbstractSpinBox*>(inputItem)) {
QQnxVirtualKeyboard::instance().setKeyboardMode(QQnxVirtualKeyboard::NumPunc);
} else {
QQnxVirtualKeyboard::instance().setKeyboardMode(QQnxVirtualKeyboard::Default);
}
if (qobject_cast<QAbstractSpinBox*>(inputItem))
m_virtualKeyboard.setKeyboardMode(QQnxVirtualKeyboard::Phone);
else
m_virtualKeyboard.setKeyboardMode(QQnxVirtualKeyboard::Default);
if (!m_inputPanelVisible)
showInputPanel();
}
}
QT_END_NAMESPACE

17
src/plugins/platforms/qnx/qqnxinputcontext_noimf.h
View File

@ -48,24 +48,26 @@
QT_BEGIN_NAMESPACE
class QQnxVirtualKeyboard;
class QQnxInputContext : public QPlatformInputContext
{
Q_OBJECT
public:
explicit QQnxInputContext();
explicit QQnxInputContext(QQnxVirtualKeyboard &keyboard);
~QQnxInputContext();
virtual bool isValid() const;
bool isValid() const;
void reset();
virtual bool filterEvent( const QEvent *event );
bool filterEvent( const QEvent *event );
bool handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap);
virtual void showInputPanel();
virtual void hideInputPanel();
virtual bool isInputPanelVisible() const;
void showInputPanel();
void hideInputPanel();
bool isInputPanelVisible() const;
virtual QLocale locale() const;
QLocale locale() const;
private Q_SLOTS:
void keyboardVisibilityChanged(bool visible);
@ -77,6 +79,7 @@ private:
bool m_inputPanelVisible;
QLocale m_inputPanelLocale;
QQnxVirtualKeyboard &m_virtualKeyboard;
};
QT_END_NAMESPACE

21
src/plugins/platforms/qnx/qqnxintegration.cpp
View File

@ -79,6 +79,7 @@ QQnxIntegration::QQnxIntegration()
: QPlatformIntegration()
, m_eventThread(0)
, m_navigatorEventHandler(0)
, m_virtualKeyboard(0)
, m_inputContext(0)
, m_fontDatabase(new QGenericUnixFontDatabase())
, m_paintUsingOpenGL(false)
@ -108,7 +109,7 @@ QQnxIntegration::QQnxIntegration()
QQnxGLContext::initialize();
// Create/start event thread
m_eventThread = new QQnxEventThread(m_screenContext, *QQnxScreen::primaryDisplay());
m_eventThread = new QQnxEventThread(m_screenContext);
m_eventThread->start();
// Create/start navigator event handler
@ -122,10 +123,18 @@ QQnxIntegration::QQnxIntegration()
#endif
// Create/start the keyboard class.
QQnxVirtualKeyboard::instance();
m_virtualKeyboard = new QQnxVirtualKeyboard();
// delay invocation of start() to the time the event loop is up and running
// needed to have the QThread internals of the main thread properly initialized
QMetaObject::invokeMethod(m_virtualKeyboard, "start", Qt::QueuedConnection);
// TODO check if we need to do this for all screens or only the primary one
QObject::connect(m_virtualKeyboard, SIGNAL(heightChanged(int)),
QQnxScreen::primaryDisplay(), SLOT(keyboardHeightChanged(int)));
// Set up the input context
m_inputContext = new QQnxInputContext;
m_inputContext = new QQnxInputContext(*m_virtualKeyboard);
// Create services handling class
#ifdef Q_OS_BLACKBERRY
@ -138,8 +147,12 @@ QQnxIntegration::~QQnxIntegration()
#if defined(QQNXINTEGRATION_DEBUG)
qDebug() << "QQnx: platform plugin shutdown begin";
#endif
// Destroy input context
delete m_inputContext;
// Destroy the keyboard class.
QQnxVirtualKeyboard::destroy();
delete m_virtualKeyboard;
#ifndef QT_NO_CLIPBOARD
// Delete the clipboard

28
src/plugins/platforms/qnx/qqnxintegration.h
View File

@ -53,6 +53,7 @@ QT_BEGIN_NAMESPACE
class QQnxEventThread;
class QQnxInputContext;
class QQnxNavigatorEventHandler;
class QQnxVirtualKeyboard;
class QQnxWindow;
class QQnxServices;
@ -67,32 +68,32 @@ class QQnxIntegration : public QPlatformIntegration
{
public:
QQnxIntegration();
virtual ~QQnxIntegration();
~QQnxIntegration();
virtual bool hasCapability(QPlatformIntegration::Capability cap) const;
bool hasCapability(QPlatformIntegration::Capability cap) const;
virtual QPlatformWindow *createPlatformWindow(QWindow *window) const;
virtual QPlatformBackingStore *createPlatformBackingStore(QWindow *window) const;
virtual QPlatformOpenGLContext *createPlatformOpenGLContext(QOpenGLContext *context) const;
QPlatformWindow *createPlatformWindow(QWindow *window) const;
QPlatformBackingStore *createPlatformBackingStore(QWindow *window) const;
QPlatformOpenGLContext *createPlatformOpenGLContext(QOpenGLContext *context) const;
virtual QPlatformInputContext *inputContext() const;
QPlatformInputContext *inputContext() const;
virtual QList<QPlatformScreen *> screens() const;
virtual void moveToScreen(QWindow *window, int screen);
QList<QPlatformScreen *> screens() const;
void moveToScreen(QWindow *window, int screen);
virtual QAbstractEventDispatcher *guiThreadEventDispatcher() const;
QAbstractEventDispatcher *guiThreadEventDispatcher() const;
virtual QPlatformFontDatabase *fontDatabase() const { return m_fontDatabase; }
QPlatformFontDatabase *fontDatabase() const { return m_fontDatabase; }
#ifndef QT_NO_CLIPBOARD
virtual QPlatformClipboard *clipboard() const;
QPlatformClipboard *clipboard() const;
#endif
virtual QVariant styleHint(StyleHint hint) const;
QVariant styleHint(StyleHint hint) const;
bool paintUsingOpenGL() const { return m_paintUsingOpenGL; }
virtual QPlatformServices *services() const;
QPlatformServices *services() const;
static QWindow *window(screen_window_t qnxWindow);
@ -103,6 +104,7 @@ private:
screen_context_t m_screenContext;
QQnxEventThread *m_eventThread;
QQnxNavigatorEventHandler *m_navigatorEventHandler;
QQnxVirtualKeyboard *m_virtualKeyboard;
QQnxInputContext *m_inputContext;
QPlatformFontDatabase *m_fontDatabase;
bool m_paintUsingOpenGL;

14
src/plugins/platforms/qnx/qqnxrasterbackingstore.h
View File

@ -54,14 +54,14 @@ class QQnxRasterBackingStore : public QPlatformBackingStore
{
public:
QQnxRasterBackingStore(QWindow *window);
virtual ~QQnxRasterBackingStore();
~QQnxRasterBackingStore();
virtual QPaintDevice *paintDevice();
virtual void flush(QWindow *window, const QRegion &region, const QPoint &offset);
virtual void resize(const QSize &size, const QRegion &staticContents);
virtual bool scroll(const QRegion &area, int dx, int dy);
virtual void beginPaint(const QRegion &region);
virtual void endPaint(const QRegion &region);
QPaintDevice *paintDevice();
void flush(QWindow *window, const QRegion &region, const QPoint &offset);
void resize(const QSize &size, const QRegion &staticContents);
bool scroll(const QRegion &area, int dx, int dy);
void beginPaint(const QRegion &region);
void endPaint(const QRegion &region);
private:
class ScrollOp {

17
src/plugins/platforms/qnx/qqnxscreen.cpp
View File

@ -40,11 +40,11 @@
****************************************************************************/
#include "qqnxscreen.h"
#include "qqnxvirtualkeyboard.h"
#include "qqnxwindow.h"
#include <QtCore/QDebug>
#include <QtCore/QUuid>
#include <QtGui/QWindowSystemInterface>
#include <errno.h>
@ -59,6 +59,7 @@ QQnxScreen::QQnxScreen(screen_context_t screenContext, screen_display_t display,
m_rootWindow(),
m_primaryScreen(primaryScreen),
m_posted(false),
m_keyboardHeight(0),
m_platformContext(0)
{
#if defined(QQNXSCREEN_DEBUG)
@ -182,9 +183,8 @@ QRect QQnxScreen::availableGeometry() const
qDebug() << Q_FUNC_INFO;
#endif
// available geometry = total geometry - keyboard
int keyboardHeight = QQnxVirtualKeyboard::instance().height();
return QRect(m_currentGeometry.x(), m_currentGeometry.y(),
m_currentGeometry.width(), m_currentGeometry.height() - keyboardHeight);
m_currentGeometry.width(), m_currentGeometry.height() - m_keyboardHeight);
}
/*!
@ -312,4 +312,15 @@ void QQnxScreen::onWindowPost(QQnxWindow *window)
}
}
void QQnxScreen::keyboardHeightChanged(int height)
{
if (height == m_keyboardHeight)
return;
m_keyboardHeight = height;
QWindowSystemInterface::handleScreenAvailableGeometryChange(screen(), availableGeometry());
}
QT_END_NAMESPACE

21
src/plugins/platforms/qnx/qqnxscreen.h
View File

@ -47,6 +47,7 @@
#include "qqnxrootwindow.h"
#include <QtCore/QByteArray>
#include <QtCore/QObject>
#include <QtCore/QScopedPointer>
#include <screen/screen.h>
@ -55,8 +56,9 @@ QT_BEGIN_NAMESPACE
class QQnxWindow;
class QQnxScreen : public QPlatformScreen
class QQnxScreen : public QObject, public QPlatformScreen
{
Q_OBJECT
public:
static QList<QPlatformScreen *> screens() { return ms_screens; }
static void createDisplays(screen_context_t context);
@ -64,11 +66,11 @@ public:
static QQnxScreen *primaryDisplay() { return static_cast<QQnxScreen*>(ms_screens.at(0)); }
static int defaultDepth();
virtual QRect geometry() const { return m_currentGeometry; }
virtual QRect availableGeometry() const;
virtual int depth() const { return defaultDepth(); }
virtual QImage::Format format() const { return (depth() == 32) ? QImage::Format_RGB32 : QImage::Format_RGB16; }
virtual QSizeF physicalSize() const { return m_currentPhysicalSize; }
QRect geometry() const { return m_currentGeometry; }
QRect availableGeometry() const;
int depth() const { return defaultDepth(); }
QImage::Format format() const { return (depth() == 32) ? QImage::Format_RGB32 : QImage::Format_RGB16; }
QSizeF physicalSize() const { return m_currentPhysicalSize; }
bool isPrimaryScreen() const { return m_primaryScreen; }
@ -91,9 +93,12 @@ public:
QSharedPointer<QQnxRootWindow> rootWindow() const { return m_rootWindow; }
private Q_SLOTS:
void keyboardHeightChanged(int height);
private:
QQnxScreen(screen_context_t context, screen_display_t display, bool primaryScreen);
virtual ~QQnxScreen();
~QQnxScreen();
static bool orthogonal(int rotation1, int rotation2);
@ -102,10 +107,10 @@ private:
QSharedPointer<QQnxRootWindow> m_rootWindow;
bool m_primaryScreen;
bool m_posted;
bool m_usingOpenGL;
int m_initialRotation;
int m_currentRotation;
int m_keyboardHeight;
QSize m_initialPhysicalSize;
QSize m_currentPhysicalSize;
QRect m_initialGeometry;

473
src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp Normal file
View File

@ -0,0 +1,473 @@
/***************************************************************************
**
** Copyright (C) 2011 - 2012 Research In Motion
** Contact: http://www.qt-project.org/
**
** This file is part of the plugins of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qqnxscreeneventhandler.h"
#include "qqnxintegration.h"
#include "qqnxkeytranslator.h"
#include <QDebug>
#include <QGuiApplication>
#include <errno.h>
#include <sys/keycodes.h>
QT_BEGIN_NAMESPACE
QQnxScreenEventHandler::QQnxScreenEventHandler()
: m_lastButtonState(Qt::NoButton)
, m_lastMouseWindow(0)
, m_touchDevice(0)
{
// Create a touch device
m_touchDevice = new QTouchDevice;
m_touchDevice->setType(QTouchDevice::TouchScreen);
m_touchDevice->setCapabilities(QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::Pressure | QTouchDevice::NormalizedPosition);
QWindowSystemInterface::registerTouchDevice(m_touchDevice);
// initialize array of touch points
for (int i = 0; i < MaximumTouchPoints; i++) {
// map array index to id
m_touchPoints[i].id = i;
// pressure is not supported - use default
m_touchPoints[i].pressure = 1.0;
// nothing touching
m_touchPoints[i].state = Qt::TouchPointReleased;
}
}
bool QQnxScreenEventHandler::handleEvent(screen_event_t event)
{
// get the event type
errno = 0;
int qnxType;
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &qnxType);
if (result) {
qFatal("QQNX: failed to query event type, errno=%d", errno);
}
return handleEvent(event, qnxType);
}
bool QQnxScreenEventHandler::handleEvent(screen_event_t event, int qnxType)
{
switch (qnxType) {
case SCREEN_EVENT_MTOUCH_TOUCH:
case SCREEN_EVENT_MTOUCH_MOVE:
case SCREEN_EVENT_MTOUCH_RELEASE:
handleTouchEvent(event, qnxType);
break;
case SCREEN_EVENT_KEYBOARD:
handleKeyboardEvent(event);
break;
case SCREEN_EVENT_POINTER:
handlePointerEvent(event);
break;
case SCREEN_EVENT_CLOSE:
handleCloseEvent(event);
break;
default:
// event ignored
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: QNX unknown event";
#endif
return false;
}
return true;
}
void QQnxScreenEventHandler::injectKeyboardEvent(int flags, int sym, int modifiers, int scan, int cap)
{
Q_UNUSED(scan);
Qt::KeyboardModifiers qtMod = Qt::NoModifier;
if (modifiers & KEYMOD_SHIFT)
qtMod |= Qt::ShiftModifier;
if (modifiers & KEYMOD_CTRL)
qtMod |= Qt::ControlModifier;
if (modifiers & KEYMOD_ALT)
qtMod |= Qt::AltModifier;
// determine event type
QEvent::Type type = (flags & KEY_DOWN) ? QEvent::KeyPress : QEvent::KeyRelease;
// Check if the key cap is valid
if (flags & KEY_CAP_VALID) {
Qt::Key key;
QString keyStr;
if (cap >= 0x20 && cap <= 0x0ff) {
key = Qt::Key(std::toupper(cap)); // Qt expects the CAP to be upper case.
if ( qtMod & Qt::ControlModifier ) {
keyStr = QChar((int)(key & 0x3f));
} else {
if (flags & KEY_SYM_VALID) {
keyStr = QChar(sym);
}
}
} else if ((cap > 0x0ff && cap < UNICODE_PRIVATE_USE_AREA_FIRST) || cap > UNICODE_PRIVATE_USE_AREA_LAST) {
key = (Qt::Key)cap;
keyStr = QChar(sym);
} else {
if (isKeypadKey(cap))
qtMod |= Qt::KeypadModifier; // Is this right?
key = keyTranslator(cap);
}
QWindowSystemInterface::handleKeyEvent(QGuiApplication::focusWindow(), type, key, qtMod, keyStr);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt key t=" << type << ", k=" << key << ", s=" << keyStr;
#endif
}
}
void QQnxScreenEventHandler::handleKeyboardEvent(screen_event_t event)
{
// get flags of key event
errno = 0;
int flags;
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_FLAGS, &flags);
if (result) {
qFatal("QQNX: failed to query event flags, errno=%d", errno);
}
// get key code
errno = 0;
int sym;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SYM, &sym);
if (result) {
qFatal("QQNX: failed to query event sym, errno=%d", errno);
}
int modifiers;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_MODIFIERS, &modifiers);
if (result) {
qFatal("QQNX: failed to query event modifiers, errno=%d", errno);
}
int scan;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_SCAN, &scan);
if (result) {
qFatal("QQNX: failed to query event modifiers, errno=%d", errno);
}
int cap;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_KEY_CAP, &cap);
if (result) {
qFatal("QQNX: failed to query event cap, errno=%d", errno);
}
injectKeyboardEvent(flags, sym, modifiers, scan, cap);
}
void QQnxScreenEventHandler::handlePointerEvent(screen_event_t event)
{
errno = 0;
// Query the window that was clicked
screen_window_t qnxWindow;
void *handle;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
qnxWindow = static_cast<screen_window_t>(handle);
// Query the button states
int buttonState = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_BUTTONS, &buttonState);
if (result) {
qFatal("QQNX: failed to query event button state, errno=%d", errno);
}
// Query the window position
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QQNX: failed to query event window position, errno=%d", errno);
}
// Query the screen position
int pos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QQNX: failed to query event position, errno=%d", errno);
}
// Query the wheel delta
int wheelDelta = 0;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_MOUSE_WHEEL, &wheelDelta);
if (result) {
qFatal("QQNX: failed to query event wheel delta, errno=%d", errno);
}
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
// Generate enter and leave events as needed.
if (qnxWindow != m_lastMouseWindow) {
QWindow *wOld = QQnxIntegration::window(m_lastMouseWindow);
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt leave, w=" << wOld;
#endif
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt enter, w=" << w;
#endif
}
}
m_lastMouseWindow = qnxWindow;
// Apply scaling to wheel delta and invert value for Qt. We'll probably want to scale
// this via a system preference at some point. But for now this is a sane value and makes
// the wheel usable.
wheelDelta *= -10;
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// Convert buttons.
// Some QNX header files invert 'Right Button versus "Left Button' ('Right' == 0x01). But they also offer a 'Button Swap' bit,
// so we may receive events as shown. (If this is wrong, the fix is easy.)
// QNX Button mask is 8 buttons wide, with a maximum value of x080.
Qt::MouseButtons buttons = Qt::NoButton;
if (buttonState & 0x01)
buttons |= Qt::LeftButton;
if (buttonState & 0x02)
buttons |= Qt::MidButton;
if (buttonState & 0x04)
buttons |= Qt::RightButton;
if (buttonState & 0x08)
buttons |= Qt::ExtraButton1; // AKA 'Qt::BackButton'
if (buttonState & 0x10)
buttons |= Qt::ExtraButton2; // AKA 'Qt::ForwardButton'
if (buttonState & 0x20)
buttons |= Qt::ExtraButton3;
if (buttonState & 0x40)
buttons |= Qt::ExtraButton4;
if (buttonState & 0x80)
buttons |= Qt::ExtraButton5;
if (w) {
// Inject mouse event into Qt only if something has changed.
if (m_lastGlobalMousePoint != globalPoint ||
m_lastLocalMousePoint != localPoint ||
m_lastButtonState != buttons) {
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << static_cast<int>(buttons);
#endif
}
if (wheelDelta) {
// Screen only supports a single wheel, so we will assume Vertical orientation for
// now since that is pretty much standard.
QWindowSystemInterface::handleWheelEvent(w, localPoint, globalPoint, wheelDelta, Qt::Vertical);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt wheel, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), d=" << static_cast<int>(wheelDelta);
#endif
}
}
m_lastGlobalMousePoint = globalPoint;
m_lastLocalMousePoint = localPoint;
m_lastButtonState = buttons;
}
void QQnxScreenEventHandler::handleTouchEvent(screen_event_t event, int qnxType)
{
// get display coordinates of touch
errno = 0;
int pos[2];
int result = screen_get_event_property_iv(event, SCREEN_PROPERTY_POSITION, pos);
if (result) {
qFatal("QQNX: failed to query event position, errno=%d", errno);
}
// get window coordinates of touch
errno = 0;
int windowPos[2];
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SOURCE_POSITION, windowPos);
if (result) {
qFatal("QQNX: failed to query event window position, errno=%d", errno);
}
// determine which finger touched
errno = 0;
int touchId;
result = screen_get_event_property_iv(event, SCREEN_PROPERTY_TOUCH_ID, &touchId);
if (result) {
qFatal("QQNX: failed to query event touch id, errno=%d", errno);
}
// determine which window was touched
errno = 0;
void *handle;
result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
screen_window_t qnxWindow = static_cast<screen_window_t>(handle);
// check if finger is valid
if (touchId < MaximumTouchPoints) {
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
// Generate enter and leave events as needed.
if (qnxWindow != m_lastMouseWindow) {
QWindow *wOld = QQnxIntegration::window(m_lastMouseWindow);
if (wOld) {
QWindowSystemInterface::handleLeaveEvent(wOld);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt leave, w=" << wOld;
#endif
}
if (w) {
QWindowSystemInterface::handleEnterEvent(w);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt enter, w=" << w;
#endif
}
}
m_lastMouseWindow = qnxWindow;
if (w) {
// convert primary touch to mouse event
if (touchId == 0) {
// convert point to local coordinates
QPoint globalPoint(pos[0], pos[1]);
QPoint localPoint(windowPos[0], windowPos[1]);
// map touch state to button state
Qt::MouseButtons buttons = (qnxType == SCREEN_EVENT_MTOUCH_RELEASE) ? Qt::NoButton : Qt::LeftButton;
// inject event into Qt
QWindowSystemInterface::handleMouseEvent(w, localPoint, globalPoint, buttons);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt mouse, w=" << w << ", (" << localPoint.x() << "," << localPoint.y() << "), b=" << buttons;
#endif
}
// get size of screen which contains window
QPlatformScreen *platformScreen = QPlatformScreen::platformScreenForWindow(w);
QSizeF screenSize = platformScreen->physicalSize();
// update cached position of current touch point
m_touchPoints[touchId].normalPosition = QPointF( static_cast<qreal>(pos[0]) / screenSize.width(), static_cast<qreal>(pos[1]) / screenSize.height() );
m_touchPoints[touchId].area = QRectF( pos[0], pos[1], 0.0, 0.0 );
// determine event type and update state of current touch point
QEvent::Type type = QEvent::None;
switch (qnxType) {
case SCREEN_EVENT_MTOUCH_TOUCH:
m_touchPoints[touchId].state = Qt::TouchPointPressed;
type = QEvent::TouchBegin;
break;
case SCREEN_EVENT_MTOUCH_MOVE:
m_touchPoints[touchId].state = Qt::TouchPointMoved;
type = QEvent::TouchUpdate;
break;
case SCREEN_EVENT_MTOUCH_RELEASE:
m_touchPoints[touchId].state = Qt::TouchPointReleased;
type = QEvent::TouchEnd;
break;
}
// build list of active touch points
QList<QWindowSystemInterface::TouchPoint> pointList;
for (int i = 0; i < MaximumTouchPoints; i++) {
if (i == touchId) {
// current touch point is always active
pointList.append(m_touchPoints[i]);
} else if (m_touchPoints[i].state != Qt::TouchPointReleased) {
// finger is down but did not move
m_touchPoints[i].state = Qt::TouchPointStationary;
pointList.append(m_touchPoints[i]);
}
}
// inject event into Qt
QWindowSystemInterface::handleTouchEvent(w, m_touchDevice, pointList);
#if defined(QQNXSCREENEVENT_DEBUG)
qDebug() << "QQNX: Qt touch, w=" << w << ", p=(" << pos[0] << "," << pos[1] << "), t=" << type;
#endif
}
}
}
void QQnxScreenEventHandler::handleCloseEvent(screen_event_t event)
{
// Query the window that was closed
void *handle;
int result = screen_get_event_property_pv(event, SCREEN_PROPERTY_WINDOW, &handle);
if (result != 0) {
qFatal("QQNX: failed to query event window, errno=%d", errno);
}
screen_window_t qnxWindow = static_cast<screen_window_t>(handle);
// Map window handle to top-level QWindow
QWindow *w = QQnxIntegration::window(qnxWindow);
if (w != 0) {
QWindowSystemInterface::handleCloseEvent(w);
}
}
QT_END_NAMESPACE

82
src/plugins/platforms/qnx/qqnxscreeneventhandler.h Normal file
View File

@ -0,0 +1,82 @@
/***************************************************************************
**
** Copyright (C) 2011 - 2012 Research In Motion
** Contact: http://www.qt-project.org/
**
** This file is part of the plugins of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QQNXSCREENEVENTHANDLER_H
#define QQNXSCREENEVENTHANDLER_H
#include <QWindowSystemInterface>
#include <screen/screen.h>
QT_BEGIN_NAMESPACE
class QQnxScreenEventHandler
{
public:
QQnxScreenEventHandler();
bool handleEvent(screen_event_t event);
bool handleEvent(screen_event_t event, int qnxType);
static void injectKeyboardEvent(int flags, int sym, int mod, int scan, int cap);
private:
void handleKeyboardEvent(screen_event_t event);
void handlePointerEvent(screen_event_t event);
void handleTouchEvent(screen_event_t event, int qnxType);
void handleCloseEvent(screen_event_t event);
private:
enum {
MaximumTouchPoints = 10
};
QPoint m_lastGlobalMousePoint;
QPoint m_lastLocalMousePoint;
Qt::MouseButtons m_lastButtonState;
screen_window_t m_lastMouseWindow;
QTouchDevice *m_touchDevice;
QWindowSystemInterface::TouchPoint m_touchPoints[MaximumTouchPoints];
};
QT_END_NAMESPACE
#endif // QQNXSCREENEVENTHANDLER_H

59
src/plugins/platforms/qnx/qqnxvirtualkeyboard.cpp
View File

@ -42,9 +42,6 @@
#include "qqnxvirtualkeyboard.h"
#include "qqnxscreen.h"
#include <QtGui/QPlatformScreen>
#include <QtGui/QPlatformWindow>
#include <QtCore/QDebug>
#include <QtCore/QSocketNotifier>
#include <QtCore/private/qcore_unix_p.h>
@ -59,11 +56,11 @@
#include <sys/types.h>
#include <unistd.h>
QT_BEGIN_NAMESPACE
const char *QQnxVirtualKeyboard::ms_PPSPath = "/pps/services/input/control?wait";
const size_t QQnxVirtualKeyboard::ms_bufferSize = 2048;
static QQnxVirtualKeyboard *s_instance = 0;
// Huge hack for keyboard shadow (see QNX PR 88400). Should be removed ASAP.
#define KEYBOARD_SHADOW_HEIGHT 8
@ -85,20 +82,6 @@ QQnxVirtualKeyboard::~QQnxVirtualKeyboard()
close();
}
/* static */
QQnxVirtualKeyboard& QQnxVirtualKeyboard::instance()
{
if (!s_instance) {
s_instance = new QQnxVirtualKeyboard();
// delay invocation of start() to the time the event loop is up and running
// needed to have the QThread internals of the main thread properly initialized
QMetaObject::invokeMethod(s_instance, "start", Qt::QueuedConnection);
}
return *s_instance;
}
void QQnxVirtualKeyboard::start()
{
#ifdef QQNXVIRTUALKEYBOARD_DEBUG
@ -108,15 +91,6 @@ void QQnxVirtualKeyboard::start()
return;
}
/* static */
void QQnxVirtualKeyboard::destroy()
{
if (s_instance) {
delete s_instance;
s_instance = 0;
}
}
void QQnxVirtualKeyboard::close()
{
delete m_readNotifier;
@ -292,7 +266,8 @@ void QQnxVirtualKeyboard::handleKeyboardInfoMessage()
if (newHeight != m_height) {
m_height = newHeight;
updateAvailableScreenGeometry();
if (m_visible)
emit heightChanged(m_height);
}
const QLocale locale = QLocale(languageId + QLatin1Char('_') + countryId);
@ -312,7 +287,8 @@ void QQnxVirtualKeyboard::handleKeyboardStateChangeMessage(bool visible)
#ifdef QQNXVIRTUALKEYBOARD_DEBUG
qDebug() << "QQNX: handleKeyboardStateChangeMessage " << visible;
#endif
updateAvailableScreenGeometry();
if (visible != m_visible)
emit heightChanged(height());
if (visible)
showKeyboard();
@ -320,19 +296,6 @@ void QQnxVirtualKeyboard::handleKeyboardStateChangeMessage(bool visible)
hideKeyboard();
}
void QQnxVirtualKeyboard::updateAvailableScreenGeometry()
{
#ifdef QQNXVIRTUALKEYBOARD_DEBUG
qDebug() << "QQNX: updateAvailableScreenGeometry: keyboard visible=" << m_visible << ", keyboard height=" << m_height;
#endif
// TODO: What screen index should be used? I assume primaryScreen here because it works, and
// we do it for handleScreenGeometryChange elsewhere but since we have support
// for more than one screen, that's not going to always work.
QQnxScreen *platformScreen = QQnxScreen::primaryDisplay();
QWindowSystemInterface::handleScreenAvailableGeometryChange(platformScreen->screen(), platformScreen->availableGeometry());
}
bool QQnxVirtualKeyboard::showKeyboard()
{
#ifdef QQNXVIRTUALKEYBOARD_DEBUG
@ -347,6 +310,9 @@ bool QQnxVirtualKeyboard::showKeyboard()
// hiding the keyboard wipes the setting.
applyKeyboardModeOptions();
if (m_visible)
return true;
pps_encoder_reset(m_encoder);
// Send the show message.
@ -398,7 +364,12 @@ bool QQnxVirtualKeyboard::hideKeyboard()
void QQnxVirtualKeyboard::setKeyboardMode(KeyboardMode mode)
{
if (m_keyboardMode == mode)
return;
m_keyboardMode = mode;
if (m_visible)
applyKeyboardModeOptions();
}
void QQnxVirtualKeyboard::applyKeyboardModeOptions()
@ -495,3 +466,5 @@ void QQnxVirtualKeyboard::addSymbolModeOptions()
pps_encoder_add_string(m_encoder, "enter", "enter.default");
pps_encoder_add_string(m_encoder, "type", "symbol");
}
QT_END_NAMESPACE

14
src/plugins/platforms/qnx/qqnxvirtualkeyboard.h
View File

@ -45,17 +45,16 @@
#include <QtCore/QObject>
#include <QtCore/QLocale>
#include <QtGui/QPlatformScreen>
#include <QtGui/QWindowSystemInterface>
#include <stddef.h>
#include <vector>
#include <string>
#include <sys/pps.h>
class QSocketNotifier;
QT_BEGIN_NAMESPACE
class QSocketNotifier;
/* Shamelessly copied from the browser - this should be rewritten once we have a proper PPS wrapper class */
class QQnxVirtualKeyboard : public QObject
{
@ -74,8 +73,8 @@ public:
//
enum KeyboardMode { Default, Url, Email, Web, NumPunc, Symbol, Phone, Pin };
static QQnxVirtualKeyboard& instance();
static void destroy();
QQnxVirtualKeyboard();
~QQnxVirtualKeyboard();
bool showKeyboard();
bool hideKeyboard();
@ -91,21 +90,18 @@ public Q_SLOTS:
Q_SIGNALS:
void localeChanged(const QLocale &locale);
void visibilityChanged(bool visible);
void heightChanged(int height);
private Q_SLOTS:
void ppsDataReady();
private:
QQnxVirtualKeyboard();
virtual ~QQnxVirtualKeyboard();
// Will be called internally if needed.
bool connect();
void close();
bool queryPPSInfo();
void handleKeyboardInfoMessage();
void handleKeyboardStateChangeMessage(bool visible);
void updateAvailableScreenGeometry();
void applyKeyboardModeOptions();
void addDefaultModeOptions();

16
src/plugins/platforms/qnx/qqnxwindow.h
View File

@ -69,11 +69,11 @@ public:
QQnxWindow(QWindow *window, screen_context_t context);
virtual ~QQnxWindow();
virtual void setGeometry(const QRect &rect);
virtual void setVisible(bool visible);
virtual void setOpacity(qreal level);
void setGeometry(const QRect &rect);
void setVisible(bool visible);
void setOpacity(qreal level);
virtual WId winId() const { return (WId)m_window; }
WId winId() const { return (WId)m_window; }
screen_window_t nativeHandle() const { return m_window; }
void setBufferSize(const QSize &size);
@ -86,10 +86,10 @@ public:
void setScreen(QQnxScreen *platformScreen);
virtual void setParent(const QPlatformWindow *window);
virtual void raise();
virtual void lower();
virtual void requestActivateWindow();
void setParent(const QPlatformWindow *window);
void raise();
void lower();
void requestActivateWindow();
void gainedFocus();

13
src/tools/qdoc/ditaxmlgenerator.cpp
View File

@ -4818,13 +4818,13 @@ void DitaXmlGenerator::writeFunctions(const Section& s,
FunctionNode* fn = const_cast<FunctionNode*>(static_cast<const FunctionNode*>(*m));
writeStartTag(DT_cxxFunction);
xmlWriter().writeAttribute("id",fn->guid());
if (fn->metaness() == FunctionNode::Signal)
xmlWriter().writeAttribute("otherprops","signal");
else if (fn->metaness() == FunctionNode::Slot)
xmlWriter().writeAttribute("otherprops","slot");
if (!attribute.isEmpty())
xmlWriter().writeAttribute("outputclass",attribute);
writeStartTag(DT_apiName);
if (fn->metaness() == FunctionNode::Signal)
xmlWriter().writeAttribute("outputclass","signal");
else if (fn->metaness() == FunctionNode::Slot)
xmlWriter().writeAttribute("outputclass","slot");
writeCharacters(fn->name());
writeEndTag(); // </apiName>
generateBrief(fn,marker);
@ -4976,6 +4976,11 @@ void DitaXmlGenerator::replaceTypesWithLinks(const Node* n,
else
addLink(linkForNode(tn,parent),arg,DT_apiRelation);
}
else {
// Write simple arguments, like void and bool,
// which do not have a Qt defined target.
writeCharacters(arg.toString());
}
}
}
else {

2
src/tools/rcc/rcc.cpp
View File

@ -52,6 +52,8 @@
#include <QtCore/QStack>
#include <QtCore/QXmlStreamReader>
// Note: A copy of this file is used in Qt Designer (qttools/src/designer/src/lib/shared/rcc.cpp)
QT_BEGIN_NAMESPACE
enum {

2
src/tools/rcc/rcc.h
View File

@ -39,6 +39,8 @@
**
****************************************************************************/
// Note: A copy of this file is used in Qt Designer (qttools/src/designer/src/lib/shared/rcc_p.h)
#ifndef RCC_H
#define RCC_H