diff options
Diffstat (limited to 'src/platformsupport')
106 files changed, 6022 insertions, 1051 deletions
diff --git a/src/platformsupport/cglconvenience/cglconvenience.mm b/src/platformsupport/cglconvenience/cglconvenience.mm deleted file mode 100644 index 85add35879..0000000000 --- a/src/platformsupport/cglconvenience/cglconvenience.mm +++ /dev/null @@ -1,131 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the plugins of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "cglconvenience_p.h" -#include <QtCore/qglobal.h> -#include <QtCore/private/qcore_mac_p.h> -#include <AppKit/AppKit.h> -#include <QVector> -#include <qdebug.h> - -// Match up with createNSOpenGLPixelFormat below! -QSurfaceFormat qcgl_surfaceFormat() -{ - QSurfaceFormat format; - format.setRenderableType(QSurfaceFormat::OpenGL); - format.setRedBufferSize(8); - format.setGreenBufferSize(8); - format.setBlueBufferSize(8); - format.setAlphaBufferSize(8); -/* - format.setDepthBufferSize(24); - format.setAccumBufferSize(0); - format.setStencilBufferSize(8); - format.setSampleBuffers(false); - format.setSamples(1); - format.setDepth(true); - format.setRgba(true); - format.setAlpha(true); - format.setAccum(false); - format.setStencil(true); - format.setStereo(false); - format.setDirectRendering(false); -*/ - return format; -} - -void *qcgl_createNSOpenGLPixelFormat(const QSurfaceFormat &format) -{ - - QVector<NSOpenGLPixelFormatAttribute> attrs; - - if (format.swapBehavior() == QSurfaceFormat::DoubleBuffer - || format.swapBehavior() == QSurfaceFormat::DefaultSwapBehavior) - attrs.append(NSOpenGLPFADoubleBuffer); - else if (format.swapBehavior() == QSurfaceFormat::TripleBuffer) - attrs.append(NSOpenGLPFATripleBuffer); - - if (format.profile() == QSurfaceFormat::CoreProfile - && ((format.majorVersion() == 3 && format.minorVersion() >= 2) - || format.majorVersion() > 3)) { - attrs << NSOpenGLPFAOpenGLProfile; - attrs << NSOpenGLProfileVersion3_2Core; - } else { - attrs << NSOpenGLPFAOpenGLProfile; - attrs << NSOpenGLProfileVersionLegacy; - } - - if (format.depthBufferSize() > 0) - attrs << NSOpenGLPFADepthSize << format.depthBufferSize(); - if (format.stencilBufferSize() > 0) - attrs << NSOpenGLPFAStencilSize << format.stencilBufferSize(); - if (format.alphaBufferSize() > 0) - attrs << NSOpenGLPFAAlphaSize << format.alphaBufferSize(); - if ((format.redBufferSize() > 0) && - (format.greenBufferSize() > 0) && - (format.blueBufferSize() > 0)) { - const int colorSize = format.redBufferSize() + - format.greenBufferSize() + - format.blueBufferSize(); - attrs << NSOpenGLPFAColorSize << colorSize << NSOpenGLPFAMinimumPolicy; - } - - if (format.samples() > 0) { - attrs << NSOpenGLPFAMultisample - << NSOpenGLPFASampleBuffers << (NSOpenGLPixelFormatAttribute) 1 - << NSOpenGLPFASamples << (NSOpenGLPixelFormatAttribute) format.samples(); - } - - if (format.stereo()) - attrs << NSOpenGLPFAStereo; - - attrs << NSOpenGLPFAAllowOfflineRenderers; - - QByteArray useLayer = qgetenv("QT_MAC_WANTS_LAYER"); - if (!useLayer.isEmpty() && useLayer.toInt() > 0) { - // Disable the software rendering fallback. This makes compositing - // OpenGL and raster NSViews using Core Animation layers possible. - attrs << NSOpenGLPFANoRecovery; - } - - attrs << 0; - - NSOpenGLPixelFormat* pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs.constData()]; - return pixelFormat; -} diff --git a/src/platformsupport/cglconvenience/cglconvenience.pro b/src/platformsupport/cglconvenience/cglconvenience.pro deleted file mode 100644 index 89d1fc4643..0000000000 --- a/src/platformsupport/cglconvenience/cglconvenience.pro +++ /dev/null @@ -1,17 +0,0 @@ -TARGET = QtCglSupport -MODULE = cgl_support - -QT = core-private gui -CONFIG += static internal_module - -DEFINES += QT_NO_CAST_FROM_ASCII - -HEADERS += \ - cglconvenience_p.h - -OBJECTIVE_SOURCES += \ - cglconvenience.mm - -LIBS_PRIVATE += -framework AppKit -framework OpenGL - -load(qt_module) diff --git a/src/platformsupport/clipboard/clipboard.pro b/src/platformsupport/clipboard/clipboard.pro index def2a061a0..916f6b0c06 100644 --- a/src/platformsupport/clipboard/clipboard.pro +++ b/src/platformsupport/clipboard/clipboard.pro @@ -9,6 +9,7 @@ DEFINES += QT_NO_CAST_FROM_ASCII HEADERS += qmacmime_p.h SOURCES += qmacmime.mm +LIBS += -framework ImageIO macos: LIBS_PRIVATE += -framework AppKit load(qt_module) diff --git a/src/platformsupport/clipboard/qmacmime.mm b/src/platformsupport/clipboard/qmacmime.mm index 6a6e033bec..09901ba0a5 100644 --- a/src/platformsupport/clipboard/qmacmime.mm +++ b/src/platformsupport/clipboard/qmacmime.mm @@ -37,10 +37,15 @@ ** ****************************************************************************/ +#include <ImageIO/ImageIO.h> + #include <QtCore/qsystemdetection.h> +#include <QtGui/qimage.h> #if defined(Q_OS_OSX) #import <AppKit/AppKit.h> +#else +#include <MobileCoreServices/MobileCoreServices.h> #endif #if defined(QT_PLATFORM_UIKIT) @@ -779,6 +784,85 @@ QList<QByteArray> QMacPasteboardMimeVCard::convertFromMime(const QString &mime, return ret; } +extern QImage qt_mac_toQImage(CGImageRef image); +extern CGImageRef qt_mac_toCGImage(const QImage &qImage); + +class QMacPasteboardMimeTiff : public QMacInternalPasteboardMime { +public: + QMacPasteboardMimeTiff() : QMacInternalPasteboardMime(MIME_ALL) { } + QString convertorName(); + + QString flavorFor(const QString &mime); + QString mimeFor(QString flav); + bool canConvert(const QString &mime, QString flav); + QVariant convertToMime(const QString &mime, QList<QByteArray> data, QString flav); + QList<QByteArray> convertFromMime(const QString &mime, QVariant data, QString flav); +}; + +QString QMacPasteboardMimeTiff::convertorName() +{ + return QLatin1String("Tiff"); +} + +QString QMacPasteboardMimeTiff::flavorFor(const QString &mime) +{ + if (mime.startsWith(QLatin1String("application/x-qt-image"))) + return QLatin1String("public.tiff"); + return QString(); +} + +QString QMacPasteboardMimeTiff::mimeFor(QString flav) +{ + if (flav == QLatin1String("public.tiff")) + return QLatin1String("application/x-qt-image"); + return QString(); +} + +bool QMacPasteboardMimeTiff::canConvert(const QString &mime, QString flav) +{ + return flav == QLatin1String("public.tiff") && mime == QLatin1String("application/x-qt-image"); +} + +QVariant QMacPasteboardMimeTiff::convertToMime(const QString &mime, QList<QByteArray> data, QString flav) +{ + if (data.count() > 1) + qWarning("QMacPasteboardMimeTiff: Cannot handle multiple member data"); + + if (!canConvert(mime, flav)) + return QVariant(); + + QCFType<CFDataRef> tiffData = data.first().toRawCFData(); + QCFType<CGImageSourceRef> imageSource = CGImageSourceCreateWithData(tiffData, 0); + + if (QCFType<CGImageRef> image = CGImageSourceCreateImageAtIndex(imageSource, 0, 0)) + return QVariant(qt_mac_toQImage(image)); + + return QVariant(); +} + +QList<QByteArray> QMacPasteboardMimeTiff::convertFromMime(const QString &mime, QVariant variant, QString flav) +{ + if (!canConvert(mime, flav)) + return QList<QByteArray>(); + + QCFType<CFMutableDataRef> data = CFDataCreateMutable(0, 0); + QCFType<CGImageDestinationRef> imageDestination = CGImageDestinationCreateWithData(data, kUTTypeTIFF, 1, 0); + + if (!imageDestination) + return QList<QByteArray>(); + + QImage img = qvariant_cast<QImage>(variant); + NSDictionary *props = @{ + static_cast<NSString *>(kCGImagePropertyPixelWidth) : [NSNumber numberWithInt:img.width()], + static_cast<NSString *>(kCGImagePropertyPixelHeight) : [NSNumber numberWithInt:img.height()] + }; + + CGImageDestinationAddImage(imageDestination, qt_mac_toCGImage(img), static_cast<CFDictionaryRef>(props)); + CGImageDestinationFinalize(imageDestination); + + return QList<QByteArray>() << QByteArray::fromCFData(data); +} + /*! \internal @@ -792,6 +876,7 @@ void QMacInternalPasteboardMime::initializeMimeTypes() new QMacPasteboardMimeAny; //standard types that we wrap + new QMacPasteboardMimeTiff; new QMacPasteboardMimePlainTextFallback; new QMacPasteboardMimeUnicodeText; new QMacPasteboardMimeRtfText; diff --git a/src/platformsupport/devicediscovery/qdevicediscovery_dummy_p.h b/src/platformsupport/devicediscovery/qdevicediscovery_dummy_p.h index fea3a06cbd..fe669c8dec 100644 --- a/src/platformsupport/devicediscovery/qdevicediscovery_dummy_p.h +++ b/src/platformsupport/devicediscovery/qdevicediscovery_dummy_p.h @@ -61,7 +61,7 @@ class QDeviceDiscoveryDummy : public QDeviceDiscovery public: QDeviceDiscoveryDummy(QDeviceTypes types, QObject *parent = 0); - QStringList scanConnectedDevices() Q_DECL_OVERRIDE; + QStringList scanConnectedDevices() override; }; QT_END_NAMESPACE diff --git a/src/platformsupport/devicediscovery/qdevicediscovery_static_p.h b/src/platformsupport/devicediscovery/qdevicediscovery_static_p.h index ab5a9c6f12..93110c3c55 100644 --- a/src/platformsupport/devicediscovery/qdevicediscovery_static_p.h +++ b/src/platformsupport/devicediscovery/qdevicediscovery_static_p.h @@ -61,7 +61,7 @@ class QDeviceDiscoveryStatic : public QDeviceDiscovery public: QDeviceDiscoveryStatic(QDeviceTypes types, QObject *parent = 0); - QStringList scanConnectedDevices() Q_DECL_OVERRIDE; + QStringList scanConnectedDevices() override; private: bool checkDeviceType(const QString &device); diff --git a/src/platformsupport/devicediscovery/qdevicediscovery_udev_p.h b/src/platformsupport/devicediscovery/qdevicediscovery_udev_p.h index 3c53ef3f17..28618d0b21 100644 --- a/src/platformsupport/devicediscovery/qdevicediscovery_udev_p.h +++ b/src/platformsupport/devicediscovery/qdevicediscovery_udev_p.h @@ -63,7 +63,7 @@ class QDeviceDiscoveryUDev : public QDeviceDiscovery public: QDeviceDiscoveryUDev(QDeviceTypes types, struct udev *udev, QObject *parent = 0); ~QDeviceDiscoveryUDev(); - QStringList scanConnectedDevices() Q_DECL_OVERRIDE; + QStringList scanConnectedDevices() override; private slots: void handleUDevNotification(); diff --git a/src/platformsupport/edid/edid.pro b/src/platformsupport/edid/edid.pro new file mode 100644 index 0000000000..842a91170e --- /dev/null +++ b/src/platformsupport/edid/edid.pro @@ -0,0 +1,13 @@ +TARGET = QtEdidSupport +MODULE = edid_support + +QT = core-private +CONFIG += static internal_module + +DEFINES += QT_NO_CAST_FROM_ASCII +PRECOMPILED_HEADER = ../../corelib/global/qt_pch.h + +HEADERS += qedidparser_p.h +SOURCES += qedidparser.cpp + +load(qt_module) diff --git a/src/platformsupport/edid/qedidparser.cpp b/src/platformsupport/edid/qedidparser.cpp new file mode 100644 index 0000000000..ccf12e9eb3 --- /dev/null +++ b/src/platformsupport/edid/qedidparser.cpp @@ -0,0 +1,177 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com> +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QtCore/QFile> + +#include "qedidparser_p.h" +#include "qedidvendortable_p.h" + +#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) + +#define EDID_DESCRIPTOR_ALPHANUMERIC_STRING 0xfe +#define EDID_DESCRIPTOR_PRODUCT_NAME 0xfc +#define EDID_DESCRIPTOR_SERIAL_NUMBER 0xff + +#define EDID_OFFSET_DATA_BLOCKS 0x36 +#define EDID_OFFSET_LAST_BLOCK 0x6c +#define EDID_OFFSET_PNP_ID 0x08 +#define EDID_OFFSET_SERIAL 0x0c +#define EDID_PHYSICAL_WIDTH 0x15 +#define EDID_OFFSET_PHYSICAL_HEIGHT 0x16 + +QT_BEGIN_NAMESPACE + +QEdidParser::QEdidParser() +{ + // Cache vendors list from pnp.ids + const QString fileName = QLatin1String("/usr/share/hwdata/pnp.ids"); + if (QFile::exists(fileName)) { + QFile file(fileName); + + if (file.open(QFile::ReadOnly)) { + while (!file.atEnd()) { + QString line = QString::fromUtf8(file.readLine()).trimmed(); + + if (line.startsWith(QLatin1Char('#'))) + continue; + + QStringList parts = line.split(QLatin1Char('\t')); + if (parts.count() > 1) { + QString pnpId = parts.at(0); + parts.removeFirst(); + m_vendorCache[pnpId] = parts.join(QLatin1Char(' ')); + } + } + + file.close(); + } + } +} + +bool QEdidParser::parse(const QByteArray &blob) +{ + const quint8 *data = reinterpret_cast<const quint8 *>(blob.constData()); + const size_t length = blob.length(); + + // Verify header + if (length < 128) + return false; + if (data[0] != 0x00 || data[1] != 0xff) + return false; + + /* Decode the PNP ID from three 5 bit words packed into 2 bytes + * /--08--\/--09--\ + * 7654321076543210 + * |\---/\---/\---/ + * R C1 C2 C3 */ + char id[3]; + id[0] = 'A' + ((data[EDID_OFFSET_PNP_ID] & 0x7c) / 4) - 1; + id[1] = 'A' + ((data[EDID_OFFSET_PNP_ID] & 0x3) * 8) + ((data[EDID_OFFSET_PNP_ID + 1] & 0xe0) / 32) - 1; + id[2] = 'A' + (data[EDID_OFFSET_PNP_ID + 1] & 0x1f) - 1; + identifier = QString::fromLatin1(id, 3); + + // Clear manufacturer + manufacturer = QString(); + + // Serial number, will be overwritten by an ASCII descriptor + // when and if it will be found + quint32 serial = data[EDID_OFFSET_SERIAL] + + (data[EDID_OFFSET_SERIAL + 1] << 8) + + (data[EDID_OFFSET_SERIAL + 2] << 16) + + (data[EDID_OFFSET_SERIAL + 3] << 24); + if (serial > 0) + serialNumber = QString::number(serial); + else + serialNumber = QString(); + + // Parse EDID data + for (int i = 0; i < 5; ++i) { + const uint offset = EDID_OFFSET_DATA_BLOCKS + i * 18; + + if (data[offset] != 0 || data[offset + 1] != 0 || data[offset + 2] != 0) + continue; + + if (data[offset + 3] == EDID_DESCRIPTOR_PRODUCT_NAME) + model = parseEdidString(&data[offset + 5]); + else if (data[offset + 3] == EDID_DESCRIPTOR_ALPHANUMERIC_STRING) + identifier = parseEdidString(&data[offset + 5]); + else if (data[offset + 3] == EDID_DESCRIPTOR_SERIAL_NUMBER) + serialNumber = parseEdidString(&data[offset + 5]); + } + + // Try to use cache first because it is potentially more updated + if (m_vendorCache.contains(identifier)) { + manufacturer = m_vendorCache[identifier]; + } else { + // Find the manufacturer from the vendor lookup table + for (size_t i = 0; i < ARRAY_LENGTH(q_edidVendorTable); i++) { + if (strcmp(q_edidVendorTable[i].id, identifier.toLatin1().constData()) == 0) { + manufacturer = QString::fromUtf8(q_edidVendorTable[i].name); + break; + } + } + } + + // If we don't know the manufacturer, fallback to PNP ID + if (manufacturer.isEmpty()) + manufacturer = identifier; + + // Physical size + physicalSize = QSizeF(data[EDID_PHYSICAL_WIDTH], data[EDID_OFFSET_PHYSICAL_HEIGHT]) * 10; + + return true; +} + +QString QEdidParser::parseEdidString(const quint8 *data) +{ + QByteArray buffer(reinterpret_cast<const char *>(data), 12); + + // Erase carriage return and line feed + buffer = buffer.replace('\r', '\0').replace('\n', '\0'); + + // Replace non-printable characters with dash + for (int i = 0; i < buffer.count(); ++i) { + if (buffer[i] < '\040' && buffer[i] > '\176') + buffer[i] = '-'; + } + + return QString::fromLatin1(buffer.trimmed()); +} + +QT_END_NAMESPACE diff --git a/src/platformsupport/edid/qedidparser_p.h b/src/platformsupport/edid/qedidparser_p.h new file mode 100644 index 0000000000..c436155258 --- /dev/null +++ b/src/platformsupport/edid/qedidparser_p.h @@ -0,0 +1,80 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com> +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QEDIDPARSER_P_H +#define QEDIDPARSER_P_H + +#include <QtCore/QSize> +#include <QtCore/QMap> + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +QT_BEGIN_NAMESPACE + +class QEdidParser +{ +public: + QEdidParser(); + + bool parse(const QByteArray &blob); + + QString identifier; + QString manufacturer; + QString model; + QString serialNumber; + QSizeF physicalSize; + +private: + QMap<QString, QString> m_vendorCache; + + QString parseEdidString(const quint8 *data); +}; + +QT_END_NAMESPACE + +#endif // QEDIDPARSER_P_H diff --git a/src/platformsupport/edid/qedidvendortable_p.h b/src/platformsupport/edid/qedidvendortable_p.h new file mode 100644 index 0000000000..6ec399df05 --- /dev/null +++ b/src/platformsupport/edid/qedidvendortable_p.h @@ -0,0 +1,2307 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com> +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +/* + * This lookup table was generated from https://git.fedorahosted.org/cgit/hwdata.git/plain/pnp.ids + * + * Do not change directly this file, instead edit the + * qtbase/util/edid/qedidvendortable.py script and regenerate this file. + */ + +#ifndef QEDIDVENDORTABLE_P_H +#define QEDIDVENDORTABLE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +QT_BEGIN_NAMESPACE + +typedef struct VendorTable { + const char id[4]; + const char name[78]; +} VendorTable; + +static const struct VendorTable q_edidVendorTable[] = { + { "LLL", "L-3 Communications" }, + { "GMX", "GMX Inc" }, + { "FOS", "Foss Tecator" }, + { "PHI", "DO NOT USE - PHI" }, + { "DNV", "DiCon" }, + { "KZN", "K-Zone International" }, + { "TIC", "Trigem KinfoComm" }, + { "FNC", "Fanuc LTD" }, + { "ESY", "E-Systems Inc" }, + { "TGM", "TriGem Computer,Inc." }, + { "DBN", "DB Networks Inc" }, + { "GCS", "Grey Cell Systems Ltd" }, + { "AVR", "AVer Information Inc." }, + { "OKI", "OKI Electric Industrial Company Ltd" }, + { "GDI", "G. Diehl ISDN GmbH" }, + { "SPC", "SpinCore Technologies, Inc" }, + { "ICV", "Inside Contactless" }, + { "UNY", "Unicate" }, + { "NMP", "Nokia Mobile Phones" }, + { "HMC", "Hualon Microelectric Corporation" }, + { "OPT", "OPTi Inc" }, + { "TSG", "The Software Group Ltd" }, + { "IMN", "Impossible Production" }, + { "DHQ", "Quadram" }, + { "UFG", "UNIGRAF-USA" }, + { "CLA", "Clarion Company Ltd" }, + { "IOM", "Iomega" }, + { "MTS", "Multi-Tech Systems" }, + { "TXN", "Texas Insturments" }, + { "SDH", "Communications Specialies, Inc." }, + { "DCC", "Dale Computer Corporation" }, + { "PAK", "Many CNC System Co., Ltd." }, + { "TDC", "Teradici" }, + { "XAC", "XAC Automation Corp" }, + { "DRI", "Data Race Inc" }, + { "HAN", "Hanchang System Corporation" }, + { "NTR", "N-trig Innovative Technologies, Inc." }, + { "PDR", "Pure Data Inc" }, + { "BNS", "Boulder Nonlinear Systems" }, + { "EGO", "Ergo Electronics" }, + { "ETS", "Electronic Trade Solutions Ltd" }, + { "CNN", "Canon Inc" }, + { "CSB", "Transtex SA" }, + { "NAK", "Nakano Engineering Co.,Ltd." }, + { "IME", "Imagraph" }, + { "CYT", "Cytechinfo Inc" }, + { "ADM", "Ad Lib MultiMedia Inc" }, + { "IBC", "Integrated Business Systems" }, + { "TMT", "T-Metrics Inc." }, + { "ALP", "Alps Electric Company Ltd" }, + { "TWX", "TEKWorx Limited" }, + { "CDP", "CalComp" }, + { "KSX", "King Tester Corporation" }, + { "AMI", "American Megatrends Inc" }, + { "KBI", "Kidboard Inc" }, + { "COO", "coolux GmbH" }, + { "CBR", "Cebra Tech A/S" }, + { "ANA", "Anakron" }, + { "ACT", "Applied Creative Technology" }, + { "PGS", "Princeton Graphic Systems" }, + { "DCL", "Dynamic Controls Ltd" }, + { "TCH", "Interaction Systems, Inc" }, + { "STP", "StreamPlay Ltd" }, + { "PCG", "First Industrial Computer Inc" }, + { "SSE", "Samsung Electronic Co." }, + { "TXT", "Textron Defense System" }, + { "XRO", "XORO ELECTRONICS (CHENGDU) LIMITED" }, + { "MTU", "Mark of the Unicorn Inc" }, + { "ERG", "Ergo System" }, + { "GFN", "Gefen Inc." }, + { "UNE", "Unisys Corporation" }, + { "DDD", "Danka Data Devices" }, + { "ZGT", "Zenith Data Systems" }, + { "NAL", "Network Alchemy" }, + { "FVX", "C-C-C Group Plc" }, + { "AJA", "AJA Video Systems, Inc." }, + { "AZT", "Aztech Systems Ltd" }, + { "CIS", "Cisco Systems Inc" }, + { "DUA", "Dosch & Amand GmbH & Company KG" }, + { "INP", "Interphase Corporation" }, + { "DMS", "DOME imaging systems" }, + { "COW", "Polycow Productions" }, + { "PTC", "PS Technology Corporation" }, + { "PRD", "Praim S.R.L." }, + { "DEC", "Digital Equipment Corporation" }, + { "SMT", "Silcom Manufacturing Tech Inc" }, + { "MII", "Mitec Inc" }, + { "QLC", "Q-Logic" }, + { "PRG", "The Phoenix Research Group Inc" }, + { "LNV", "Lenovo" }, + { "IND", "ILC" }, + { "MXL", "Hitachi Maxell, Ltd." }, + { "DAU", "Daou Tech Inc" }, + { "SNK", "S&K Electronics" }, + { "SYE", "SY Electronics Ltd" }, + { "BCC", "Beaver Computer Corporaton" }, + { "LPI", "Design Technology" }, + { "CLO", "Clone Computers" }, + { "CMI", "C-Media Electronics" }, + { "ESK", "ES&S" }, + { "HCW", "Hauppauge Computer Works Inc" }, + { "KPC", "King Phoenix Company" }, + { "DXS", "Signet" }, + { "OLY", "OLYMPUS CORPORATION" }, + { "OOS", "OSRAM" }, + { "NOE", "NordicEye AB" }, + { "DXP", "Data Expert Corporation" }, + { "ITP", "IT-PRO Consulting und Systemhaus GmbH" }, + { "MMS", "MMS Electronics" }, + { "FDC", "Future Domain" }, + { "ASM", "ASEM S.p.A." }, + { "AIC", "Arnos Insturments & Computer Systems" }, + { "ANC", "Ancot" }, + { "SEE", "SeeColor Corporation" }, + { "JAS", "Janz Automationssysteme AG" }, + { "TGV", "Grass Valley Germany GmbH" }, + { "LTI", "Jongshine Tech Inc" }, + { "JVC", "JVC" }, + { "TLV", "S3 Inc" }, + { "MGC", "Mentor Graphics Corporation" }, + { "NBS", "National Key Lab. on ISN" }, + { "GTI", "Goldtouch" }, + { "SPI", "SPACE-I Co., Ltd." }, + { "ZNX", "Znyx Adv. Systems" }, + { "EMC", "eMicro Corporation" }, + { "WDE", "Westinghouse Digital Electronics" }, + { "CEN", "Centurion Technologies P/L" }, + { "BFE", "B.F. Engineering Corporation" }, + { "DTL", "e-Net Inc" }, + { "FTL", "FUJITSU TEN LIMITED" }, + { "HSC", "Hagiwara Sys-Com Company Ltd" }, + { "ECP", "Elecom Company Ltd" }, + { "LJX", "Datalogic Corporation" }, + { "DRC", "Data Ray Corp." }, + { "STM", "SGS Thomson Microelectronics" }, + { "GDT", "Vortex Computersysteme GmbH" }, + { "JSK", "SANKEN ELECTRIC CO., LTD" }, + { "TMC", "Techmedia Computer Systems Corporation" }, + { "CFG", "Atlantis" }, + { "DCO", "Dialogue Technology Corporation" }, + { "NEC", "NEC Corporation" }, + { "SAE", "Saab Aerotech" }, + { "STA", "ST Electronics Systems Assembly Pte Ltd" }, + { "GEO", "GEO Sense" }, + { "SLH", "Silicon Library Inc." }, + { "SAG", "Sedlbauer" }, + { "VEK", "Vektrex" }, + { "ADA", "Addi-Data GmbH" }, + { "NCT", "NEC CustomTechnica, Ltd." }, + { "STX", "ST-Ericsson" }, + { "PRM", "Prometheus" }, + { "DPA", "DigiTalk Pro AV" }, + { "SLF", "StarLeaf" }, + { "AXY", "AXYZ Automation Services, Inc" }, + { "CPX", "Powermatic Data Systems" }, + { "DLL", "Dell Inc" }, + { "PLF", "Panasonic Avionics Corporation" }, + { "FRI", "Fibernet Research Inc" }, + { "BRM", "Braemar Inc" }, + { "MSK", "Megasoft Inc" }, + { "ECT", "Enciris Technologies" }, + { "TKO", "TouchKo, Inc." }, + { "CYC", "Cylink Corporation" }, + { "SMR", "B.& V. s.r.l." }, + { "SRT", "SeeReal Technologies GmbH" }, + { "GES", "GES Singapore Pte Ltd" }, + { "DHT", "Projectavision Inc" }, + { "ESC", "Eden Sistemas de Computacao S/A" }, + { "BYD", "byd:sign corporation" }, + { "BMI", "Benson Medical Instruments Company" }, + { "XSY", "XSYS" }, + { "MYX", "Micronyx Inc" }, + { "OUK", "OUK Company Ltd" }, + { "MPI", "Mediatrix Peripherals Inc" }, + { "BUS", "BusTek" }, + { "LCN", "LEXICON" }, + { "ADS", "Analog Devices Inc" }, + { "XTL", "Crystal Computer" }, + { "CEF", "Cefar Digital Vision" }, + { "IPP", "IP Power Technologies GmbH" }, + { "CDV", "Convergent Design Inc." }, + { "OLD", "Olidata S.p.A." }, + { "GNN", "GN Nettest Inc" }, + { "ADH", "Aerodata Holdings Ltd" }, + { "IMM", "Immersion Corporation" }, + { "CBT", "Cabletime Ltd" }, + { "RVI", "Realvision Inc" }, + { "HNS", "Hughes Network Systems" }, + { "HAR", "Harris Corporation" }, + { "ACV", "ActivCard S.A" }, + { "RUN", "RUNCO International" }, + { "WDC", "Western Digital" }, + { "SIG", "Sigma Designs Inc" }, + { "PNR", "Planar Systems, Inc." }, + { "PRS", "Leutron Vision" }, + { "KEM", "Kontron Embedded Modules GmbH" }, + { "LAN", "Sodeman Lancom Inc" }, + { "CEM", "MEC Electronics GmbH" }, + { "RHD", "RightHand Technologies" }, + { "CHE", "Acer Inc" }, + { "POL", "PolyComp (PTY) Ltd." }, + { "MST", "MS Telematica" }, + { "ALA", "Alacron Inc" }, + { "EDI", "Edimax Tech. Company Ltd" }, + { "EGN", "Egenera, Inc." }, + { "PIX", "Pixie Tech Inc" }, + { "AVN", "Advance Computer Corporation" }, + { "CTN", "Computone Products" }, + { "SFM", "TORNADO Company" }, + { "ATA", "Allied Telesyn International (Asia) Pte Ltd" }, + { "SIA", "SIEMENS AG" }, + { "NAV", "Navigation Corporation" }, + { "PRF", "Digital Electronics Corporation" }, + { "HRE", "Qingdao Haier Electronics Co., Ltd." }, + { "NAC", "Ncast Corporation" }, + { "ELM", "Elmic Systems Inc" }, + { "HYR", "Hypertec Pty Ltd" }, + { "EMB", "Embedded computing inc ltd" }, + { "MWR", "mware" }, + { "KGL", "KEISOKU GIKEN Co.,Ltd." }, + { "NRL", "U.S. Naval Research Lab" }, + { "TNM", "TECNIMAGEN SA" }, + { "GTT", "General Touch Technology Co., Ltd." }, + { "BTE", "Brilliant Technology" }, + { "KDS", "KDS USA" }, + { "EEP", "E.E.P.D. GmbH" }, + { "NCI", "NewCom Inc" }, + { "CIP", "Ciprico Inc" }, + { "RTL", "Realtek Semiconductor Company Ltd" }, + { "MUK", "mainpine limited" }, + { "SLX", "Specialix" }, + { "HCM", "HCL Peripherals" }, + { "CHA", "Chase Research PLC" }, + { "VOB", "MaxData Computer AG" }, + { "ANK", "Anko Electronic Company Ltd" }, + { "FWR", "Flat Connections Inc" }, + { "DXL", "Dextera Labs Inc" }, + { "QVU", "Quartics" }, + { "MPS", "mps Software GmbH" }, + { "AVM", "AVM GmbH" }, + { "TDY", "Tandy Electronics" }, + { "MJS", "MJS Designs" }, + { "SNC", "Sentronic International Corp." }, + { "IPT", "International Power Technologies" }, + { "API", "A Plus Info Corporation" }, + { "TLT", "Dai Telecom S.p.A." }, + { "PCC", "PowerCom Technology Company Ltd" }, + { "TRM", "Tekram Technology Company Ltd" }, + { "DEL", "Dell Inc." }, + { "CYW", "Cyberware" }, + { "TDS", "Tri-Data Systems Inc" }, + { "FPE", "Fujitsu Peripherals Ltd" }, + { "SPN", "Sapience Corporation" }, + { "COX", "Comrex" }, + { "STE", "SII Ido-Tsushin Inc" }, + { "RVC", "RSI Systems Inc" }, + { "HMK", "hmk Daten-System-Technik BmbH" }, + { "TTA", "Topson Technology Co., Ltd." }, + { "CSM", "Cosmic Engineering Inc." }, + { "PTL", "Pantel Inc" }, + { "EQX", "Equinox Systems Inc" }, + { "HEL", "Hitachi Micro Systems Europe Ltd" }, + { "TIX", "Tixi.Com GmbH" }, + { "CMD", "Colorado MicroDisplay, Inc." }, + { "VIS", "Visioneer" }, + { "MTH", "Micro-Tech Hearing Instruments" }, + { "ISR", "INSIS Co., LTD." }, + { "EME", "EMiNE TECHNOLOGY COMPANY, LTD." }, + { "DMT", "Distributed Management Task Force, Inc. (DMTF)" }, + { "JFX", "Jones Futurex Inc" }, + { "SMB", "Schlumberger" }, + { "GTM", "Garnet System Company Ltd" }, + { "DBK", "Databook Inc" }, + { "IQT", "IMAGEQUEST Co., Ltd" }, + { "DTX", "Data Translation" }, + { "QSI", "Quantum Solutions, Inc." }, + { "BEL", "Beltronic Industrieelektronik GmbH" }, + { "PJT", "Pan Jit International Inc." }, + { "WST", "Wistron Corporation" }, + { "ASN", "Asante Tech Inc" }, + { "ROS", "Rohde & Schwarz" }, + { "NWP", "NovaWeb Technologies Inc" }, + { "CLG", "CoreLogic" }, + { "ECS", "Elitegroup Computer Systems Company Ltd" }, + { "PER", "Perceptive Signal Technologies" }, + { "SPR", "pmns GmbH" }, + { "DLB", "Dolby Laboratories Inc." }, + { "SRF", "Surf Communication Solutions Ltd" }, + { "ATM", "ATM Ltd" }, + { "MED", "Messeltronik Dresden GmbH" }, + { "SGD", "Sigma Designs, Inc." }, + { "RJA", "Roland Corporation" }, + { "EDC", "e.Digital Corporation" }, + { "CON", "Contec Company Ltd" }, + { "CCJ", "CONTEC CO.,LTD." }, + { "GVC", "GVC Corporation" }, + { "TRI", "Tricord Systems" }, + { "SLB", "Shlumberger Ltd" }, + { "PRO", "Proteon" }, + { "DSI", "Digitan Systems Inc" }, + { "SDF", "SODIFF E&T CO., Ltd." }, + { "VDC", "VDC Display Systems" }, + { "PSL", "Perle Systems Limited" }, + { "SCR", "Systran Corporation" }, + { "DEX", "idex displays" }, + { "CDS", "Computer Diagnostic Systems" }, + { "RAY", "Raylar Design, Inc." }, + { "MMF", "Minnesota Mining and Manufacturing" }, + { "MMA", "Micromedia AG" }, + { "FUS", "Fujitsu Siemens Computers GmbH" }, + { "ESS", "ESS Technology Inc" }, + { "SIX", "Zuniq Data Corporation" }, + { "ISS", "ISS Inc" }, + { "PFT", "Telia ProSoft AB" }, + { "SOL", "Solitron Technologies Inc" }, + { "ZTM", "ZT Group Int'l Inc." }, + { "GZE", "GUNZE Limited" }, + { "CHS", "Agentur Chairos" }, + { "CBI", "ComputerBoards Inc" }, + { "DTA", "DELTATEC" }, + { "CSC", "Crystal Semiconductor" }, + { "MPC", "M-Pact Inc" }, + { "HHI", "Fraunhofer Heinrich-Hertz-Institute" }, + { "BIT", "Bit 3 Computer" }, + { "ICP", "ICP Electronics, Inc./iEi Technology Corp." }, + { "FOA", "FOR-A Company Limited" }, + { "NWC", "NW Computer Engineering" }, + { "MRO", "Medikro Oy" }, + { "IDT", "International Display Technology" }, + { "NMV", "NEC-Mitsubishi Electric Visual Systems Corporation" }, + { "COT", "Core Technology Inc" }, + { "PEL", "Primax Electric Ltd" }, + { "ZMZ", "Z Microsystems" }, + { "TYN", "Tyan Computer Corporation" }, + { "DIN", "Daintelecom Co., Ltd" }, + { "QTH", "Questech Ltd" }, + { "CYL", "Cyberlabs" }, + { "DGC", "Data General Corporation" }, + { "PPM", "Clinton Electronics Corp." }, + { "ITD", "Internet Technology Corporation" }, + { "MMM", "Electronic Measurements" }, + { "CMM", "Comtime GmbH" }, + { "NDC", "National DataComm Corporaiton" }, + { "TAS", "Taskit Rechnertechnik GmbH" }, + { "MFR", "MediaFire Corp." }, + { "HIC", "Hitachi Information Technology Co., Ltd." }, + { "CMC", "CMC Ltd" }, + { "TSE", "Tottori Sanyo Electric" }, + { "TMR", "Taicom International Inc" }, + { "SIE", "Siemens" }, + { "IMD", "ImasDe Canarias S.A." }, + { "SCE", "Sun Corporation" }, + { "PJD", "Projectiondesign AS" }, + { "VML", "Vine Micros Limited" }, + { "ETL", "Evertz Microsystems Ltd." }, + { "MAZ", "MAZeT GmbH" }, + { "UNC", "Unisys Corporation" }, + { "MEG", "Abeam Tech Ltd" }, + { "FCS", "Focus Enhancements, Inc." }, + { "MDV", "MET Development Inc" }, + { "GLD", "Goldmund - Digital Audio SA" }, + { "MRC", "Marconi Simulation & Ty-Coch Way Training" }, + { "FEC", "FURUNO ELECTRIC CO., LTD." }, + { "ALR", "Advanced Logic" }, + { "AEJ", "Alpha Electronics Company" }, + { "QCC", "QuakeCom Company Ltd" }, + { "TDK", "TDK USA Corporation" }, + { "TKN", "Teknor Microsystem Inc" }, + { "FMC", "Ford Microelectronics Inc" }, + { "KTI", "Konica Technical Inc" }, + { "AEI", "Actiontec Electric Inc" }, + { "TGI", "TriGem Computer Inc" }, + { "HIL", "Hilevel Technology" }, + { "WNI", "WillNet Inc." }, + { "FTI", "FastPoint Technologies, Inc." }, + { "ASU", "Asuscom Network Inc" }, + { "MEJ", "Mac-Eight Co., LTD." }, + { "SLS", "Schnick-Schnack-Systems GmbH" }, + { "SXG", "SELEX GALILEO" }, + { "EXP", "Data Export Corporation" }, + { "TPR", "Topro Technology Inc" }, + { "RCE", "Parc d'Activite des Bellevues" }, + { "VIK", "Viking Connectors" }, + { "TGS", "Torus Systems Ltd" }, + { "IDO", "IDEO Product Development" }, + { "MCE", "Metz-Werke GmbH & Co KG" }, + { "PHC", "Pijnenburg Beheer N.V." }, + { "BTF", "Bitfield Oy" }, + { "MCD", "McDATA Corporation" }, + { "EXY", "Exterity Ltd" }, + { "ZTI", "Zoom Telephonics Inc" }, + { "MTI", "Motorola Inc." }, + { "ONK", "ONKYO Corporation" }, + { "SEC", "Seiko Epson Corporation" }, + { "TTB", "National Semiconductor Japan Ltd" }, + { "SNO", "SINOSUN TECHNOLOGY CO., LTD" }, + { "SHG", "Soft & Hardware development Goldammer GmbH" }, + { "GEM", "Gem Plus" }, + { "BOS", "BOS" }, + { "SAK", "Saitek Ltd" }, + { "CNE", "Cine-tal" }, + { "BOB", "Rainy Orchard" }, + { "UNF", "Unisys Corporation" }, + { "MCG", "Motorola Computer Group" }, + { "RTC", "Relia Technologies" }, + { "ASD", "USC Information Sciences Institute" }, + { "BMS", "BIOMEDISYS" }, + { "LPE", "El-PUSK Co., Ltd." }, + { "CTA", "CoSystems Inc" }, + { "SVI", "Sun Microsystems" }, + { "PCS", "TOSHIBA PERSONAL COMPUTER SYSTEM CORPRATION" }, + { "GEN", "Genesys ATE Inc" }, + { "CRI", "Crio Inc." }, + { "TOG", "The OPEN Group" }, + { "SYT", "Seyeon Tech Company Ltd" }, + { "CRE", "Creative Labs Inc" }, + { "ALK", "Acrolink Inc" }, + { "TNC", "TNC Industrial Company Ltd" }, + { "PLV", "PLUS Vision Corp." }, + { "CCL", "CCL/ITRI" }, + { "PLY", "Polycom Inc." }, + { "RMC", "Raritan Computer, Inc" }, + { "XRC", "Xircom Inc" }, + { "BRC", "BARC" }, + { "CUK", "Calibre UK Ltd" }, + { "KME", "KIMIN Electronics Co., Ltd." }, + { "TBS", "Turtle Beach System" }, + { "ASY", "Rockwell Collins / Airshow Systems" }, + { "ALV", "AlphaView LCD" }, + { "VSD", "3M" }, + { "MTN", "Mtron Storage Technology Co., Ltd." }, + { "LMG", "Lucent Technologies" }, + { "HWP", "Hewlett Packard" }, + { "UEG", "Elitegroup Computer Systems Company Ltd" }, + { "FIC", "Formosa Industrial Computing Inc" }, + { "CRV", "Cerevo Inc." }, + { "AIL", "Altos India Ltd" }, + { "EMI", "Ex Machina Inc" }, + { "DPC", "Delta Electronics Inc" }, + { "ADN", "Analog & Digital Devices Tel. Inc" }, + { "LGC", "Logic Ltd" }, + { "DMP", "D&M Holdings Inc, Professional Business Company" }, + { "CEC", "Chicony Electronics Company Ltd" }, + { "BTC", "Bit 3 Computer" }, + { "IWX", "Intelliworxx, Inc." }, + { "SML", "Sumitomo Metal Industries, Ltd." }, + { "JWY", "Jetway Information Co., Ltd" }, + { "OMC", "OBJIX Multimedia Corporation" }, + { "CIT", "Citifax Limited" }, + { "AOE", "Advanced Optics Electronics, Inc." }, + { "SYC", "Sysmic" }, + { "ZTT", "Z3 Technology" }, + { "LCS", "Longshine Electronics Company" }, + { "NXQ", "Nexiq Technologies, Inc." }, + { "PSY", "Prodea Systems Inc." }, + { "CUB", "Cubix Corporation" }, + { "JWL", "Jewell Instruments, LLC" }, + { "SUB", "Subspace Comm. Inc" }, + { "PTG", "Cipher Systems Inc" }, + { "TON", "TONNA" }, + { "VBR", "VBrick Systems Inc." }, + { "RTI", "Rancho Tech Inc" }, + { "IMG", "IMAGENICS Co., Ltd." }, + { "AEP", "Aetas Peripheral International" }, + { "PTH", "Pathlight Technology Inc" }, + { "ZYX", "Zyxel" }, + { "NXP", "NXP Semiconductors bv." }, + { "OYO", "Shadow Systems" }, + { "PVM", "Penta Studiotechnik GmbH" }, + { "AVC", "Auravision Corporation" }, + { "SYM", "Symicron Computer Communications Ltd." }, + { "AVI", "Nippon Avionics Co.,Ltd" }, + { "EYE", "eyevis GmbH" }, + { "PLM", "PROLINK Microsystems Corp." }, + { "NFC", "BTC Korea Co., Ltd" }, + { "PIE", "Pacific Image Electronics Company Ltd" }, + { "SRC", "Integrated Tech Express Inc" }, + { "CMX", "Comex Electronics AB" }, + { "OPP", "OPPO Digital, Inc." }, + { "GAL", "Galil Motion Control" }, + { "YHW", "Exacom SA" }, + { "SSD", "FlightSafety International" }, + { "FSC", "Future Systems Consulting KK" }, + { "HRI", "Hall Research" }, + { "PSA", "Advanced Signal Processing Technologies" }, + { "MSI", "Microstep" }, + { "IMI", "International Microsystems Inc" }, + { "IDX", "IDEXX Labs" }, + { "SCO", "SORCUS Computer GmbH" }, + { "DIS", "Diseda S.A." }, + { "SVA", "SGEG" }, + { "SMA", "SMART Modular Technologies" }, + { "SXL", "SolutionInside" }, + { "WRC", "WiNRADiO Communications" }, + { "NIT", "Network Info Technology" }, + { "EKS", "EKSEN YAZILIM" }, + { "GEF", "GE Fanuc Embedded Systems" }, + { "DEI", "Deico Electronics" }, + { "DCD", "Datacast LLC" }, + { "MEE", "Mitsubishi Electric Engineering Co., Ltd." }, + { "LSC", "LifeSize Communications" }, + { "PDV", "Prodrive B.V." }, + { "HIB", "Hibino Corporation" }, + { "SKT", "Samsung Electro-Mechanics Company Ltd" }, + { "SAN", "Sanyo Electric Co.,Ltd." }, + { "RCO", "Rockwell Collins" }, + { "SNY", "Sony" }, + { "ANR", "ANR Ltd" }, + { "DKY", "Datakey Inc" }, + { "OPC", "Opcode Inc" }, + { "TBC", "Turbo Communication, Inc" }, + { "CNT", "COINT Multimedia Systems" }, + { "HDC", "HardCom Elektronik & Datateknik" }, + { "UNB", "Unisys Corporation" }, + { "IOD", "I-O Data Device Inc" }, + { "APR", "Aprilia s.p.a." }, + { "AXX", "Axxon Computer Corporation" }, + { "AED", "Advanced Electronic Designs, Inc." }, + { "MTX", "Matrox" }, + { "TAX", "Taxan (Europe) Ltd" }, + { "TVS", "TVS Electronics Limited" }, + { "CZE", "Carl Zeiss AG" }, + { "SMI", "SpaceLabs Medical Inc" }, + { "FCB", "Furukawa Electric Company Ltd" }, + { "AXP", "American Express" }, + { "FST", "Modesto PC Inc" }, + { "PSI", "PSI-Perceptive Solutions Inc" }, + { "MCR", "Marina Communicaitons" }, + { "JCE", "Jace Tech Inc" }, + { "GRE", "GOLD RAIN ENTERPRISES CORP." }, + { "SYN", "Synaptics Inc" }, + { "MBC", "MBC" }, + { "SIB", "Sanyo Electric Company Ltd" }, + { "TCT", "Telecom Technology Centre Co. Ltd." }, + { "BIC", "Big Island Communications" }, + { "UNI", "Unisys Corporation" }, + { "ELX", "Elonex PLC" }, + { "ZDS", "Zenith Data Systems" }, + { "XLX", "Xilinx, Inc." }, + { "MIC", "Micom Communications Inc" }, + { "SEB", "system elektronik GmbH" }, + { "WIN", "Wintop Technology Inc" }, + { "CDG", "Christie Digital Systems Inc" }, + { "HUB", "GAI-Tronics, A Hubbell Company" }, + { "CSE", "Concept Solutions & Engineering" }, + { "SUR", "Surenam Computer Corporation" }, + { "VTM", "Miltope Corporation" }, + { "ATK", "Allied Telesyn Int'l" }, + { "MGT", "Megatech R & D Company" }, + { "SLK", "Silitek Corporation" }, + { "DYN", "Askey Computer Corporation" }, + { "KEY", "Key Tech Inc" }, + { "DVD", "Dictaphone Corporation" }, + { "OTT", "OPTO22, Inc." }, + { "TCI", "Tulip Computers Int'l B.V." }, + { "ACB", "Aculab Ltd" }, + { "PAD", "Promotion and Display Technology Ltd." }, + { "CMG", "Chenming Mold Ind. Corp." }, + { "UJR", "Ueda Japan Radio Co., Ltd." }, + { "LHA", "Lars Haagh ApS" }, + { "SIM", "S3 Inc" }, + { "TPC", "Touch Panel Systems Corporation" }, + { "TVD", "Tecnovision" }, + { "FZI", "FZI Forschungszentrum Informatik" }, + { "AIW", "Aiwa Company Ltd" }, + { "LTW", "Lightware, Inc" }, + { "DSP", "Domain Technology Inc" }, + { "ILS", "Innotech Corporation" }, + { "VDM", "Vadem" }, + { "KYK", "Samsung Electronics America Inc" }, + { "NTW", "Networth Inc" }, + { "SID", "Seiko Instruments Information Devices Inc" }, + { "MRT", "Merging Technologies" }, + { "MGL", "M-G Technology Ltd" }, + { "UBL", "Ubinetics Ltd." }, + { "PSM", "Prosum" }, + { "MDR", "Medar Inc" }, + { "STN", "Samsung Electronics America" }, + { "NCR", "NCR Electronics" }, + { "INU", "Inovatec S.p.A." }, + { "WAL", "Wave Access" }, + { "BLN", "BioLink Technologies" }, + { "RXT", "Tectona SoftSolutions (P) Ltd.," }, + { "MRL", "Miratel" }, + { "ZAZ", "Zazzle Technologies" }, + { "NIC", "National Instruments Corporation" }, + { "FMZ", "Formoza-Altair" }, + { "MDG", "Madge Networks" }, + { "VIA", "VIA Tech Inc" }, + { "KOD", "Eastman Kodak Company" }, + { "SAI", "Sage Inc" }, + { "FEL", "Fellowes & Questec" }, + { "SLI", "Symbios Logic Inc" }, + { "ELE", "Elecom Company Ltd" }, + { "FRE", "Forvus Research Inc" }, + { "TTL", "2-Tel B.V." }, + { "PPX", "Perceptive Pixel Inc." }, + { "NAT", "NaturalPoint Inc." }, + { "SLC", "Syslogic Datentechnik AG" }, + { "PAM", "Peter Antesberger Messtechnik" }, + { "JPW", "Wallis Hamilton Industries" }, + { "AVA", "Avaya Communication" }, + { "EEH", "EEH Datalink GmbH" }, + { "WMT", "Winmate Communication Inc" }, + { "LWC", "Labway Corporation" }, + { "HYO", "HYC CO., LTD." }, + { "MCC", "Micro Industries" }, + { "IOA", "CRE Technology Corporation" }, + { "AGI", "Artish Graphics Inc" }, + { "TDT", "TDT" }, + { "UNO", "Unisys Corporation" }, + { "LIN", "Lenovo Beijing Co. Ltd." }, + { "MAG", "MAG InnoVision" }, + { "HCL", "HCL America Inc" }, + { "BWK", "Bitworks Inc." }, + { "BSN", "BRIGHTSIGN, LLC" }, + { "INM", "InnoMedia Inc" }, + { "MIN", "Minicom Digital Signage" }, + { "ARE", "ICET S.p.A." }, + { "TPZ", "Ypoaz Systems Inc" }, + { "BRO", "BROTHER INDUSTRIES,LTD." }, + { "MEX", "MSC Vertriebs GmbH" }, + { "FJC", "Fujitsu Takamisawa Component Limited" }, + { "HRT", "HERCULES" }, + { "MOM", "Momentum Data Systems" }, + { "RSV", "Ross Video Ltd" }, + { "RAN", "Rancho Tech Inc" }, + { "HOL", "Holoeye Photonics AG" }, + { "SOT", "Sotec Company Ltd" }, + { "AAE", "Anatek Electronics Inc." }, + { "ZYT", "Zytex Computers" }, + { "APP", "Apple Computer Inc" }, + { "MCM", "Metricom Inc" }, + { "NXC", "NextCom K.K." }, + { "CBX", "Cybex Computer Products Corporation" }, + { "FJS", "Fujitsu Spain" }, + { "SNI", "Siemens Microdesign GmbH" }, + { "MPL", "Maple Research Inst. Company Ltd" }, + { "PLX", "Parallax Graphics" }, + { "EAS", "Evans and Sutherland Computer" }, + { "ZBR", "Zebra Technologies International, LLC" }, + { "MSL", "MicroSlate Inc." }, + { "XOC", "DO NOT USE - XOC" }, + { "EMG", "EMG Consultants Inc" }, + { "SMC", "Standard Microsystems Corporation" }, + { "RAD", "Radisys Corporation" }, + { "NMS", "Natural Micro System" }, + { "APT", "Audio Processing Technology Ltd" }, + { "MLI", "McIntosh Laboratory Inc." }, + { "ISI", "Interface Solutions" }, + { "RAT", "Rent-A-Tech" }, + { "BAN", "Banyan" }, + { "PCL", "pentel.co.,ltd" }, + { "CSI", "Cabletron System Inc" }, + { "IVS", "Intevac Photonics Inc." }, + { "MAT", "Matsushita Electric Ind. Company Ltd" }, + { "LWR", "Lightware Visual Engineering" }, + { "FWA", "Attero Tech, LLC" }, + { "ORI", "OSR Open Systems Resources, Inc." }, + { "ARG", "Argus Electronics Co., LTD" }, + { "CAS", "CASIO COMPUTER CO.,LTD" }, + { "DHP", "DH Print" }, + { "TTS", "TechnoTrend Systemtechnik GmbH" }, + { "HHC", "HIRAKAWA HEWTECH CORP." }, + { "GRM", "Garmin International" }, + { "BUL", "Bull" }, + { "AFA", "Alfa Inc" }, + { "OVR", "Oculus VR, Inc." }, + { "EPI", "Envision Peripherals, Inc" }, + { "GSC", "General Standards Corporation" }, + { "DNG", "Apache Micro Peripherals Inc" }, + { "VIN", "Vine Micros Ltd" }, + { "PTW", "DO NOT USE - PTW" }, + { "MFI", "Micro Firmware" }, + { "SMP", "Simple Computing" }, + { "HCA", "DAT" }, + { "PHL", "Philips Consumer Electronics Company" }, + { "ADC", "Acnhor Datacomm" }, + { "VBT", "Valley Board Ltda" }, + { "MPX", "Micropix Technologies, Ltd." }, + { "VSP", "Vision Systems GmbH" }, + { "PJA", "Projecta" }, + { "AMT", "AMT International Industry" }, + { "VCI", "VistaCom Inc" }, + { "XIR", "Xirocm Inc" }, + { "MBV", "Moreton Bay" }, + { "NSC", "National Semiconductor Corporation" }, + { "TPV", "Top Victory Electronics ( Fujian ) Company Ltd" }, + { "HAE", "Haider electronics" }, + { "PKA", "Acco UK ltd." }, + { "PXC", "Phoenix Contact" }, + { "BXE", "Buxco Electronics" }, + { "OZC", "OZ Corporation" }, + { "TXL", "Trixel Ltd" }, + { "MXD", "MaxData Computer GmbH & Co.KG" }, + { "ASK", "Ask A/S" }, + { "KSC", "Kinetic Systems Corporation" }, + { "XAD", "Alpha Data" }, + { "MVI", "Media Vision Inc" }, + { "BPU", "Best Power" }, + { "LAF", "Microline" }, + { "SPS", "Synopsys Inc" }, + { "WXT", "Woxter Technology Co. Ltd" }, + { "NIX", "Seanix Technology Inc" }, + { "HPA", "Zytor Communications" }, + { "SPK", "SpeakerCraft" }, + { "CHP", "CH Products" }, + { "SNX", "Sonix Comm. Ltd" }, + { "LZX", "Lightwell Company Ltd" }, + { "ART", "Corion Industrial Corporation" }, + { "IFS", "In Focus Systems Inc" }, + { "DAL", "Digital Audio Labs Inc" }, + { "STR", "Starlight Networks Inc" }, + { "PRT", "Parade Technologies, Ltd." }, + { "VRC", "Virtual Resources Corporation" }, + { "IIC", "ISIC Innoscan Industrial Computers A/S" }, + { "AUR", "Aureal Semiconductor" }, + { "ATC", "Ably-Tech Corporation" }, + { "ODR", "Odrac" }, + { "LIP", "Linked IP GmbH" }, + { "FLI", "Faroudja Laboratories" }, + { "AVV", "SBS Technologies (Canada), Inc. (was Avvida Systems, Inc.)" }, + { "ECM", "E-Cmos Tech Corporation" }, + { "LAG", "Laguna Systems" }, + { "FFC", "FUJIFILM Corporation" }, + { "MAX", "Rogen Tech Distribution Inc" }, + { "HUM", "IMP Electronics Ltd." }, + { "VTX", "Vestax Corporation" }, + { "NST", "Network Security Technology Co" }, + { "FLY", "Butterfly Communications" }, + { "ETT", "E-Tech Inc" }, + { "NXS", "Technology Nexus Secure Open Systems AB" }, + { "VES", "Vestel Elektronik Sanayi ve Ticaret A. S." }, + { "EBT", "HUALONG TECHNOLOGY CO., LTD" }, + { "HPK", "HAMAMATSU PHOTONICS K.K." }, + { "RGB", "RGB Spectrum" }, + { "AUI", "Alps Electric Inc" }, + { "ICI", "Infotek Communication Inc" }, + { "NTS", "Nits Technology Inc." }, + { "EVI", "eviateg GmbH" }, + { "CRD", "Cardinal Technical Inc" }, + { "MOD", "Modular Technology" }, + { "CCP", "Capetronic USA Inc" }, + { "DGS", "Diagsoft Inc" }, + { "IFT", "Informtech" }, + { "LWW", "Lanier Worldwide" }, + { "SDK", "SAIT-Devlonics" }, + { "UWC", "Uniwill Computer Corp." }, + { "MXV", "MaxVision Corporation" }, + { "HOE", "Hosiden Corporation" }, + { "SGE", "Kansai Electric Company Ltd" }, + { "URD", "Video Computer S.p.A." }, + { "TSV", "TRANSVIDEO" }, + { "MBM", "Marshall Electronics" }, + { "TLA", "Ferrari Electronic GmbH" }, + { "GLM", "Genesys Logic" }, + { "LEN", "Lenovo Group Limited" }, + { "SAM", "Samsung Electric Company" }, + { "VTL", "Vivid Technology Pte Ltd" }, + { "UTD", "Up to Date Tech" }, + { "ITC", "Intercom Inc" }, + { "ENI", "Efficient Networks" }, + { "GDC", "General Datacom" }, + { "XIT", "Xitel Pty ltd" }, + { "CMN", "Chimei Innolux Corporation" }, + { "AVE", "Add Value Enterpises (Asia) Pte Ltd" }, + { "WEC", "Winbond Electronics Corporation" }, + { "OAK", "Oak Tech Inc" }, + { "DON", "DENON, Ltd." }, + { "ITR", "Infotronic America, Inc." }, + { "CAC", "CA & F Elettronica" }, + { "VIM", "Via Mons Ltd." }, + { "DGP", "Digicorp European sales S.A." }, + { "HPD", "Hewlett Packard" }, + { "USD", "U.S. Digital Corporation" }, + { "TAM", "Tamura Seisakusyo Ltd" }, + { "SGZ", "Systec Computer GmbH" }, + { "NGS", "A D S Exports" }, + { "FSI", "Fore Systems Inc" }, + { "SIL", "Silicon Laboratories, Inc" }, + { "QCP", "Qualcomm Inc" }, + { "SDA", "SAT (Societe Anonyme)" }, + { "SEI", "Seitz & Associates Inc" }, + { "RSI", "Rampage Systems Inc" }, + { "VIZ", "VIZIO, Inc" }, + { "EPN", "EPiCON Inc." }, + { "OIC", "Option Industrial Computers" }, + { "KDE", "KDE" }, + { "CLV", "Clevo Company" }, + { "GRA", "Graphica Computer" }, + { "HIK", "Hikom Co., Ltd." }, + { "LCE", "La Commande Electronique" }, + { "MNP", "Microcom" }, + { "ERI", "Ericsson Mobile Communications AB" }, + { "REX", "RATOC Systems, Inc." }, + { "PPP", "Purup Prepress AS" }, + { "JAT", "Jaton Corporation" }, + { "GLE", "AD electronics" }, + { "VAL", "Valence Computing Corporation" }, + { "CDN", "Codenoll Technical Corporation" }, + { "SDT", "Siemens AG" }, + { "RSC", "PhotoTelesis" }, + { "FFI", "Fairfield Industries" }, + { "VPR", "Best Buy" }, + { "IPM", "IPM Industria Politecnica Meridionale SpA" }, + { "HSM", "AT&T Microelectronics" }, + { "YHQ", "Yokogawa Electric Corporation" }, + { "UEC", "Ultima Electronics Corporation" }, + { "NME", "Navico, Inc." }, + { "GVL", "Global Village Communication" }, + { "TEK", "Tektronix Inc" }, + { "SBD", "Softbed - Consulting & Development Ltd" }, + { "PSD", "Peus-Systems GmbH" }, + { "DCA", "Digital Communications Association" }, + { "HWC", "DBA Hans Wedemeyer" }, + { "DFK", "SharkTec A/S" }, + { "DMB", "Digicom Systems Inc" }, + { "IPW", "IPWireless, Inc" }, + { "ACC", "Accton Technology Corporation" }, + { "CPM", "Capella Microsystems Inc." }, + { "AAT", "Ann Arbor Technologies" }, + { "LAS", "LASAT Comm. A/S" }, + { "TWI", "Easytel oy" }, + { "HJI", "Harris & Jeffries Inc" }, + { "SGX", "Silicon Graphics Inc" }, + { "TSL", "Tottori SANYO Electric Co., Ltd." }, + { "SVD", "SVD Computer" }, + { "CLT", "automated computer control systems" }, + { "WLD", "Wildfire Communications Inc" }, + { "LCI", "Lite-On Communication Inc" }, + { "AEC", "Antex Electronics Corporation" }, + { "ACA", "Ariel Corporation" }, + { "KML", "Kensington Microware Ltd" }, + { "KDT", "KDDI Technology Corporation" }, + { "BSE", "Bose Corporation" }, + { "WSP", "Wireless And Smart Products Inc." }, + { "GNZ", "Gunze Ltd" }, + { "PMM", "Point Multimedia System" }, + { "ASC", "Ascom Strategic Technology Unit" }, + { "EVX", "Everex" }, + { "WBN", "MicroSoftWare" }, + { "FGL", "Fujitsu General Limited." }, + { "JSI", "Jupiter Systems, Inc." }, + { "SII", "Silicon Image, Inc." }, + { "SMM", "Shark Multimedia Inc" }, + { "XYC", "Xycotec Computer GmbH" }, + { "PEC", "POTRANS Electrical Corp." }, + { "TSD", "TechniSat Digital GmbH" }, + { "ZSE", "Zenith Data Systems" }, + { "ENC", "Eizo Nanao Corporation" }, + { "MWY", "Microway Inc" }, + { "OLI", "Olivetti" }, + { "WIL", "WIPRO Information Technology Ltd" }, + { "LKM", "Likom Technology Sdn. Bhd." }, + { "KOU", "KOUZIRO Co.,Ltd." }, + { "VHI", "Macrocad Development Inc." }, + { "FIT", "Feature Integration Technology Inc." }, + { "MXP", "Maxpeed Corporation" }, + { "SCD", "Sanyo Electric Company Ltd" }, + { "NBL", "N*Able Technologies Inc" }, + { "SPT", "Sceptre Tech Inc" }, + { "IPN", "Performance Technologies" }, + { "BMD", "Blackmagic Design" }, + { "MDK", "Mediatek Corporation" }, + { "DCS", "Diamond Computer Systems Inc" }, + { "ICE", "IC Ensemble" }, + { "LSY", "LSI Systems Inc" }, + { "AMC", "Attachmate Corporation" }, + { "TCO", "Thomas-Conrad Corporation" }, + { "NOK", "Nokia Display Products" }, + { "VFI", "VeriFone Inc" }, + { "OPV", "Optivision Inc" }, + { "LCM", "Latitude Comm." }, + { "LSL", "Logical Solutions" }, + { "TVO", "TV One Ltd" }, + { "KVA", "Kvaser AB" }, + { "PMT", "Promate Electronic Co., Ltd." }, + { "ZZZ", "Boca Research Inc" }, + { "ELC", "Electro Scientific Ind" }, + { "SIR", "Sirius Technologies Pty Ltd" }, + { "DCE", "dSPACE GmbH" }, + { "WAN", "DO NOT USE - WAN" }, + { "PCT", "PC-Tel Inc" }, + { "BEO", "Baug & Olufsen" }, + { "LUM", "Lumagen, Inc." }, + { "DNA", "DNA Enterprises, Inc." }, + { "WEY", "WEY Design AG" }, + { "IAF", "Institut f r angewandte Funksystemtechnik GmbH" }, + { "QFF", "Padix Co., Inc." }, + { "JIC", "Jaeik Information & Communication Co., Ltd." }, + { "VIT", "Visitech AS" }, + { "QUA", "Quatographic AG" }, + { "BNK", "Banksia Tech Pty Ltd" }, + { "TME", "AT&T Microelectronics" }, + { "DRB", "Dr. Bott KG" }, + { "NET", "Mettler Toledo" }, + { "CDE", "Colin.de" }, + { "ATI", "Allied Telesis KK" }, + { "PMD", "TDK USA Corporation" }, + { "SKY", "SKYDATA S.P.A." }, + { "FTN", "Fountain Technologies Inc" }, + { "DBD", "Diebold Inc." }, + { "ECA", "Electro Cam Corp." }, + { "TLI", "TOSHIBA TELI CORPORATION" }, + { "CTC", "CTC Communication Development Company Ltd" }, + { "NVT", "Navatek Engineering Corporation" }, + { "CKC", "The Concept Keyboard Company Ltd" }, + { "FIR", "Chaplet Systems Inc" }, + { "HYD", "Hydis Technologies.Co.,LTD" }, + { "TTY", "TRIDELITY Display Solutions GmbH" }, + { "DAE", "Digatron Industrie Elektronik GmbH" }, + { "AUT", "Autotime Corporation" }, + { "GTC", "Graphtec Corporation" }, + { "MYR", "Myriad Solutions Ltd" }, + { "DLT", "Digitelec Informatique Park Cadera" }, + { "SDR", "SDR Systems" }, + { "ACS", "Altos Computer Systems" }, + { "SVC", "Intellix Corp." }, + { "ZTE", "ZTE Corporation" }, + { "ERT", "Escort Insturments Corporation" }, + { "WII", "Innoware Inc" }, + { "DOL", "Dolman Technologies Group Inc" }, + { "RLD", "MEPCO" }, + { "HRL", "Herolab GmbH" }, + { "IRD", "IRdata" }, + { "IVI", "Intervoice Inc" }, + { "ICS", "Integrated Circuit Systems" }, + { "ASE", "AseV Display Labs" }, + { "SYX", "Prime Systems, Inc." }, + { "SOI", "Silicon Optix Corporation" }, + { "OCS", "Open Connect Solutions" }, + { "HON", "Sonitronix" }, + { "TAG", "Teles AG" }, + { "PEP", "Peppercon AG" }, + { "INT", "Interphase Corporation" }, + { "IBR", "IBR GmbH" }, + { "WYS", "Wyse Technology" }, + { "TRE", "Tremetrics" }, + { "RKC", "Reakin Technolohy Corporation" }, + { "SEG", "DO NOT USE - SEG" }, + { "CAV", "Cavium Networks, Inc" }, + { "ELA", "ELAD srl" }, + { "MMD", "Micromed Biotecnologia Ltd" }, + { "SGL", "Super Gate Technology Company Ltd" }, + { "SIS", "Silicon Integrated Systems Corporation" }, + { "XFO", "EXFO Electro Optical Engineering" }, + { "ING", "Integraph Corporation" }, + { "NEU", "NEUROTEC - EMPRESA DE PESQUISA E DESENVOLVIMENTO EM BIOMEDICINA" }, + { "ZIC", "Nationz Technologies Inc." }, + { "CVI", "Colorado Video, Inc." }, + { "VCC", "Virtual Computer Corporation" }, + { "INZ", "Best Buy" }, + { "ELO", "Tyco Electronics" }, + { "EPH", "Epiphan Systems Inc." }, + { "SYL", "Sylvania Computer Products" }, + { "MXI", "Macronix Inc" }, + { "GEH", "GE Intelligent Platforms - Huntsville" }, + { "BBB", "an-najah university" }, + { "ARK", "Ark Logic Inc" }, + { "IVM", "Iiyama North America" }, + { "XTE", "X2E GmbH" }, + { "DMV", "NDS Ltd" }, + { "CPD", "CompuAdd" }, + { "CYD", "Cyclades Corporation" }, + { "ALX", "ALEXON Co.,Ltd." }, + { "COB", "COBY Electronics Co., Ltd" }, + { "HCE", "Hitachi Consumer Electronics Co., Ltd" }, + { "EXX", "Exxact GmbH" }, + { "TAB", "Todos Data System AB" }, + { "MPN", "Mainpine Limited" }, + { "ATH", "Athena Informatica S.R.L." }, + { "AWL", "Aironet Wireless Communications, Inc" }, + { "FNI", "Funai Electric Co., Ltd." }, + { "PLT", "PT Hartono Istana Teknologi" }, + { "DEN", "Densitron Computers Ltd" }, + { "MIM", "Mimio – A Newell Rubbermaid Company" }, + { "GER", "GERMANEERS GmbH" }, + { "CAI", "Canon Inc." }, + { "DNI", "Deterministic Networks Inc." }, + { "DOT", "Dotronic Mikroelektronik GmbH" }, + { "MVX", "COM 1" }, + { "WTC", "ACC Microelectronics" }, + { "HIT", "Hitachi America Ltd" }, + { "ALM", "Acutec Ltd." }, + { "TIP", "TIPTEL AG" }, + { "END", "ENIDAN Technologies Ltd" }, + { "PAR", "Parallan Comp Inc" }, + { "DVL", "Devolo AG" }, + { "ADV", "Advanced Micro Devices Inc" }, + { "TKS", "TimeKeeping Systems, Inc." }, + { "MLD", "Deep Video Imaging Ltd" }, + { "IUC", "ICSL" }, + { "MNL", "Monorail Inc" }, + { "HRC", "Hercules" }, + { "ANS", "Ansel Communication Company" }, + { "UAS", "Ultima Associates Pte Ltd" }, + { "SBS", "SBS-or Industrial Computers GmbH" }, + { "DVT", "Data Video" }, + { "PTS", "Plain Tree Systems Inc" }, + { "CSD", "Cresta Systems Inc" }, + { "LDT", "LogiDataTech Electronic GmbH" }, + { "AGM", "Advan Int'l Corporation" }, + { "TLD", "Telindus" }, + { "SPU", "SIM2 Multimedia S.P.A." }, + { "BCS", "Booria CAD/CAM systems" }, + { "CRQ", "Cirque Corporation" }, + { "MIL", "Marconi Instruments Ltd" }, + { "FTE", "Frontline Test Equipment Inc." }, + { "RWC", "Red Wing Corporation" }, + { "TLS", "Teleste Educational OY" }, + { "DAT", "Datel Inc" }, + { "SIT", "Sitintel" }, + { "QTI", "Quicknet Technologies Inc" }, + { "EBH", "Data Price Informatica" }, + { "PCK", "PCBANK21" }, + { "VSC", "ViewSonic Corporation" }, + { "BBL", "Brain Boxes Limited" }, + { "UFO", "UFO Systems Inc" }, + { "NTI", "New Tech Int'l Company" }, + { "WAV", "Wavephore" }, + { "NOT", "Not Limited Inc" }, + { "GRH", "Granch Ltd" }, + { "VTC", "VTel Corporation" }, + { "UNA", "Unisys DSD" }, + { "LAB", "ACT Labs Ltd" }, + { "UIC", "Uniform Industrial Corporation" }, + { "IDK", "IDK Corporation" }, + { "CHI", "Chrontel Inc" }, + { "QCH", "Metronics Inc" }, + { "CER", "Ceronix" }, + { "PCB", "OCTAL S.A." }, + { "VTV", "VATIV Technologies" }, + { "BTI", "BusTech Inc" }, + { "RVL", "Reveal Computer Prod" }, + { "CHC", "Chic Technology Corp." }, + { "QDS", "Quanta Display Inc." }, + { "DAW", "DA2 Technologies Inc" }, + { "MTR", "Mitron computer Inc" }, + { "PCP", "Procomp USA Inc" }, + { "AZM", "AZ Middelheim - Radiotherapy" }, + { "NHT", "Vinci Labs" }, + { "ROB", "Robust Electronics GmbH" }, + { "RIC", "RICOH COMPANY, LTD." }, + { "PCI", "Pioneer Computer Inc" }, + { "EKA", "MagTek Inc." }, + { "SWL", "Sharedware Ltd" }, + { "GSM", "Goldstar Company Ltd" }, + { "IDP", "Integrated Device Technology, Inc." }, + { "BPD", "Micro Solutions, Inc." }, + { "UNS", "Unisys Corporation" }, + { "PBN", "Packard Bell NEC" }, + { "KRM", "Kroma Telecom" }, + { "ENT", "Enterprise Comm. & Computing Inc" }, + { "ATL", "Arcus Technology Ltd" }, + { "VDT", "Viditec, Inc." }, + { "JUK", "Janich & Klass Computertechnik GmbH" }, + { "PVG", "Proview Global Co., Ltd" }, + { "INX", "Communications Supply Corporation (A division of WESCO)" }, + { "GDS", "GDS" }, + { "UHB", "XOCECO" }, + { "MEI", "Panasonic Industry Company" }, + { "OXU", "Oxus Research S.A." }, + { "SGO", "Logos Design A/S" }, + { "STU", "Sentelic Corporation" }, + { "PUL", "Pulse-Eight Ltd" }, + { "BRA", "Braemac Pty Ltd" }, + { "MBD", "Microbus PLC" }, + { "OAS", "Oasys Technology Company" }, + { "MDS", "Micro Display Systems Inc" }, + { "SCS", "Nanomach Anstalt" }, + { "DAS", "DAVIS AS" }, + { "NLC", "Next Level Communications" }, + { "MSU", "motorola" }, + { "MAD", "Xedia Corporation" }, + { "LOE", "Loewe Opta GmbH" }, + { "EEE", "ET&T Technology Company Ltd" }, + { "ANX", "Acer Netxus Inc" }, + { "IEE", "IEE" }, + { "ALL", "Alliance Semiconductor Corporation" }, + { "DCT", "Dancall Telecom A/S" }, + { "AII", "Amptron International Inc." }, + { "DPT", "DPT" }, + { "TNJ", "DO NOT USE - TNJ" }, + { "FTC", "Futuretouch Corporation" }, + { "ESG", "ELCON Systemtechnik GmbH" }, + { "SYV", "SYVAX Inc" }, + { "RAC", "Racore Computer Products Inc" }, + { "IBM", "IBM France" }, + { "LTV", "Leitch Technology International Inc." }, + { "AKE", "AKAMI Electric Co.,Ltd" }, + { "VDO", "Video & Display Oriented Corporation" }, + { "MEN", "MEN Mikroelectronik Nueruberg GmbH" }, + { "UNT", "Unisys Corporation" }, + { "TTK", "Totoku Electric Company Ltd" }, + { "DII", "Dataq Instruments Inc" }, + { "AMO", "Amino Technologies PLC and Amino Communications Limited" }, + { "IMC", "IMC Networks" }, + { "STG", "StereoGraphics Corp." }, + { "RRI", "Radicom Research Inc" }, + { "HTI", "Hampshire Company, Inc." }, + { "SOR", "Sorcus Computer GmbH" }, + { "AXL", "Axel" }, + { "SNS", "Cirtech (UK) Ltd" }, + { "IPD", "Industrial Products Design, Inc." }, + { "FMI", "Fujitsu Microelect Inc" }, + { "FMA", "Fast Multimedia AG" }, + { "MIT", "MCM Industrial Technology GmbH" }, + { "RII", "Racal Interlan Inc" }, + { "PDN", "AT&T Paradyne" }, + { "TRU", "Aashima Technology B.V." }, + { "BEI", "Beckworth Enterprises Inc" }, + { "RSS", "Rockwell Semiconductor Systems" }, + { "SHR", "Digital Discovery" }, + { "CDT", "IBM Corporation" }, + { "TKC", "Taiko Electric Works.LTD" }, + { "ITM", "ITM inc." }, + { "QUE", "Questra Consulting" }, + { "CMR", "Cambridge Research Systems Ltd" }, + { "LCC", "LCI" }, + { "MDO", "Panasonic" }, + { "IEC", "Interlace Engineering Corporation" }, + { "DPL", "Digital Projection Limited" }, + { "INV", "Inviso, Inc." }, + { "JSD", "JS DigiTech, Inc" }, + { "TOE", "TOEI Electronics Co., Ltd." }, + { "HAY", "Hayes Microcomputer Products Inc" }, + { "SSJ", "Sankyo Seiki Mfg.co., Ltd" }, + { "NNC", "NNC" }, + { "PHE", "Philips Medical Systems Boeblingen GmbH" }, + { "MWI", "Multiwave Innovation Pte Ltd" }, + { "WYT", "Wooyoung Image & Information Co.,Ltd." }, + { "AIM", "AIMS Lab Inc" }, + { "CSS", "CSS Laboratories" }, + { "TRS", "Torus Systems Ltd" }, + { "ROK", "Rockwell International" }, + { "SXD", "Silex technology, Inc." }, + { "PHS", "Philips Communication Systems" }, + { "CLM", "CrystaLake Multimedia" }, + { "ALO", "Algolith Inc." }, + { "SIU", "Seiko Instruments USA Inc" }, + { "TUA", "T+A elektroakustik GmbH" }, + { "CTE", "Chunghwa Telecom Co., Ltd." }, + { "SDD", "Intrada-SDD Ltd" }, + { "RMT", "Roper Mobile" }, + { "SSP", "Spectrum Signal Proecessing Inc" }, + { "VTN", "VIDEOTRON CORP." }, + { "VAD", "Vaddio, LLC" }, + { "SFT", "Mikroforum Ring 3" }, + { "DGK", "DugoTech Co., LTD" }, + { "ACH", "Archtek Telecom Corporation" }, + { "ABT", "Anchor Bay Technologies, Inc." }, + { "STC", "STAC Electronics" }, + { "DRS", "DRS Defense Solutions, LLC" }, + { "OQI", "Oksori Company Ltd" }, + { "IMT", "Inmax Technology Corporation" }, + { "ENE", "ENE Technology Inc." }, + { "WBS", "WB Systemtechnik GmbH" }, + { "PRC", "PerComm" }, + { "PSC", "Philips Semiconductors" }, + { "RJS", "Advanced Engineering" }, + { "STS", "SITECSYSTEM CO., LTD." }, + { "LAV", "Lava Computer MFG Inc" }, + { "RCH", "Reach Technology Inc" }, + { "DWE", "Daewoo Electronics Company Ltd" }, + { "KTC", "Kingston Tech Corporation" }, + { "GLS", "Gadget Labs LLC" }, + { "COS", "CoStar Corporation" }, + { "SBI", "SMART Technologies Inc." }, + { "ATP", "Alpha-Top Corporation" }, + { "DQB", "Datacube Inc" }, + { "INN", "Innovent Systems, Inc." }, + { "DNT", "Dr. Neuhous Telekommunikation GmbH" }, + { "KFX", "Kofax Image Products" }, + { "APE", "Alpine Electronics, Inc." }, + { "DSM", "DSM Digital Services GmbH" }, + { "RES", "ResMed Pty Ltd" }, + { "HMX", "HUMAX Co., Ltd." }, + { "PCW", "Pacific CommWare Inc" }, + { "KYC", "Kyocera Corporation" }, + { "VSN", "Ingram Macrotron" }, + { "SNT", "SuperNet Inc" }, + { "TEL", "Promotion and Display Technology Ltd." }, + { "IFX", "Infineon Technologies AG" }, + { "PVC", "DO NOT USE - PVC" }, + { "JKC", "JVC KENWOOD Corporation" }, + { "MSV", "Mosgi Corporation" }, + { "BUR", "Bernecker & Rainer Ind-Eletronik GmbH" }, + { "PTA", "PAR Tech Inc." }, + { "GGL", "Google Inc." }, + { "COM", "Comtrol Corporation" }, + { "JEN", "N-Vision" }, + { "AMP", "AMP Inc" }, + { "HDI", "HD-INFO d.o.o." }, + { "BOE", "BOE" }, + { "ICM", "Intracom SA" }, + { "ADD", "Advanced Peripheral Devices Inc" }, + { "PRI", "Priva Hortimation BV" }, + { "ANL", "Analogix Semiconductor, Inc" }, + { "AVO", "Avocent Corporation" }, + { "LEG", "Legerity, Inc" }, + { "DTE", "Dimension Technologies, Inc." }, + { "WPA", "Matsushita Communication Industrial Co., Ltd." }, + { "OLV", "Olitec S.A." }, + { "RNB", "Rainbow Technologies" }, + { "LVI", "LVI Low Vision International AB" }, + { "LOC", "Locamation B.V." }, + { "TGC", "Toshiba Global Commerce Solutions, Inc." }, + { "STI", "Smart Tech Inc" }, + { "TLF", "Teleforce.,co,ltd" }, + { "PLC", "Pro-Log Corporation" }, + { "HSD", "HannStar Display Corp" }, + { "ONE", "Oneac Corporation" }, + { "CLE", "Classe Audio" }, + { "MCI", "Micronics Computers" }, + { "VTG", "Voice Technologies Group Inc" }, + { "VTI", "VLSI Tech Inc" }, + { "DAI", "DAIS SET Ltd." }, + { "UNM", "Unisys Corporation" }, + { "MCQ", "Mat's Computers" }, + { "IPC", "IPC Corporation" }, + { "ADE", "Arithmos, Inc." }, + { "PON", "Perpetual Technologies, LLC" }, + { "EXA", "Exabyte" }, + { "CHD", "ChangHong Electric Co.,Ltd" }, + { "FDT", "Fujitsu Display Technologies Corp." }, + { "DBL", "Doble Engineering Company" }, + { "CTP", "Computer Technology Corporation" }, + { "CLD", "COMMAT L.t.d." }, + { "BLI", "Busicom" }, + { "FRS", "South Mountain Technologies, LTD" }, + { "CDD", "Convergent Data Devices" }, + { "SHT", "Shin Ho Tech" }, + { "EPC", "Empac" }, + { "RDS", "Radius Inc" }, + { "NEX", "Nexgen Mediatech Inc.," }, + { "AGC", "Beijing Aerospace Golden Card Electronic Engineering Co.,Ltd." }, + { "MCP", "Magni Systems Inc" }, + { "WMO", "Westermo Teleindustri AB" }, + { "NMX", "Neomagic" }, + { "BDS", "Barco Display Systems" }, + { "RIV", "Rivulet Communications" }, + { "TRA", "TriTech Microelectronics International" }, + { "CYX", "Cyrix Corporation" }, + { "TCM", "3Com Corporation" }, + { "ZYP", "Zypcom Inc" }, + { "VIB", "Tatung UK Ltd" }, + { "IEI", "Interlink Electronics" }, + { "BGB", "Barco Graphics N.V" }, + { "ISP", "IntreSource Systems Pte Ltd" }, + { "BGT", "Budzetron Inc" }, + { "DPS", "Digital Processing Systems" }, + { "SSS", "S3 Inc" }, + { "AXB", "Adrienne Electronics Corporation" }, + { "HKA", "HONKO MFG. CO., LTD." }, + { "TPK", "TOPRE CORPORATION" }, + { "NPI", "Network Peripherals Inc" }, + { "LMP", "Leda Media Products" }, + { "MAI", "Mutoh America Inc" }, + { "ATX", "Athenix Corporation" }, + { "MVM", "SOBO VISION" }, + { "ALI", "Acer Labs" }, + { "HPR", "H.P.R. Electronics GmbH" }, + { "BIL", "Billion Electric Company Ltd" }, + { "CRO", "Extraordinary Technologies PTY Limited" }, + { "KTG", "Kayser-Threde GmbH" }, + { "SCI", "System Craft" }, + { "MVD", "Microvitec PLC" }, + { "IST", "Intersolve Technologies" }, + { "ICD", "ICD Inc" }, + { "PDS", "PD Systems International Ltd" }, + { "CPQ", "Compaq Computer Company" }, + { "QCL", "Quadrant Components Inc" }, + { "PRA", "PRO/AUTOMATION" }, + { "MAC", "MAC System Company Ltd" }, + { "TOP", "Orion Communications Co., Ltd." }, + { "AGT", "Agilent Technologies" }, + { "SWI", "Sierra Wireless Inc." }, + { "ATT", "AT&T" }, + { "MCL", "Motorola Communications Israel" }, + { "NCS", "Northgate Computer Systems" }, + { "RSX", "Rapid Tech Corporation" }, + { "ATV", "Office Depot, Inc." }, + { "MRD", "MicroDisplay Corporation" }, + { "SCH", "Schlumberger Cards" }, + { "ONW", "OPEN Networks Ltd" }, + { "DTC", "DTC Tech Corporation" }, + { "HYV", "Hynix Semiconductor" }, + { "WEL", "W-DEV" }, + { "AND", "Adtran Inc" }, + { "AMN", "Amimon LTD." }, + { "PXL", "The Moving Pixel Company" }, + { "ZCT", "ZeitControl cardsystems GmbH" }, + { "ALH", "AL Systems" }, + { "VCJ", "Victor Company of Japan, Limited" }, + { "COD", "CODAN Pty. Ltd." }, + { "TMM", "Time Management, Inc." }, + { "PPR", "PicPro" }, + { "INL", "InnoLux Display Corporation" }, + { "LTC", "Labtec Inc" }, + { "PNP", "Microsoft" }, + { "FIL", "Forefront Int'l Ltd" }, + { "OSR", "Oksori Company Ltd" }, + { "PEI", "PEI Electronics Inc" }, + { "EZP", "Storm Technology" }, + { "TCE", "Century Corporation" }, + { "KAR", "Karna" }, + { "ALS", "Texas Advanced optoelectronics Solutions, Inc" }, + { "COI", "Codec Inc." }, + { "NRT", "Beijing Northern Radiantelecom Co." }, + { "FTR", "Mediasonic" }, + { "SUN", "Sun Electronics Corporation" }, + { "OZO", "Tribe Computer Works Inc" }, + { "MCO", "Motion Computing Inc." }, + { "UBI", "Ungermann-Bass Inc" }, + { "ZNI", "Zetinet Inc" }, + { "FUN", "sisel muhendislik" }, + { "RMP", "Research Machines" }, + { "DGT", "The Dearborn Group" }, + { "SPX", "Simplex Time Recorder Co." }, + { "COR", "Corollary Inc" }, + { "AMX", "AMX LLC" }, + { "AKY", "Askey Computer Corporation" }, + { "RAR", "Raritan, Inc." }, + { "VDS", "Vidisys GmbH & Company" }, + { "SCL", "Sigmacom Co., Ltd." }, + { "KSL", "Karn Solutions Ltd." }, + { "ACK", "Acksys" }, + { "NWS", "Newisys, Inc." }, + { "TRX", "Trex Enterprises" }, + { "BOI", "NINGBO BOIGLE DIGITAL TECHNOLOGY CO.,LTD" }, + { "NTT", "NTT Advanced Technology Corporation" }, + { "GUZ", "Guzik Technical Enterprises" }, + { "MDY", "Microdyne Inc" }, + { "EDM", "EDMI" }, + { "DTI", "Diversified Technology, Inc." }, + { "MMI", "Multimax" }, + { "SCB", "SeeCubic B.V." }, + { "UPS", "Systems Enhancement" }, + { "AKB", "Akebia Ltd" }, + { "NBT", "NingBo Bestwinning Technology CO., Ltd" }, + { "TCD", "Taicom Data Systems Co., Ltd." }, + { "XMM", "C3PO S.L." }, + { "OIM", "Option International" }, + { "DAV", "Davicom Semiconductor Inc" }, + { "CKJ", "Carina System Co., Ltd." }, + { "ATD", "Alpha Telecom Inc" }, + { "XQU", "SHANGHAI SVA-DAV ELECTRONICS CO., LTD" }, + { "KOL", "Kollmorgen Motion Technologies Group" }, + { "HWA", "Harris Canada Inc" }, + { "INE", "Inventec Electronics (M) Sdn. Bhd." }, + { "ORN", "ORION ELECTRIC CO., LTD." }, + { "KES", "Kesa Corporation" }, + { "CRC", "CONRAC GmbH" }, + { "AXT", "Axtend Technologies Inc" }, + { "NAX", "Naxos Tecnologia" }, + { "DAN", "Danelec Marine A/S" }, + { "ADP", "Adaptec Inc" }, + { "ICA", "ICA Inc" }, + { "AGL", "Argolis" }, + { "ECC", "ESSential Comm. Corporation" }, + { "AWS", "Wave Systems" }, + { "APN", "Appian Tech Inc" }, + { "DGI", "DIGI International" }, + { "MCS", "Micro Computer Systems" }, + { "ITA", "Itausa Export North America" }, + { "CII", "Cromack Industries Inc" }, + { "IPS", "IPS, Inc. (Intellectual Property Solutions, Inc.)" }, + { "KOE", "KOLTER ELECTRONIC" }, + { "MEP", "Meld Technology" }, + { "IMA", "Imagraph" }, + { "DDV", "Delta Information Systems, Inc" }, + { "GML", "General Information Systems" }, + { "SSC", "Sierra Semiconductor Inc" }, + { "WNX", "Wincor Nixdorf International GmbH" }, + { "ABD", "Allen Bradley Company" }, + { "CMS", "CompuMaster Srl" }, + { "INK", "Indtek Co., Ltd." }, + { "DTT", "Design & Test Technology, Inc." }, + { "MGA", "Mega System Technologies, Inc." }, + { "SMO", "STMicroelectronics" }, + { "SSI", "S-S Technology Inc" }, + { "CIR", "Cirrus Logic Inc" }, + { "EKC", "Eastman Kodak Company" }, + { "LNR", "Linear Systems Ltd." }, + { "VCM", "Vector Magnetics, LLC" }, + { "HKG", "Josef Heim KG" }, + { "ORG", "ORGA Kartensysteme GmbH" }, + { "ELG", "Elmeg GmbH Kommunikationstechnik" }, + { "NSI", "NISSEI ELECTRIC CO.,LTD" }, + { "RDM", "Tremon Enterprises Company Ltd" }, + { "HAI", "Haivision Systems Inc." }, + { "CIC", "Comm. Intelligence Corporation" }, + { "LTS", "LTS Scale LLC" }, + { "SAS", "Stores Automated Systems Inc" }, + { "OEC", "ORION ELECTRIC CO.,LTD" }, + { "BRG", "Bridge Information Co., Ltd" }, + { "SQT", "Sequent Computer Systems Inc" }, + { "CCI", "Cache" }, + { "PRX", "Proxima Corporation" }, + { "ADR", "Nasa Ames Research Center" }, + { "SNW", "Snell & Wilcox" }, + { "CDI", "Concept Development Inc" }, + { "SEA", "Seanix Technology Inc." }, + { "STY", "SDS Technologies" }, + { "PCA", "Philips BU Add On Card" }, + { "NYC", "nakayo telecommunications,inc." }, + { "JMT", "Micro Technical Company Ltd" }, + { "MTD", "MindTech Display Co. Ltd" }, + { "NSP", "Nspire System Inc." }, + { "DSD", "DS Multimedia Pte Ltd" }, + { "PBI", "Pitney Bowes" }, + { "ARO", "Poso International B.V." }, + { "TTE", "TTE, Inc." }, + { "DDA", "DA2 Technologies Corporation" }, + { "MAS", "Mass Inc." }, + { "LAC", "LaCie" }, + { "CRX", "Cyrix Corporation" }, + { "EMO", "ELMO COMPANY, LIMITED" }, + { "OSP", "OPTI-UPS Corporation" }, + { "GED", "General Dynamics C4 Systems" }, + { "PPI", "Practical Peripherals" }, + { "VPI", "Video Products Inc" }, + { "TOS", "Toshiba Corporation" }, + { "ASL", "AccuScene Corporation Ltd" }, + { "ANT", "Ace CAD Enterprise Company Ltd" }, + { "GRV", "Advanced Gravis" }, + { "ANO", "Anorad Corporation" }, + { "LNK", "Link Tech Inc" }, + { "DIG", "Digicom S.p.A." }, + { "ALC", "Altec Corporation" }, + { "IAI", "Integration Associates, Inc." }, + { "APG", "Horner Electric Inc" }, + { "TWK", "TOWITOKO electronics GmbH" }, + { "BRI", "Boca Research Inc" }, + { "SVS", "SVSI" }, + { "QCI", "Quanta Computer Inc" }, + { "MDD", "MODIS" }, + { "PDT", "PDTS - Prozessdatentechnik und Systeme" }, + { "IMP", "Impression Products Incorporated" }, + { "EXI", "Exide Electronics" }, + { "WNV", "Winnov L.P." }, + { "ALG", "Realtek Semiconductor Corp." }, + { "ESA", "Elbit Systems of America" }, + { "OLC", "Olicom A/S" }, + { "DPX", "DpiX, Inc." }, + { "GSB", "NIPPONDENCHI CO,.LTD" }, + { "MCA", "American Nuclear Systems Inc" }, + { "EST", "Embedded Solution Technology" }, + { "ADX", "Adax Inc" }, + { "MSA", "Micro Systemation AB" }, + { "HDV", "Holografika kft." }, + { "GIP", "GI Provision Ltd" }, + { "XTN", "X-10 (USA) Inc" }, + { "VEC", "Vector Informatik GmbH" }, + { "DTN", "Datang Telephone Co" }, + { "CST", "CSTI Inc" }, + { "ECO", "Echo Speech Corporation" }, + { "TDD", "Tandberg Data Display AS" }, + { "NVL", "Novell Inc" }, + { "CHT", "Chunghwa Picture Tubes,LTD." }, + { "SCP", "Scriptel Corporation" }, + { "TMS", "Trident Microsystems Ltd" }, + { "ABO", "D-Link Systems Inc" }, + { "JTY", "jetway security micro,inc" }, + { "LSD", "Intersil Corporation" }, + { "SEP", "SEP Eletronica Ltda." }, + { "SHI", "Jiangsu Shinco Electronic Group Co., Ltd" }, + { "FTG", "FTG Data Systems" }, + { "ESN", "eSATURNUS" }, + { "DJE", "Capstone Visual Product Development" }, + { "BEC", "Elektro Beckhoff GmbH" }, + { "FVC", "First Virtual Corporation" }, + { "JUP", "Jupiter Systems" }, + { "XNT", "XN Technologies, Inc." }, + { "RTK", "DO NOT USE - RTK" }, + { "ACL", "Apricot Computers" }, + { "TAA", "Tandberg" }, + { "WIP", "Wipro Infotech" }, + { "KRL", "Krell Industries Inc." }, + { "INO", "Innolab Pte Ltd" }, + { "ELT", "Element Labs, Inc." }, + { "KTE", "K-Tech" }, + { "CVA", "Covia Inc." }, + { "SIC", "Sysmate Corporation" }, + { "STH", "Semtech Corporation" }, + { "ACD", "AWETA BV" }, + { "EHN", "Enhansoft" }, + { "VMI", "Vermont Microsystems" }, + { "TTC", "Telecommunications Techniques Corporation" }, + { "KYE", "KYE Syst Corporation" }, + { "QDI", "Quantum Data Incorporated" }, + { "ELL", "Electrosonic Ltd" }, + { "FLE", "ADTI Media, Inc" }, + { "KTD", "Takahata Electronics Co.,Ltd." }, + { "MAL", "Meridian Audio Ltd" }, + { "TRV", "Trivisio Prototyping GmbH" }, + { "TWH", "Twinhead International Corporation" }, + { "SYP", "SYPRO Co Ltd" }, + { "GCC", "GCC Technologies Inc" }, + { "POR", "Portalis LC" }, + { "PIM", "Prism, LLC" }, + { "MLX", "Mylex Corporation" }, + { "ONL", "OnLive, Inc" }, + { "NIS", "Nissei Electric Company" }, + { "ISM", "Image Stream Medical" }, + { "EPS", "KEPS" }, + { "PAC", "Pacific Avionics Corporation" }, + { "AXC", "AXIOMTEK CO., LTD." }, + { "DYX", "Dynax Electronics (HK) Ltd" }, + { "WEB", "WebGear Inc" }, + { "RIT", "Ritech Inc" }, + { "INI", "Initio Corporation" }, + { "LBO", "Lubosoft" }, + { "PGM", "Paradigm Advanced Research Centre" }, + { "OSA", "OSAKA Micro Computer, Inc." }, + { "SIN", "Singular Technology Co., Ltd." }, + { "CIN", "Citron GmbH" }, + { "OTB", "outsidetheboxstuff.com" }, + { "ARL", "Arlotto Comnet Inc" }, + { "HOB", "HOB Electronic GmbH" }, + { "QQQ", "Chuomusen Co., Ltd." }, + { "AXE", "D-Link Systems Inc" }, + { "CCC", "C-Cube Microsystems" }, + { "CPT", "cPATH" }, + { "SEM", "Samsung Electronics Company Ltd" }, + { "PVI", "Prime view international Co., Ltd" }, + { "TAT", "Teleliaison Inc" }, + { "SON", "Sony" }, + { "ITT", "I&T Telecom." }, + { "SLM", "Solomon Technology Corporation" }, + { "MAN", "LGIC" }, + { "AIX", "ALTINEX, INC." }, + { "ASP", "ASP Microelectronics Ltd" }, + { "VUT", "Vutrix (UK) Ltd" }, + { "MTE", "MediaTec GmbH" }, + { "UPP", "UPPI" }, + { "DCM", "DCM Data Products" }, + { "DYC", "Dycam Inc" }, + { "DAK", "Daktronics" }, + { "JAZ", "Carrera Computer Inc" }, + { "FOX", "HON HAI PRECISON IND.CO.,LTD." }, + { "UEI", "Universal Electronics Inc" }, + { "OPI", "D.N.S. Corporation" }, + { "CXT", "Conexant Systems" }, + { "VTK", "Viewteck Co., Ltd." }, + { "AVL", "Avalue Technology Inc." }, + { "TSI", "TeleVideo Systems" }, + { "PAN", "The Panda Project" }, + { "CED", "Cambridge Electronic Design Ltd" }, + { "RUP", "Ups Manufactoring s.r.l." }, + { "MIP", "micronpc.com" }, + { "REM", "SCI Systems Inc." }, + { "NSS", "Newport Systems Solutions" }, + { "FBI", "Interface Corporation" }, + { "FER", "Ferranti Int'L" }, + { "DLG", "Digital-Logic GmbH" }, + { "TSY", "TouchSystems" }, + { "PIO", "Pioneer Electronic Corporation" }, + { "PNG", "P.I. Engineering Inc" }, + { "OIN", "Option International" }, + { "RED", "Research Electronics Development Inc" }, + { "NOI", "North Invent A/S" }, + { "MAY", "Maynard Electronics" }, + { "BTO", "BioTao Ltd" }, + { "ZYD", "Zydacron Inc" }, + { "KCD", "Chunichi Denshi Co.,LTD." }, + { "TTI", "Trenton Terminals Inc" }, + { "TRD", "Trident Microsystem Inc" }, + { "TDP", "3D Perception" }, + { "TER", "TerraTec Electronic GmbH" }, + { "AEM", "ASEM S.p.A." }, + { "IBI", "INBINE.CO.LTD" }, + { "ECK", "Eugene Chukhlomin Sole Proprietorship, d.b.a." }, + { "AVT", "Avtek (Electronics) Pty Ltd" }, + { "PST", "Global Data SA" }, + { "FPS", "Deltec Corporation" }, + { "SHP", "Sharp Corporation" }, + { "RDN", "RADIODATA GmbH" }, + { "TRC", "Trioc AB" }, + { "ABE", "Alcatel Bell" }, + { "VCX", "VCONEX" }, + { "PBL", "Packard Bell Electronics" }, + { "TLK", "Telelink AG" }, + { "DMM", "Dimond Multimedia Systems Inc" }, + { "IGM", "IGM Communi" }, + { "KFC", "SCD Tech" }, + { "GUD", "Guntermann & Drunck GmbH" }, + { "MDA", "Media4 Inc" }, + { "VWB", "Vweb Corp." }, + { "ISG", "Insignia Solutions Inc" }, + { "AMS", "ARMSTEL, Inc." }, + { "NTL", "National Transcomm. Ltd" }, + { "LSJ", "LSI Japan Company Ltd" }, + { "NDL", "Network Designers" }, + { "DIA", "Diadem" }, + { "SDX", "SDX Business Systems Ltd" }, + { "LPL", "LG Philips" }, + { "CAG", "CalComp" }, + { "FZC", "Founder Group Shenzhen Co." }, + { "PCX", "PC Xperten" }, + { "TSF", "Racal-Airtech Software Forge Ltd" }, + { "RGL", "Robertson Geologging Ltd" }, + { "MSD", "Datenerfassungs- und Informationssysteme" }, + { "NVC", "NetVision Corporation" }, + { "SKD", "Schneider & Koch" }, + { "CRS", "Crescendo Communication Inc" }, + { "AXI", "American Magnetics" }, + { "HRS", "Harris Semiconductor" }, + { "AEN", "Avencall" }, + { "TCL", "Technical Concepts Ltd" }, + { "SST", "SystemSoft Corporation" }, + { "OMN", "Omnitel" }, + { "GCI", "Gateway Comm. Inc" }, + { "SEN", "Sencore" }, + { "MDT", "Magus Data Tech" }, + { "ALN", "Alana Technologies" }, + { "AVD", "Avid Electronics Corporation" }, + { "DOM", "Dome Imaging Systems" }, + { "KBL", "Kobil Systems GmbH" }, + { "ITS", "IDTECH" }, + { "CGS", "Chyron Corp" }, + { "CYV", "Cyviz AS" }, + { "CSO", "California Institute of Technology" }, + { "ADT", "Aved Display Technologies" }, + { "ACP", "Aspen Tech Inc" }, + { "AKI", "AKIA Corporation" }, + { "LCT", "Labcal Technologies" }, + { "NDS", "Nokia Data" }, + { "WCS", "Woodwind Communications Systems Inc" }, + { "XFG", "Jan Strapko - FOTO" }, + { "CPI", "Computer Peripherals Inc" }, + { "FCG", "First International Computer Ltd" }, + { "EVE", "Advanced Micro Peripherals Ltd" }, + { "ATO", "ASTRO DESIGN, INC." }, + { "SGW", "Shanghai Guowei Science and Technology Co., Ltd." }, + { "CNB", "American Power Conversion" }, + { "TCX", "FREEMARS Heavy Industries" }, + { "ITN", "The NTI Group" }, + { "HWD", "Highwater Designs Ltd" }, + { "NUG", "NU Technology, Inc." }, + { "ISL", "Isolation Systems" }, + { "CIL", "Citicom Infotech Private Limited" }, + { "IOT", "I/OTech Inc" }, + { "GET", "Getac Technology Corporation" }, + { "ULT", "Ultra Network Tech" }, + { "TVV", "TV1 GmbH" }, + { "OWL", "Mediacom Technologies Pte Ltd" }, + { "TMX", "Thermotrex Corporation" }, + { "ARC", "Alta Research Corporation" }, + { "SEL", "Way2Call Communications" }, + { "ELS", "ELSA GmbH" }, + { "STD", "STD Computer Inc" }, + { "GST", "Graphic SystemTechnology" }, + { "SME", "Sysmate Company" }, + { "ARS", "Arescom Inc" }, + { "SCN", "Scanport, Inc." }, + { "CTX", "Creatix Polymedia GmbH" }, + { "DIM", "dPict Imaging, Inc." }, + { "MDI", "Micro Design Inc" }, + { "SCM", "SCM Microsystems Inc" }, + { "CEA", "Consumer Electronics Association" }, + { "OTI", "Orchid Technology" }, + { "ADK", "Adtek System Science Company Ltd" }, + { "ETC", "Everton Technology Company Ltd" }, + { "PCO", "Performance Concepts Inc.," }, + { "DMC", "Dune Microsystems Corporation" }, + { "SGM", "SAGEM" }, + { "OBS", "Optibase Technologies" }, + { "PMX", "Photomatrix" }, + { "SDI", "Samtron Displays Inc" }, + { "GMM", "GMM Research Inc" }, + { "DUN", "NCR Corporation" }, + { "CAL", "Acon" }, + { "MIR", "Miro Computer Prod." }, + { "PEN", "Interactive Computer Products Inc" }, + { "CRL", "Creative Logic" }, + { "SBT", "Senseboard Technologies AB" }, + { "AST", "AST Research Inc" }, + { "INS", "Ines GmbH" }, + { "SGC", "Spectragraphics Corporation" }, + { "DBI", "DigiBoard Inc" }, + { "LEO", "First International Computer Inc" }, + { "TSP", "U.S. Navy" }, + { "MTK", "Microtek International Inc." }, + { "TCN", "Tecnetics (PTY) Ltd" }, + { "DPM", "ADPM Synthesis sas" }, + { "LGS", "LG Semicom Company Ltd" }, + { "LGI", "Logitech Inc" }, + { "PBV", "Pitney Bowes" }, + { "ELI", "Edsun Laboratories" }, + { "HPQ", "HP" }, + { "RPT", "R.P.T.Intergroups" }, + { "BDO", "Brahler ICS" }, + { "ARM", "Arima" }, + { "JTS", "JS Motorsports" }, + { "TNY", "Tennyson Tech Pty Ltd" }, + { "UDN", "Uniden Corporation" }, + { "KNC", "Konica corporation" }, + { "GND", "Gennum Corporation" }, + { "MSG", "MSI GmbH" }, + { "REH", "Rehan Electronics Ltd." }, + { "COL", "Rockwell Collins, Inc." }, + { "MDC", "Midori Electronics" }, + { "TRN", "Datacommunicatie Tron B.V." }, + { "VDA", "Victor Data Systems" }, + { "TOU", "Touchstone Technology" }, + { "ETD", "ELAN MICROELECTRONICS CORPORATION" }, + { "CYB", "CyberVision" }, + { "SWC", "Software Café" }, + { "EXN", "RGB Systems, Inc. dba Extron Electronics" }, + { "HSP", "HannStar Display Corp" }, + { "WTK", "Wearnes Thakral Pte" }, + { "GFM", "GFMesstechnik GmbH" }, + { "INC", "Home Row Inc" }, + { "LEC", "Lectron Company Ltd" }, + { "WTS", "Restek Electric Company Ltd" }, + { "ACE", "Actek Engineering Pty Ltd" }, + { "MSH", "Microsoft" }, + { "CHL", "Chloride-R&D" }, + { "ALT", "Altra" }, + { "EES", "EE Solutions, Inc." }, + { "ASX", "AudioScience" }, + { "DAC", "Digital Acoustics Corporation" }, + { "HAL", "Halberthal" }, + { "HPC", "Hewlett Packard Co." }, + { "GRY", "Robert Gray Company" }, + { "AXO", "Axonic Labs LLC" }, + { "ALJ", "Altec Lansing" }, + { "SMS", "Silicom Multimedia Systems Inc" }, + { "HPI", "Headplay, Inc." }, + { "FRO", "FARO Technologies" }, + { "GAU", "Gaudi Co., Ltd." }, + { "SRS", "SR-Systems e.K." }, + { "APL", "Aplicom Oy" }, + { "JGD", "University College" }, + { "NVD", "Nvidia" }, + { "CEP", "C-DAC" }, + { "BDR", "Blonder Tongue Labs, Inc." }, + { "AUO", "AU Optronics" }, + { "DCR", "Decros Ltd" }, + { "DLK", "D-Link Systems Inc" }, + { "SWS", "Static" }, + { "WSC", "CIS Technology Inc" }, + { "ESL", "Esterline Technologies" }, + { "ISC", "Id3 Semiconductors" }, + { "XSN", "Xscreen AS" }, + { "FML", "Fujitsu Microelect Ltd" }, + { "WPI", "Wearnes Peripherals International (Pte) Ltd" }, + { "EGL", "Eagle Technology" }, + { "EGA", "Elgato Systems LLC" }, + { "GAG", "Gage Applied Sciences Inc" }, + { "HCP", "Hitachi Computer Products Inc" }, + { "UET", "Universal Empowering Technologies" }, + { "ITL", "Inter-Tel" }, + { "SDE", "Sherwood Digital Electronics Corporation" }, + { "CAA", "Castles Automation Co., Ltd" }, + { "ZRN", "Zoran Corporation" }, + { "VLT", "VideoLan Technologies" }, + { "EUT", "Ericsson Mobile Networks B.V." }, + { "REA", "Real D" }, + { "BUT", "21ST CENTURY ENTERTAINMENT" }, + { "THN", "Thundercom Holdings Sdn. Bhd." }, + { "CHO", "Sichuang Changhong Corporation" }, + { "SCC", "SORD Computer Corporation" }, + { "MSY", "MicroTouch Systems Inc" }, + { "ERP", "Euraplan GmbH" }, + { "CPL", "Compal Electronics Inc" }, + { "ACM", "Acroloop Motion Control Systems Inc" }, + { "VTS", "VTech Computers Ltd" }, + { "ETH", "Etherboot Project" }, + { "CGT", "congatec AG" }, + { "FEN", "Fen Systems Ltd." }, + { "MLN", "Mark Levinson" }, + { "UMC", "United Microelectr Corporation" }, + { "CAR", "Cardinal Company Ltd" }, + { "LIT", "Lithics Silicon Technology" }, + { "AWC", "Access Works Comm Inc" }, + { "PPC", "Phoenixtec Power Company Ltd" }, + { "SVT", "SEVIT Co., Ltd." }, + { "MDX", "MicroDatec GmbH" }, + { "XIN", "Xinex Networks Inc" }, + { "KTN", "Katron Tech Inc" }, + { "MJI", "MARANTZ JAPAN, INC." }, + { "CTM", "Computerm Corporation" }, + { "PDM", "Psion Dacom Plc." }, + { "AKM", "Asahi Kasei Microsystems Company Ltd" }, + { "GSY", "Grossenbacher Systeme AG" }, + { "OMR", "Omron Corporation" }, + { "RSH", "ADC-Centre" }, + { "MTM", "Motium" }, + { "XDM", "XDM Ltd." }, + { "MSX", "Micomsoft Co., Ltd." }, + { "VNC", "Vinca Corporation" }, + { "STK", "SANTAK CORP." }, + { "JET", "JET POWER TECHNOLOGY CO., LTD." }, + { "SLR", "Schlumberger Technology Corporate" }, + { "GWI", "GW Instruments" }, + { "TMI", "Texas Microsystem" }, + { "EXT", "Exatech Computadores & Servicos Ltda" }, + { "SXB", "Syntax-Brillian" }, + { "HYT", "Heng Yu Technology (HK) Limited" }, + { "TST", "Transtream Inc" }, + { "FIS", "FLY-IT Simulators" }, + { "VMW", "VMware Inc.," }, + { "PET", "Practical Electronic Tools" }, + { "BLP", "Bloomberg L.P." }, + { "MVS", "Microvision" }, + { "ZMT", "Zalman Tech Co., Ltd." }, + { "QTD", "Quantum 3D Inc" }, + { "ITE", "Integrated Tech Express Inc" }, + { "MIS", "Modular Industrial Solutions Inc" }, + { "KOB", "Kobil Systems GmbH" }, + { "KOW", "KOWA Company,LTD." }, + { "SHC", "ShibaSoku Co., Ltd." }, + { "IKS", "Ikos Systems Inc" }, + { "PGP", "propagamma kommunikation" }, + { "AYD", "Aydin Displays" }, + { "MFG", "MicroField Graphics Inc" }, + { "APS", "Autologic Inc" }, + { "APM", "Applied Memory Tech" }, + { "ACO", "Allion Computer Inc." }, + { "IWR", "Icuiti Corporation" }, + { "RCI", "RC International" }, + { "YMH", "Yamaha Corporation" }, + { "SPE", "SPEA Software AG" }, + { "ADL", "ASTRA Security Products Ltd" }, + { "QFI", "Quickflex, Inc" }, + { "FRD", "Freedom Scientific BLV" }, + { "PCM", "PCM Systems Corporation" }, + { "RHM", "Rohm Company Ltd" }, + { "EQP", "Equipe Electronics Ltd." }, + { "UND", "Unisys Corporation" }, + { "ITX", "integrated Technology Express Inc" }, + { "WML", "Wolfson Microelectronics Ltd" }, + { "IPR", "Ithaca Peripherals" }, + { "NCE", "Norcent Technology, Inc." }, + { "GWY", "Gateway 2000" }, + { "DAX", "Data Apex Ltd" }, + { "MKT", "MICROTEK Inc." }, + { "AOL", "America OnLine" }, + { "BIO", "BioLink Technologies International, Inc." }, + { "DCI", "Concepts Inc" }, + { "LOL", "Litelogic Operations Ltd" }, + { "ADI", "ADI Systems Inc" }, + { "TPJ", "Junnila" }, + { "JDL", "Japan Digital Laboratory Co.,Ltd." }, + { "MMN", "MiniMan Inc" }, + { "MNC", "Mini Micro Methods Ltd" }, + { "SUM", "Summagraphics Corporation" }, + { "SXT", "SHARP TAKAYA ELECTRONIC INDUSTRY CO.,LTD." }, + { "CAT", "Consultancy in Advanced Technology" }, + { "MSM", "Advanced Digital Systems" }, + { "CHY", "Cherry GmbH" }, + { "VLB", "ValleyBoard Ltda." }, + { "DDS", "Barco, n.v." }, + { "STL", "SigmaTel Inc" }, + { "AIE", "Altmann Industrieelektronik" }, + { "CHM", "CHIC TECHNOLOGY CORP." }, + { "KTK", "Key Tronic Corporation" }, + { "LTN", "Litronic Inc" }, + { "IDC", "International Datacasting Corporation" }, + { "TWA", "Tidewater Association" }, + { "ARI", "Argosy Research Inc" }, + { "STT", "Star Paging Telecom Tech (Shenzhen) Co. Ltd." }, + { "MYA", "Monydata" }, + { "JAE", "Japan Aviation Electronics Industry, Limited" }, + { "BBH", "B&Bh" }, + { "GIC", "General Inst. Corporation" }, + { "TIV", "OOO Technoinvest" }, + { "ION", "Inside Out Networks" }, + { "KZI", "K-Zone International co. Ltd." }, + { "IDE", "IDE Associates" }, + { "IQI", "IneoQuest Technologies, Inc" }, + { "NDI", "National Display Systems" }, + { "REL", "Reliance Electric Ind Corporation" }, + { "SPH", "G&W Instruments GmbH" }, + { "RPI", "RoomPro Technologies" }, + { "LUC", "Lucent Technologies" }, + { "CTL", "Creative Technology Ltd" }, + { "SDS", "SunRiver Data System" }, + { "USR", "U.S. Robotics Inc" }, + { "GJN", "Grand Junction Networks" }, + { "YED", "Y-E Data Inc" }, + { "RHT", "Red Hat, Inc." }, + { "AOT", "Alcatel" }, + { "TCR", "Thomson Consumer Electronics" }, + { "ILC", "Image Logic Corporation" }, + { "IGC", "Intergate Pty Ltd" }, + { "HYC", "Hypercope Gmbh Aachen" }, + { "SPL", "Smart Silicon Systems Pty Ltd" }, + { "DLC", "Diamond Lane Comm. Corporation" }, + { "TBB", "Triple S Engineering Inc" }, + { "MLS", "Milestone EPE" }, + { "QDM", "Quadram" }, + { "AIR", "Advanced Integ. Research Inc" }, + { "SLA", "Systeme Lauer GmbH&Co KG" }, + { "IBP", "IBP Instruments GmbH" }, + { "DDI", "Data Display AG" }, + { "LED", "Long Engineering Design Inc" }, + { "MSC", "Mouse Systems Corporation" }, + { "LXS", "ELEA CardWare" }, + { "ATE", "Innovate Ltd" }, + { "APV", "A+V Link" }, + { "FRC", "Force Computers" }, + { "ZTC", "ZyDAS Technology Corporation" }, + { "ANP", "Andrew Network Production" }, + { "LOG", "Logicode Technology Inc" }, + { "RAI", "Rockwell Automation/Intecolor" }, + { "MPJ", "Microlab" }, + { "CMO", "Chi Mei Optoelectronics corp." }, + { "ROH", "Rohm Co., Ltd." }, + { "HYP", "Hyphen Ltd" }, + { "ICO", "Intel Corp" }, + { "ACI", "Ancor Communications Inc" }, + { "SLT", "Salt Internatioinal Corp." }, + { "TSC", "Sanyo Electric Company Ltd" }, + { "APC", "American Power Conversion" }, + { "PSE", "Practical Solutions Pte., Ltd." }, + { "MET", "Metheus Corporation" }, + { "SAT", "Shuttle Tech" }, + { "SYK", "Stryker Communications" }, + { "BCQ", "Deutsche Telekom Berkom GmbH" }, + { "DPI", "DocuPoint" }, + { "FAR", "Farallon Computing" }, + { "ROP", "Roper International Ltd" }, + { "STB", "STB Systems Inc" }, + { "CNC", "Alvedon Computers Ltd" }, + { "DGA", "Digiital Arts Inc" }, + { "EDT", "Emerging Display Technologies Corp" }, + { "IPI", "Intelligent Platform Management Interface (IPMI) forum (Intel, HP, NEC, Dell)" }, + { "VQ@", "Vision Quest" }, + { "EMK", "Emcore Corporation" }, + { "XTD", "Icuiti Corporation" }, + { "KNX", "Nutech Marketing PTL" }, + { "WHI", "Whistle Communications" }, + { "KDM", "Korea Data Systems Co., Ltd." }, + { "QCK", "Quick Corporation" }, + { "QTR", "Qtronix Corporation" }, + { "NFS", "Number Five Software" }, + { "HTK", "Holtek Microelectronics Inc" }, + { "TRL", "Royal Information" }, + { "LXN", "Luxeon" }, + { "VLK", "Vislink International Ltd" }, + { "TWE", "Kontron Electronik" }, + { "DFI", "DFI" }, + { "JWS", "JWSpencer & Co." }, + { "FTW", "MindTribe Product Engineering, Inc." }, + { "TDM", "Tandem Computer Europe Inc" }, + { "RAS", "RAScom Inc" }, + { "KVX", "KeyView" }, + { "MOS", "Moses Corporation" }, + { "ONX", "SOMELEC Z.I. Du Vert Galanta" }, + { "STF", "Starflight Electronics" }, + { "HER", "Ascom Business Systems" }, + { "GTS", "Geotest Marvin Test Systems Inc" }, + { "KEC", "Kyushu Electronics Systems Inc" }, + { "MQP", "MultiQ Products AB" }, + { "LUX", "Luxxell Research Inc" }, + { "HEC", "Hitachi Engineering Company Ltd" }, + { "NXG", "Nexgen" }, + { "CNI", "Connect Int'l A/S" }, + { "FUJ", "Fujitsu Ltd" }, + { "APD", "AppliAdata" }, + { "LHE", "Lung Hwa Electronics Company Ltd" }, + { "SCT", "Smart Card Technology" }, + { "SOY", "SOYO Group, Inc" }, + { "ICN", "Sanyo Icon" }, + { "TDV", "TDVision Systems, Inc." }, + { "AHC", "Advantech Co., Ltd." }, + { "GTK", "G-Tech Corporation" }, + { "BII", "Boeckeler Instruments Inc" }, + { "TCC", "Tandon Corporation" }, + { "BUJ", "ATI Tech Inc" }, + { "SAA", "Sanritz Automation Co.,Ltd." }, + { "DTK", "Dynax Electronics (HK) Ltd" }, + { "HXM", "Hexium Ltd." }, + { "EGD", "EIZO GmbH Display Technologies" }, + { "NDK", "Naitoh Densei CO., LTD." }, + { "TVR", "TV Interactive Corporation" }, + { "PNL", "Panelview, Inc." }, + { "AET", "Aethra Telecomunicazioni S.r.l." }, + { "REC", "ReCom" }, + { "HET", "HETEC Datensysteme GmbH" }, + { "ZOW", "Zowie Intertainment, Inc" }, + { "MEQ", "Matelect Ltd." }, + { "DRD", "DIGITAL REFLECTION INC." }, + { "MRA", "Miranda Technologies Inc" }, + { "QTM", "Quantum" }, + { "REN", "Renesas Technology Corp." }, + { "XIO", "Xiotech Corporation" }, + { "GIS", "AT&T Global Info Solutions" }, + { "TEA", "TEAC System Corporation" }, + { "EMU", "Emulex Corporation" }, + { "VIC", "Victron B.V." }, + { "ATN", "Athena Smartcard Solutions Ltd." }, + { "SYS", "Sysgration Ltd" }, + { "CVS", "Clarity Visual Systems" }, + { "CWR", "Connectware Inc" }, + { "TVI", "Truevision" }, + { "AMB", "Ambient Technologies, Inc." }, + { "USA", "Utimaco Safeware AG" }, + { "LNT", "LANETCO International" }, + { "EDG", "Electronic-Design GmbH" }, + { "MKV", "Trtheim Technology" }, + { "SGT", "Stargate Technology" }, + { "RTS", "Raintree Systems" }, + { "PXM", "Proxim Inc" }, + { "ACG", "A&R Cambridge Ltd" }, + { "FJT", "F.J. Tieman BV" }, + { "LCD", "Toshiba Matsushita Display Technology Co., Ltd" }, + { "IDS", "Interdigital Sistemas de Informacao" }, + { "AOA", "AOpen Inc." }, + { "ACR", "Acer Technologies" }, + { "AKL", "AMiT Ltd" }, + { "IOS", "i-O Display System" }, + { "NOR", "Norand Corporation" }, + { "XST", "XS Technologies Inc" }, + { "BUG", "B.U.G., Inc." }, + { "RCN", "Radio Consult SRL" }, + { "ESI", "Extended Systems, Inc." }, + { "TUT", "Tut Systems" }, + { "VAR", "Varian Australia Pty Ltd" }, + { "DIT", "Dragon Information Technology" }, + { "CET", "TEC CORPORATION" }, + { "WKH", "Uni-Take Int'l Inc." }, + { "BHZ", "BitHeadz, Inc." }, + { "PTI", "Promise Technology Inc" }, + { "HIQ", "Kaohsiung Opto Electronics Americas, Inc." }, + { "SET", "SendTek Corporation" }, + { "KCL", "Keycorp Ltd" }, + { "EIC", "Eicon Technology Corporation" }, + { "TRT", "Tritec Electronic AG" }, + { "ZAN", "Zandar Technologies plc" }, + { "NTN", "Nuvoton Technology Corporation" }, + { "MTC", "Mars-Tech Corporation" }, + { "JQE", "CNet Technical Inc" }, + { "SRG", "Intuitive Surgical, Inc." }, + { "VIR", "Visual Interface, Inc" }, + { "HTX", "Hitex Systementwicklung GmbH" }, + { "TLX", "Telxon Corporation" }, + { "NGC", "Network General" }, + { "TSB", "Toshiba America Info Systems Inc" }, + { "SGI", "Scan Group Ltd" }, + { "AIS", "Alien Internet Services" }, + { "MUD", "Multi-Dimension Institute" }, + { "PNS", "PanaScope" }, + { "NEO", "NEO TELECOM CO.,LTD." }, + { "IMB", "ART s.r.l." }, + { "SRD", "Setred" }, + { "LEX", "Lexical Ltd" }, + { "LMI", "Lexmark Int'l Inc" }, + { "ECL", "Excel Company Ltd" }, + { "EXC", "Excession Audio" }, + { "ABA", "ABBAHOME INC." }, + { "CLI", "Cirrus Logic Inc" }, + { "DYM", "Dymo-CoStar Corporation" }, + { "MEL", "Mitsubishi Electric Corporation" }, + { "ZAX", "Zefiro Acoustics" }, + { "TEC", "Tecmar Inc" }, + { "WTI", "WorkStation Tech" }, + { "APX", "AP Designs Ltd" }, + { "MLM", "Millennium Engineering Inc" }, + { "BAC", "Biometric Access Corporation" }, + { "DDE", "Datasat Digital Entertainment" }, + { "GIM", "Guillemont International" }, + { "TVM", "Taiwan Video & Monitor Corporation" }, + { "KWD", "Kenwood Corporation" }, + { "STW", "Starwin Inc." }, + { "NRV", "Taugagreining hf" }, + { "SUP", "Supra Corporation" }, + { "MTB", "Media Technologies Ltd." }, + { "INF", "Inframetrics Inc" }, + { "OTM", "Optoma Corporation" }, + { "NTX", "Netaccess Inc" }, + { "LXC", "LXCO Technologies AG" }, + { "CRN", "Cornerstone Imaging" }, + { "PVP", "Klos Technologies, Inc." }, + { "TCJ", "TEAC America Inc" }, + { "WVM", "Wave Systems Corporation" }, + { "ERN", "Ericsson, Inc." }, + { "PVN", "Pixel Vision" }, + { "LMT", "Laser Master" }, + { "MID", "miro Displays" }, + { "VID", "Ingram Macrotron Germany" }, + { "IFZ", "Infinite Z" }, + { "ODM", "ODME Inc." }, + { "ASI", "Ahead Systems" }, + { "ISY", "International Integrated Systems,Inc.(IISI)" }, + { "NCL", "NetComm Ltd" }, + { "ITK", "ITK Telekommunikation AG" }, + { "EZE", "EzE Technologies" }, + { "VSR", "V-Star Electronics Inc." }, + { "CPC", "Ciprico Inc" }, + { "JWD", "Video International Inc." }, + { "MEC", "Mega System Technologies Inc" }, + { "NVI", "NuVision US, Inc." }, + { "MRK", "Maruko & Company Ltd" }, + { "AAA", "Avolites Ltd" }, + { "CHG", "Sichuan Changhong Electric CO, LTD." }, + { "WWV", "World Wide Video, Inc." }, + { "SEO", "SEOS Ltd" }, + { "XER", "DO NOT USE - XER" }, + { "MCN", "Micron Electronics Inc" }, + { "DXC", "Digipronix Control Systems" }, + { "RSN", "Radiospire Networks, Inc." }, + { "FGD", "Lisa Draexlmaier GmbH" }, + { "SES", "Session Control LLC" }, + { "IIN", "IINFRA Co., Ltd" }, + { "ETI", "Eclipse Tech Inc" }, + { "DXD", "DECIMATOR DESIGN PTY LTD" }, + { "BST", "BodySound Technologies, Inc." }, + { "MTL", "Mitel Corporation" }, + { "LGX", "Lasergraphics, Inc." }, + { "MSP", "Mistral Solutions [P] Ltd." }, + { "SER", "Sony Ericsson Mobile Communications Inc." }, + { "IHE", "InHand Electronics" }, + { "STO", "Stollmann E+V GmbH" }, + { "RET", "Resonance Technology, Inc." }, + { "PXE", "PIXELA CORPORATION" }, + { "USI", "Universal Scientific Industrial Co., Ltd." }, + { "JAC", "Astec Inc" }, + { "WAC", "Wacom Tech" }, + { "BUF", "Yasuhiko Shirai Melco Inc" }, + { "LSI", "Loughborough Sound Images" }, + { "AMA", "Asia Microelectronic Development Inc" }, + { "DJP", "Maygay Machines, Ltd" }, + { "CAN", "CORNEA" }, + { "UMM", "Universal Multimedia" }, + { "ECI", "Enciris Technologies" }, + { "DDT", "Datadesk Technologies Inc" }, + { "MLG", "Micrologica AG" }, + { "NCA", "Nixdorf Company" }, + { "ENS", "Ensoniq Corporation" }, + { "MOT", "Motorola UDS" }, + { "WCI", "Wisecom Inc" }, + { "MXT", "Maxtech Corporation" }, + { "EHJ", "Epson Research" }, + { "KUR", "Kurta Corporation" }, + { "DFT", "DEI Holdings dba Definitive Technology" }, + { "NAD", "NAD Electronics" }, + { "GMK", "GMK Electronic Design GmbH" }, + { "TAI", "Toshiba America Info Systems Inc" }, + { "SNP", "Siemens Nixdorf Info Systems" }, + { "KFE", "Komatsu Forest" }, + { "PPD", "MEPhI" }, + { "UMG", "Umezawa Giken Co.,Ltd" }, + { "PMC", "PMC Consumer Electronics Ltd" }, + { "KIS", "KiSS Technology A/S" }, + { "ABV", "Advanced Research Technology" }, + { "ISA", "Symbol Technologies" }, + { "GMN", "GEMINI 2000 Ltd" }, + { "VSI", "VideoServer" }, + { "DTO", "Deutsche Thomson OHG" }, + { "OCN", "Olfan" }, + { "LTK", "Lucidity Technology Company Ltd" }, + { "CLX", "CardLogix" }, + { "TPT", "Thruput Ltd" }, + { "IXD", "Intertex Data AB" }, + { "ICX", "ICCC A/S" }, + { "REF", "Reflectivity, Inc." }, + { "CDK", "Cray Communications" }, + { "PNX", "Phoenix Technologies, Ltd." }, + { "MCT", "Microtec" }, + { "ESD", "Ensemble Designs, Inc" }, + { "CTS", "Comtec Systems Co., Ltd." }, + { "ADB", "Aldebbaron" }, + { "AML", "Anderson Multimedia Communications (HK) Limited" }, + { "FIN", "Finecom Co., Ltd." }, + { "NCC", "NCR Corporation" }, + { "ONS", "On Systems Inc" }, + { "CGA", "Chunghwa Picture Tubes, LTD" }, + { "NTC", "NeoTech S.R.L" }, + { "AMD", "Amdek Corporation" }, + { "WVV", "WolfVision GmbH" }, + { "PHO", "Photonics Systems Inc." }, + { "AVX", "AVerMedia Technologies, Inc." }, + { "SJE", "Sejin Electron Inc" }, + { "BCM", "Broadcom" }, + { "RLN", "RadioLAN Inc" }, + { "CAM", "Cambridge Audio" }, + { "TCS", "Tatung Company of America Inc" }, + { "RIO", "Rios Systems Company Ltd" }, + { "SWT", "Software Technologies Group,Inc." }, + { "BSL", "Biomedical Systems Laboratory" }, + { "DCV", "Datatronics Technology Inc" }, + { "JPC", "JPC Technology Limited" }, + { "ICC", "BICC Data Networks Ltd" }, + { "CEI", "Crestron Electronics, Inc." }, + { "NUI", "NU Inc." }, + { "MAE", "Maestro Pty Ltd" }, + { "AYR", "Airlib, Inc" }, + { "TPS", "Teleprocessing Systeme GmbH" }, + { "SMK", "SMK CORPORATION" }, + { "IAT", "IAT Germany GmbH" }, + { "BNO", "Bang & Olufsen" }, + { "KRY", "Kroy LLC" }, + { "OLT", "Olitec S.A." }, + { "ABC", "AboCom System Inc" }, + { "FXX", "Fuji Xerox" }, + { "ANI", "Anigma Inc" }, + { "OEI", "Optum Engineering Inc." }, + { "TPE", "Technology Power Enterprises Inc" }, + { "RDI", "Rainbow Displays, Inc." }, + { "KDK", "Kodiak Tech" }, + { "LHT", "Lighthouse Technologies Limited" }, + { "BEK", "Beko Elektronik A.S." }, + { "LND", "Land Computer Company Ltd" }, + { "CDC", "Core Dynamics Corporation" }, + { "FHL", "FHLP" }, + { "UNP", "Unitop" }, + { "MSR", "MASPRO DENKOH Corp." }, + { "MKC", "Media Tek Inc." }, + { "BCD", "Barco GmbH" }, + { "PQI", "Pixel Qi" }, + { "ALD", "In4S Inc" }, + { "HTC", "Hitachi Ltd" }, + { "OCD", "Macraigor Systems Inc" }, + { "PHY", "Phylon Communications" }, + { "MSF", "M-Systems Flash Disk Pioneers" }, + { "ETK", "eTEK Labs Inc." }, + { "DVS", "Digital Video System" }, + { "ACU", "Acculogic" }, + { "YOW", "American Biometric Company" }, + { "MGE", "Schneider Electric S.A." }, + { "AKP", "Atom Komplex Prylad" }, + { "PGI", "PACSGEAR, Inc." }, + { "III", "Intelligent Instrumentation" }, + { "BML", "BIOMED Lab" }, + { "KMC", "Mitsumi Company Ltd" }, + { "RSQ", "R Squared" }, + { "SBC", "Shanghai Bell Telephone Equip Mfg Co" }, + { "FPX", "Cirel Systemes" }, + { "IDN", "Idneo Technologies" }, + { "BNE", "Bull AB" }, +}; + +QT_END_NAMESPACE + +#endif // QEDIDVENDORTABLE_P_H diff --git a/src/platformsupport/eglconvenience/qeglpbuffer_p.h b/src/platformsupport/eglconvenience/qeglpbuffer_p.h index 76233967e7..0285e067a6 100644 --- a/src/platformsupport/eglconvenience/qeglpbuffer_p.h +++ b/src/platformsupport/eglconvenience/qeglpbuffer_p.h @@ -63,8 +63,8 @@ public: QEGLPlatformContext::Flags flags = 0); ~QEGLPbuffer(); - QSurfaceFormat format() const Q_DECL_OVERRIDE { return m_format; } - bool isValid() const Q_DECL_OVERRIDE; + QSurfaceFormat format() const override { return m_format; } + bool isValid() const override; EGLSurface pbuffer() const { return m_pbuffer; } diff --git a/src/platformsupport/eglconvenience/qeglplatformcontext_p.h b/src/platformsupport/eglconvenience/qeglplatformcontext_p.h index 9d41eecd99..d6cbbe4131 100644 --- a/src/platformsupport/eglconvenience/qeglplatformcontext_p.h +++ b/src/platformsupport/eglconvenience/qeglplatformcontext_p.h @@ -72,15 +72,15 @@ public: Flags flags = 0); ~QEGLPlatformContext(); - void initialize() Q_DECL_OVERRIDE; - bool makeCurrent(QPlatformSurface *surface) Q_DECL_OVERRIDE; - void doneCurrent() Q_DECL_OVERRIDE; - void swapBuffers(QPlatformSurface *surface) Q_DECL_OVERRIDE; - QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE; + void initialize() override; + bool makeCurrent(QPlatformSurface *surface) override; + void doneCurrent() override; + void swapBuffers(QPlatformSurface *surface) override; + QFunctionPointer getProcAddress(const char *procName) override; - QSurfaceFormat format() const Q_DECL_OVERRIDE; - bool isSharing() const Q_DECL_OVERRIDE { return m_shareContext != EGL_NO_CONTEXT; } - bool isValid() const Q_DECL_OVERRIDE { return m_eglContext != EGL_NO_CONTEXT; } + QSurfaceFormat format() const override; + bool isSharing() const override { return m_shareContext != EGL_NO_CONTEXT; } + bool isValid() const override { return m_eglContext != EGL_NO_CONTEXT; } EGLContext eglContext() const; EGLDisplay eglDisplay() const; diff --git a/src/platformsupport/eventdispatchers/qeventdispatcher_glib.cpp b/src/platformsupport/eventdispatchers/qeventdispatcher_glib.cpp index dc4785071f..06f0aa6747 100644 --- a/src/platformsupport/eventdispatchers/qeventdispatcher_glib.cpp +++ b/src/platformsupport/eventdispatchers/qeventdispatcher_glib.cpp @@ -48,78 +48,26 @@ QT_BEGIN_NAMESPACE -struct GUserEventSource -{ - GSource source; - QPAEventDispatcherGlib *q; -}; - -static gboolean userEventSourcePrepare(GSource *source, gint *timeout) -{ - Q_UNUSED(timeout) - GUserEventSource *userEventSource = reinterpret_cast<GUserEventSource *>(source); - QPAEventDispatcherGlib *dispatcher = userEventSource->q; - if (dispatcher->m_flags & QEventLoop::ExcludeUserInputEvents) - return QWindowSystemInterface::nonUserInputEventsQueued(); - else - return QWindowSystemInterface::windowSystemEventsQueued() > 0; -} - -static gboolean userEventSourceCheck(GSource *source) -{ - return userEventSourcePrepare(source, 0); -} - -static gboolean userEventSourceDispatch(GSource *source, GSourceFunc, gpointer) -{ - GUserEventSource *userEventSource = reinterpret_cast<GUserEventSource *>(source); - QPAEventDispatcherGlib *dispatcher = userEventSource->q; - QWindowSystemInterface::sendWindowSystemEvents(dispatcher->m_flags); - return true; -} - -static GSourceFuncs userEventSourceFuncs = { - userEventSourcePrepare, - userEventSourceCheck, - userEventSourceDispatch, - NULL, - NULL, - NULL -}; - QPAEventDispatcherGlibPrivate::QPAEventDispatcherGlibPrivate(GMainContext *context) : QEventDispatcherGlibPrivate(context) { - Q_Q(QPAEventDispatcherGlib); - userEventSource = reinterpret_cast<GUserEventSource *>(g_source_new(&userEventSourceFuncs, - sizeof(GUserEventSource))); - userEventSource->q = q; - g_source_set_can_recurse(&userEventSource->source, true); - g_source_attach(&userEventSource->source, mainContext); } - QPAEventDispatcherGlib::QPAEventDispatcherGlib(QObject *parent) : QEventDispatcherGlib(*new QPAEventDispatcherGlibPrivate, parent) , m_flags(QEventLoop::AllEvents) { - Q_D(QPAEventDispatcherGlib); - d->userEventSource->q = this; } QPAEventDispatcherGlib::~QPAEventDispatcherGlib() { - Q_D(QPAEventDispatcherGlib); - - g_source_destroy(&d->userEventSource->source); - g_source_unref(&d->userEventSource->source); - d->userEventSource = 0; } bool QPAEventDispatcherGlib::processEvents(QEventLoop::ProcessEventsFlags flags) { m_flags = flags; - return QEventDispatcherGlib::processEvents(m_flags); + const bool didSendEvents = QEventDispatcherGlib::processEvents(m_flags); + return QWindowSystemInterface::sendWindowSystemEvents(m_flags) || didSendEvents; } QT_END_NAMESPACE diff --git a/src/platformsupport/eventdispatchers/qeventdispatcher_glib_p.h b/src/platformsupport/eventdispatchers/qeventdispatcher_glib_p.h index 6d148753bf..5930dc68e7 100644 --- a/src/platformsupport/eventdispatchers/qeventdispatcher_glib_p.h +++ b/src/platformsupport/eventdispatchers/qeventdispatcher_glib_p.h @@ -67,18 +67,15 @@ public: explicit QPAEventDispatcherGlib(QObject *parent = 0); ~QPAEventDispatcherGlib(); - bool processEvents(QEventLoop::ProcessEventsFlags flags) Q_DECL_OVERRIDE; + bool processEvents(QEventLoop::ProcessEventsFlags flags) override; QEventLoop::ProcessEventsFlags m_flags; }; -struct GUserEventSource; - class QPAEventDispatcherGlibPrivate : public QEventDispatcherGlibPrivate { Q_DECLARE_PUBLIC(QPAEventDispatcherGlib) public: QPAEventDispatcherGlibPrivate(GMainContext *context = 0); - GUserEventSource *userEventSource; }; diff --git a/src/platformsupport/eventdispatchers/qwindowsguieventdispatcher_p.h b/src/platformsupport/eventdispatchers/qwindowsguieventdispatcher_p.h index 9a23b5c0bd..4ff047a60e 100644 --- a/src/platformsupport/eventdispatchers/qwindowsguieventdispatcher_p.h +++ b/src/platformsupport/eventdispatchers/qwindowsguieventdispatcher_p.h @@ -63,8 +63,8 @@ public: static const char *windowsMessageName(UINT msg); - bool QT_ENSURE_STACK_ALIGNED_FOR_SSE processEvents(QEventLoop::ProcessEventsFlags flags) Q_DECL_OVERRIDE; - void sendPostedEvents() Q_DECL_OVERRIDE; + bool QT_ENSURE_STACK_ALIGNED_FOR_SSE processEvents(QEventLoop::ProcessEventsFlags flags) override; + void sendPostedEvents() override; private: QEventLoop::ProcessEventsFlags m_flags; diff --git a/src/platformsupport/fbconvenience/qfbbackingstore.cpp b/src/platformsupport/fbconvenience/qfbbackingstore.cpp index 2cad3441e4..e2d94406a4 100644 --- a/src/platformsupport/fbconvenience/qfbbackingstore.cpp +++ b/src/platformsupport/fbconvenience/qfbbackingstore.cpp @@ -104,9 +104,8 @@ void QFbBackingStore::beginPaint(const QRegion ®ion) if (mImage.hasAlphaChannel()) { QPainter p(&mImage); p.setCompositionMode(QPainter::CompositionMode_Source); - const QVector<QRect> rects = region.rects(); - for (QVector<QRect>::const_iterator it = rects.begin(); it != rects.end(); ++it) - p.fillRect(*it, Qt::transparent); + for (const QRect &r : region) + p.fillRect(r, Qt::transparent); } } diff --git a/src/platformsupport/fbconvenience/qfbbackingstore_p.h b/src/platformsupport/fbconvenience/qfbbackingstore_p.h index c8dfe3489c..c4762c9327 100644 --- a/src/platformsupport/fbconvenience/qfbbackingstore_p.h +++ b/src/platformsupport/fbconvenience/qfbbackingstore_p.h @@ -66,10 +66,10 @@ public: QFbBackingStore(QWindow *window); ~QFbBackingStore(); - QPaintDevice *paintDevice() Q_DECL_OVERRIDE { return &mImage; } - void flush(QWindow *window, const QRegion ®ion, const QPoint &offset) Q_DECL_OVERRIDE; + QPaintDevice *paintDevice() override { return &mImage; } + void flush(QWindow *window, const QRegion ®ion, const QPoint &offset) override; - void resize(const QSize &size, const QRegion ®ion) Q_DECL_OVERRIDE; + void resize(const QSize &size, const QRegion ®ion) override; const QImage image(); QImage toImage() const override; @@ -77,8 +77,8 @@ public: void lock(); void unlock(); - void beginPaint(const QRegion &) Q_DECL_OVERRIDE; - void endPaint() Q_DECL_OVERRIDE; + void beginPaint(const QRegion &) override; + void endPaint() override; protected: friend class QFbWindow; diff --git a/src/platformsupport/fbconvenience/qfbscreen.cpp b/src/platformsupport/fbconvenience/qfbscreen.cpp index 2b4498157c..c42fd879f8 100644 --- a/src/platformsupport/fbconvenience/qfbscreen.cpp +++ b/src/platformsupport/fbconvenience/qfbscreen.cpp @@ -210,10 +210,9 @@ QRegion QFbScreen::doRedraw() if (!mPainter) mPainter = new QPainter(&mScreenImage); - const QVector<QRect> rects = mRepaintRegion.rects(); const QRect screenRect = mGeometry.translated(-screenOffset); - for (int rectIndex = 0; rectIndex < mRepaintRegion.rectCount(); rectIndex++) { - const QRect rect = rects[rectIndex].intersected(screenRect); + for (QRect rect : mRepaintRegion) { + rect = rect.intersected(screenRect); if (rect.isEmpty()) continue; diff --git a/src/platformsupport/fbconvenience/qfbscreen_p.h b/src/platformsupport/fbconvenience/qfbscreen_p.h index 1c27a941cc..eed615de36 100644 --- a/src/platformsupport/fbconvenience/qfbscreen_p.h +++ b/src/platformsupport/fbconvenience/qfbscreen_p.h @@ -78,14 +78,14 @@ public: virtual bool initialize(); - QRect geometry() const Q_DECL_OVERRIDE { return mGeometry; } - int depth() const Q_DECL_OVERRIDE { return mDepth; } - QImage::Format format() const Q_DECL_OVERRIDE { return mFormat; } - QSizeF physicalSize() const Q_DECL_OVERRIDE { return mPhysicalSize; } - QPlatformCursor *cursor() const Q_DECL_OVERRIDE { return mCursor; } + QRect geometry() const override { return mGeometry; } + int depth() const override { return mDepth; } + QImage::Format format() const override { return mFormat; } + QSizeF physicalSize() const override { return mPhysicalSize; } + QPlatformCursor *cursor() const override { return mCursor; } QWindow *topWindow() const; - QWindow *topLevelAt(const QPoint & p) const Q_DECL_OVERRIDE; + QWindow *topLevelAt(const QPoint & p) const override; // compositor api virtual void addWindow(QFbWindow *window); @@ -109,7 +109,7 @@ protected: virtual QRegion doRedraw(); void initializeCompositor(); - bool event(QEvent *event) Q_DECL_OVERRIDE; + bool event(QEvent *event) override; QFbWindow *windowForId(WId wid) const; diff --git a/src/platformsupport/fbconvenience/qfbwindow.cpp b/src/platformsupport/fbconvenience/qfbwindow.cpp index 7e016f2f49..36f92b8cea 100644 --- a/src/platformsupport/fbconvenience/qfbwindow.cpp +++ b/src/platformsupport/fbconvenience/qfbwindow.cpp @@ -106,7 +106,7 @@ void QFbWindow::setVisible(bool visible) } } -void QFbWindow::setWindowState(Qt::WindowState state) +void QFbWindow::setWindowState(Qt::WindowStates state) { QPlatformWindow::setWindowState(state); mWindowState = state; diff --git a/src/platformsupport/fbconvenience/qfbwindow_p.h b/src/platformsupport/fbconvenience/qfbwindow_p.h index c201302a50..76b34ce041 100644 --- a/src/platformsupport/fbconvenience/qfbwindow_p.h +++ b/src/platformsupport/fbconvenience/qfbwindow_p.h @@ -64,17 +64,17 @@ public: QFbWindow(QWindow *window); ~QFbWindow(); - void raise() Q_DECL_OVERRIDE; - void lower() Q_DECL_OVERRIDE; + void raise() override; + void lower() override; - void setGeometry(const QRect &rect) Q_DECL_OVERRIDE; - void setVisible(bool visible) Q_DECL_OVERRIDE; + void setGeometry(const QRect &rect) override; + void setVisible(bool visible) override; - void setWindowState(Qt::WindowState state) Q_DECL_OVERRIDE; - void setWindowFlags(Qt::WindowFlags type) Q_DECL_OVERRIDE; + void setWindowState(Qt::WindowStates state) override; + void setWindowFlags(Qt::WindowFlags type) override; Qt::WindowFlags windowFlags() const; - WId winId() const Q_DECL_OVERRIDE { return mWindowId; } + WId winId() const override { return mWindowId; } void setBackingStore(QFbBackingStore *store) { mBackingStore = store; } QFbBackingStore *backingStore() const { return mBackingStore; } @@ -83,9 +83,9 @@ public: virtual void repaint(const QRegion&); - void propagateSizeHints() Q_DECL_OVERRIDE { } - bool setKeyboardGrabEnabled(bool) Q_DECL_OVERRIDE { return false; } - bool setMouseGrabEnabled(bool) Q_DECL_OVERRIDE { return false; } + void propagateSizeHints() override { } + bool setKeyboardGrabEnabled(bool) override { return false; } + bool setMouseGrabEnabled(bool) override { return false; } protected: friend class QFbScreen; @@ -93,7 +93,7 @@ protected: QFbBackingStore *mBackingStore; QRect mOldGeometry; Qt::WindowFlags mWindowFlags; - Qt::WindowState mWindowState; + Qt::WindowStates mWindowState; WId mWindowId; }; diff --git a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp index 969a9c17e0..aa8f9a892a 100644 --- a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp +++ b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp @@ -250,7 +250,17 @@ static const char specialLanguages[][6] = { "", // Hatran "", // Multani "", // OldHungarian - "" // SignWriting + "", // SignWriting + "", // Adlam + "", // Bhaiksuki + "", // Marchen + "", // Newa + "", // Osage + "", // Tangut + "", // MasaramGondi + "", // Nushu + "", // Soyombo + "" // ZanabazarSquare }; Q_STATIC_ASSERT(sizeof specialLanguages / sizeof *specialLanguages == QChar::ScriptCount); @@ -428,7 +438,7 @@ static void populateFromPattern(FcPattern *pattern) if (res == FcResultMatch) { bool hasLang = false; #if FC_VERSION >= 20297 - FcChar8 *cap = Q_NULLPTR; + FcChar8 *cap = nullptr; FcResult capRes = FcResultNoMatch; #endif for (int j = 1; j < QFontDatabase::WritingSystemsCount; ++j) { @@ -438,7 +448,7 @@ static void populateFromPattern(FcPattern *pattern) if (langRes != FcLangDifferentLang) { #if FC_VERSION >= 20297 if (*capabilityForWritingSystem[j] && requiresOpenType(j)) { - if (cap == Q_NULLPTR) + if (cap == nullptr) capRes = FcPatternGetString(pattern, FC_CAPABILITY, 0, &cap); if (capRes == FcResultMatch && strstr(reinterpret_cast<const char *>(cap), capabilityForWritingSystem[j]) == 0) continue; @@ -905,7 +915,7 @@ void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef if (services) { const QList<QByteArray> desktopEnv = services->desktopEnvironment().split(':'); - useXftConf = desktopEnv.contains("GNOME") || desktopEnv.contains("UNITY"); + useXftConf = desktopEnv.contains("GNOME") || desktopEnv.contains("UNITY") || desktopEnv.contains("XFCE"); } if (useXftConf && !forcedAntialiasSetting) { diff --git a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase_p.h b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase_p.h index 6a3261de30..a7257c2f98 100644 --- a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase_p.h +++ b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase_p.h @@ -61,15 +61,15 @@ class QFontEngineFT; class QFontconfigDatabase : public QFreeTypeFontDatabase { public: - void populateFontDatabase() Q_DECL_OVERRIDE; - void invalidate() Q_DECL_OVERRIDE; - QFontEngineMulti *fontEngineMulti(QFontEngine *fontEngine, QChar::Script script) Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) Q_DECL_OVERRIDE; - QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const Q_DECL_OVERRIDE; - QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) Q_DECL_OVERRIDE; - QString resolveFontFamilyAlias(const QString &family) const Q_DECL_OVERRIDE; - QFont defaultFont() const Q_DECL_OVERRIDE; + void populateFontDatabase() override; + void invalidate() override; + QFontEngineMulti *fontEngineMulti(QFontEngine *fontEngine, QChar::Script script) override; + QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; + QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; + QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const override; + QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) override; + QString resolveFontFamilyAlias(const QString &family) const override; + QFont defaultFont() const override; private: void setupFontEngine(QFontEngineFT *engine, const QFontDef &fontDef) const; diff --git a/src/platformsupport/fontdatabases/fontconfig/qfontenginemultifontconfig_p.h b/src/platformsupport/fontdatabases/fontconfig/qfontenginemultifontconfig_p.h index 1d2f451722..7f560c2d05 100644 --- a/src/platformsupport/fontdatabases/fontconfig/qfontenginemultifontconfig_p.h +++ b/src/platformsupport/fontdatabases/fontconfig/qfontenginemultifontconfig_p.h @@ -63,7 +63,7 @@ public: ~QFontEngineMultiFontConfig(); - bool shouldLoadFontEngineForCharacter(int at, uint ucs4) const Q_DECL_OVERRIDE; + bool shouldLoadFontEngineForCharacter(int at, uint ucs4) const override; private: FcPattern* getMatchPatternForFallback(int at) const; diff --git a/src/platformsupport/fontdatabases/fontdatabases.pro b/src/platformsupport/fontdatabases/fontdatabases.pro index d2726d08a0..f2bac9ab94 100644 --- a/src/platformsupport/fontdatabases/fontdatabases.pro +++ b/src/platformsupport/fontdatabases/fontdatabases.pro @@ -9,25 +9,25 @@ PRECOMPILED_HEADER = ../../corelib/global/qt_pch.h darwin { include($$PWD/mac/coretext.pri) -} else { - qtConfig(freetype) { - include($$PWD/freetype/freetype.pri) - } +} - unix { - include($$PWD/genericunix/genericunix.pri) - qtConfig(fontconfig) { - include($$PWD/fontconfig/fontconfig.pri) - } - } +qtConfig(freetype) { + include($$PWD/freetype/freetype.pri) +} - win32:!winrt { - include($$PWD/windows/windows.pri) +unix { + include($$PWD/genericunix/genericunix.pri) + qtConfig(fontconfig) { + include($$PWD/fontconfig/fontconfig.pri) } +} - winrt { - include($$PWD/winrt/winrt.pri) - } +win32:!winrt { + include($$PWD/windows/windows.pri) +} + +winrt { + include($$PWD/winrt/winrt.pri) } load(qt_module) diff --git a/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp b/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp index 3f543755b6..cc0246b64a 100644 --- a/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp +++ b/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp @@ -66,11 +66,7 @@ #include FT_TYPE1_TABLES_H #include FT_GLYPH_H #include FT_MODULE_H - -#if defined(FT_LCD_FILTER_H) #include FT_LCD_FILTER_H -#define QT_USE_FREETYPE_LCDFILTER -#endif #if defined(FT_CONFIG_OPTIONS_H) #include FT_CONFIG_OPTIONS_H @@ -125,12 +121,13 @@ class QtFreetypeData { public: QtFreetypeData() - : library(0) + : library(0), hasPatentFreeLcdRendering(false) { } ~QtFreetypeData(); FT_Library library; QHash<QFontEngine::FaceId, QFreetypeFace *> faces; + bool hasPatentFreeLcdRendering; }; QtFreetypeData::~QtFreetypeData() @@ -164,6 +161,11 @@ QtFreetypeData *qt_getFreetypeData() FT_Bool no_darkening = false; FT_Property_Set(freetypeData->library, "cff", "no-stem-darkening", &no_darkening); #endif + // FreeType has since 2.8.1 a patent free alternative to LCD-filtering. + FT_Int amajor, aminor = 0, apatch = 0; + FT_Library_Version(freetypeData->library, &amajor, &aminor, &apatch); + if (QT_VERSION_CHECK(amajor, aminor, apatch) >= QT_VERSION_CHECK(2, 8, 1)) + freetypeData->hasPatentFreeLcdRendering = true; } return freetypeData; } @@ -775,10 +777,7 @@ QFontEngineFT::QFontEngineFT(const QFontDef &fd) default_load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH; default_hint_style = ftInitialDefaultHintStyle; subpixelType = Subpixel_None; - lcdFilterType = 0; -#if defined(FT_LCD_FILTER_H) lcdFilterType = (int)((quintptr) FT_LCD_FILTER_DEFAULT); -#endif defaultFormat = Format_None; embeddedbitmap = false; const QByteArray env = qgetenv("QT_NO_FT_CACHE"); @@ -1163,14 +1162,14 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph, int glyph_buffer_size = 0; QScopedArrayPointer<uchar> glyph_buffer; -#if defined(QT_USE_FREETYPE_LCDFILTER) bool useFreetypeRenderGlyph = false; if (slot->format == FT_GLYPH_FORMAT_OUTLINE && (hsubpixel || vfactor != 1)) { err = FT_Library_SetLcdFilter(slot->library, (FT_LcdFilter)lcdFilterType); - if (err == FT_Err_Ok) + // We use FT_Render_Glyph if freetype has support for lcd-filtering + // or is version 2.8.1 or higher and can do without. + if (err == FT_Err_Ok || qt_getFreetypeData()->hasPatentFreeLcdRendering) useFreetypeRenderGlyph = true; } - if (useFreetypeRenderGlyph) { err = FT_Render_Glyph(slot, hsubpixel ? FT_RENDER_MODE_LCD : FT_RENDER_MODE_LCD_V); @@ -1191,9 +1190,7 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph, convertRGBToARGB(slot->bitmap.buffer, (uint *)glyph_buffer.data(), info.width, info.height, slot->bitmap.pitch, subpixelType != Subpixel_RGB, false); else if (vfactor != 1) convertRGBToARGB_V(slot->bitmap.buffer, (uint *)glyph_buffer.data(), info.width, info.height, slot->bitmap.pitch, subpixelType != Subpixel_VRGB, false); - } else -#endif - { + } else { int left = slot->metrics.horiBearingX; int right = slot->metrics.horiBearingX + slot->metrics.width; int top = slot->metrics.horiBearingY; @@ -1260,9 +1257,7 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph, Q_ASSERT(antialias); uchar *convoluted = new uchar[bitmap_buffer_size]; bool useLegacyLcdFilter = false; -#if defined(FC_LCD_FILTER) && defined(FT_LCD_FILTER_H) useLegacyLcdFilter = (lcdFilterType == FT_LCD_FILTER_LEGACY); -#endif uchar *buffer = bitmap.buffer; if (!useLegacyLcdFilter) { convoluteBitmap(bitmap.buffer, convoluted, bitmap.width, info.height, bitmap.pitch); @@ -1540,7 +1535,7 @@ QFontEngineFT::QGlyphSet *QFontEngineFT::loadGlyphSet(const QTransform &matrix) // FT_Set_Transform only supports scalable fonts if (!FT_IS_SCALABLE(freetype->face)) - return matrix.type() <= QTransform::TxTranslate ? &defaultGlyphSet : Q_NULLPTR; + return matrix.type() <= QTransform::TxTranslate ? &defaultGlyphSet : nullptr; FT_Matrix m = QTransformToFTMatrix(matrix); @@ -1972,7 +1967,7 @@ glyph_metrics_t QFontEngineFT::alphaMapBoundingBox(glyph_t glyph, QFixed subPixe static inline QImage alphaMapFromGlyphData(QFontEngineFT::Glyph *glyph, QFontEngine::GlyphFormat glyphFormat) { - if (glyph == Q_NULLPTR || glyph->height == 0 || glyph->width == 0) + if (glyph == nullptr || glyph->height == 0 || glyph->width == 0) return QImage(); QImage::Format format = QImage::Format_Invalid; @@ -2020,14 +2015,14 @@ QImage *QFontEngineFT::lockedAlphaMapForGlyph(glyph_t glyphIndex, QFixed subPixe currentlyLockedAlphaMap = alphaMapFromGlyphData(glyph, neededFormat); - const bool glyphHasGeometry = glyph != Q_NULLPTR && glyph->height != 0 && glyph->width != 0; + const bool glyphHasGeometry = glyph != nullptr && glyph->height != 0 && glyph->width != 0; if (!cacheEnabled && glyph != &emptyGlyph) { currentlyLockedAlphaMap = currentlyLockedAlphaMap.copy(); delete glyph; } if (!glyphHasGeometry) - return Q_NULLPTR; + return nullptr; if (currentlyLockedAlphaMap.isNull()) return QFontEngine::lockedAlphaMapForGlyph(glyphIndex, subPixelPosition, neededFormat, t, offset); @@ -2125,7 +2120,7 @@ QImage QFontEngineFT::alphaRGBMapForGlyph(glyph_t g, QFixed subPixelPosition, co QImage QFontEngineFT::bitmapForGlyph(glyph_t g, QFixed subPixelPosition, const QTransform &t) { Glyph *glyph = loadGlyphFor(g, subPixelPosition, defaultFormat, t); - if (glyph == Q_NULLPTR) + if (glyph == nullptr) return QImage(); QImage img; diff --git a/src/platformsupport/fontdatabases/freetype/qfontengine_ft_p.h b/src/platformsupport/fontdatabases/freetype/qfontengine_ft_p.h index e98268ae4b..d498b0ac8b 100644 --- a/src/platformsupport/fontdatabases/freetype/qfontengine_ft_p.h +++ b/src/platformsupport/fontdatabases/freetype/qfontengine_ft_p.h @@ -190,68 +190,68 @@ private: mutable int fast_glyph_count; }; - QFontEngine::FaceId faceId() const Q_DECL_OVERRIDE; - QFontEngine::Properties properties() const Q_DECL_OVERRIDE; - QFixed emSquareSize() const Q_DECL_OVERRIDE; - bool supportsSubPixelPositions() const Q_DECL_OVERRIDE + QFontEngine::FaceId faceId() const override; + QFontEngine::Properties properties() const override; + QFixed emSquareSize() const override; + bool supportsSubPixelPositions() const override { return default_hint_style == HintLight || default_hint_style == HintNone; } - bool getSfntTableData(uint tag, uchar *buffer, uint *length) const Q_DECL_OVERRIDE; - int synthesized() const Q_DECL_OVERRIDE; + bool getSfntTableData(uint tag, uchar *buffer, uint *length) const override; + int synthesized() const override; - QFixed ascent() const Q_DECL_OVERRIDE; - QFixed capHeight() const Q_DECL_OVERRIDE; - QFixed descent() const Q_DECL_OVERRIDE; - QFixed leading() const Q_DECL_OVERRIDE; - QFixed xHeight() const Q_DECL_OVERRIDE; - QFixed averageCharWidth() const Q_DECL_OVERRIDE; + QFixed ascent() const override; + QFixed capHeight() const override; + QFixed descent() const override; + QFixed leading() const override; + QFixed xHeight() const override; + QFixed averageCharWidth() const override; - qreal maxCharWidth() const Q_DECL_OVERRIDE; - QFixed lineThickness() const Q_DECL_OVERRIDE; - QFixed underlinePosition() const Q_DECL_OVERRIDE; + qreal maxCharWidth() const override; + QFixed lineThickness() const override; + QFixed underlinePosition() const override; - glyph_t glyphIndex(uint ucs4) const Q_DECL_OVERRIDE; - void doKerning(QGlyphLayout *, ShaperFlags) const Q_DECL_OVERRIDE; + glyph_t glyphIndex(uint ucs4) const override; + void doKerning(QGlyphLayout *, ShaperFlags) const override; - void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) Q_DECL_OVERRIDE; + void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) override; - bool supportsTransformation(const QTransform &transform) const Q_DECL_OVERRIDE; + bool supportsTransformation(const QTransform &transform) const override; void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs, - QPainterPath *path, QTextItem::RenderFlags flags) Q_DECL_OVERRIDE; + QPainterPath *path, QTextItem::RenderFlags flags) override; void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, - QPainterPath *path, QTextItem::RenderFlags flags) Q_DECL_OVERRIDE; + QPainterPath *path, QTextItem::RenderFlags flags) override; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const Q_DECL_OVERRIDE; + bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; - glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) Q_DECL_OVERRIDE; - glyph_metrics_t boundingBox(glyph_t glyph) Q_DECL_OVERRIDE; - glyph_metrics_t boundingBox(glyph_t glyph, const QTransform &matrix) Q_DECL_OVERRIDE; + glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) override; + glyph_metrics_t boundingBox(glyph_t glyph) override; + glyph_metrics_t boundingBox(glyph_t glyph, const QTransform &matrix) override; - void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags flags) const Q_DECL_OVERRIDE; - QImage alphaMapForGlyph(glyph_t g) Q_DECL_OVERRIDE { return alphaMapForGlyph(g, 0); } - QImage alphaMapForGlyph(glyph_t, QFixed) Q_DECL_OVERRIDE; - QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; - QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; - QImage bitmapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; + void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags flags) const override; + QImage alphaMapForGlyph(glyph_t g) override { return alphaMapForGlyph(g, 0); } + QImage alphaMapForGlyph(glyph_t, QFixed) override; + QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, const QTransform &t) override; + QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) override; + QImage bitmapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) override; glyph_metrics_t alphaMapBoundingBox(glyph_t glyph, QFixed subPixelPosition, const QTransform &matrix, - QFontEngine::GlyphFormat format) Q_DECL_OVERRIDE; + QFontEngine::GlyphFormat format) override; QImage *lockedAlphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, GlyphFormat neededFormat, const QTransform &t, - QPoint *offset) Q_DECL_OVERRIDE; - bool hasInternalCaching() const Q_DECL_OVERRIDE { return cacheEnabled; } - void unlockAlphaMapForGlyph() Q_DECL_OVERRIDE; - bool expectsGammaCorrectedBlending() const Q_DECL_OVERRIDE; + QPoint *offset) override; + bool hasInternalCaching() const override { return cacheEnabled; } + void unlockAlphaMapForGlyph() override; + bool expectsGammaCorrectedBlending() const override; - void removeGlyphFromCache(glyph_t glyph) Q_DECL_OVERRIDE; - int glyphMargin(QFontEngine::GlyphFormat /* format */) Q_DECL_OVERRIDE { return 0; } + void removeGlyphFromCache(glyph_t glyph) override; + int glyphMargin(QFontEngine::GlyphFormat /* format */) override { return 0; } - int glyphCount() const Q_DECL_OVERRIDE; + int glyphCount() const override; enum Scaling { Scaled, @@ -282,13 +282,13 @@ private: bool init(FaceId faceId, bool antialias, GlyphFormat format, QFreetypeFace *freetypeFace); - int getPointInOutline(glyph_t glyph, int flags, quint32 point, QFixed *xpos, QFixed *ypos, quint32 *nPoints) Q_DECL_OVERRIDE; + int getPointInOutline(glyph_t glyph, int flags, quint32 point, QFixed *xpos, QFixed *ypos, quint32 *nPoints) override; void setQtDefaultHintStyle(QFont::HintingPreference hintingPreference); - void setDefaultHintStyle(HintStyle style) Q_DECL_OVERRIDE; + void setDefaultHintStyle(HintStyle style) override; - QFontEngine *cloneWithSize(qreal pixelSize) const Q_DECL_OVERRIDE; - Qt::HANDLE handle() const Q_DECL_OVERRIDE; + QFontEngine *cloneWithSize(qreal pixelSize) const override; + Qt::HANDLE handle() const override; bool initFromFontEngine(const QFontEngineFT *fontEngine); HintStyle defaultHintStyle() const { return default_hint_style; } diff --git a/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase_p.h b/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase_p.h index 6d51361400..0b2956b16e 100644 --- a/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase_p.h +++ b/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase_p.h @@ -66,11 +66,11 @@ struct FontFile class QFreeTypeFontDatabase : public QPlatformFontDatabase { public: - void populateFontDatabase() Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) Q_DECL_OVERRIDE; - QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) Q_DECL_OVERRIDE; - void releaseHandle(void *handle) Q_DECL_OVERRIDE; + void populateFontDatabase() override; + QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; + QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; + QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) override; + void releaseHandle(void *handle) override; static QStringList addTTFile(const QByteArray &fontData, const QByteArray &file); }; diff --git a/src/platformsupport/fontdatabases/mac/coretext.pri b/src/platformsupport/fontdatabases/mac/coretext.pri index 2a9b32f65a..af75aa3281 100644 --- a/src/platformsupport/fontdatabases/mac/coretext.pri +++ b/src/platformsupport/fontdatabases/mac/coretext.pri @@ -18,18 +18,4 @@ macos: \ else: \ LIBS_PRIVATE += -framework UIKit -# CoreText is documented to be available on watchOS, but the headers aren't present -# in the watchOS Simulator SDK like they are supposed to be. Work around the problem -# by adding the device SDK's headers to the search path as a fallback. -# rdar://25314492, rdar://27844864 -watchos:simulator { - simulator_system_frameworks = $$xcodeSDKInfo(Path, $${simulator.sdk})/System/Library/Frameworks - device_system_frameworks = $$xcodeSDKInfo(Path, $${device.sdk})/System/Library/Frameworks - for (arch, QMAKE_APPLE_SIMULATOR_ARCHS) { - QMAKE_CXXFLAGS += \ - -Xarch_$${arch} \ - -F$$simulator_system_frameworks \ - -Xarch_$${arch} \ - -F$$device_system_frameworks - } -} +CONFIG += watchos_coretext diff --git a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm index 722a53ac20..5eb5cd8a30 100644 --- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm +++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm @@ -687,9 +687,11 @@ static CTFontUIFontType fontTypeFromTheme(QPlatformTheme::Font f) return kCTFontUIFontWindowTitle; case QPlatformTheme::MdiSubWindowTitleFont: - case QPlatformTheme::DockWidgetTitleFont: return kCTFontUIFontSystem; + case QPlatformTheme::DockWidgetTitleFont: + return kCTFontUIFontSmallSystem; + case QPlatformTheme::PushButtonFont: return kCTFontUIFontPushButton; diff --git a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h index e14d1d6e6e..05f6ed641c 100644 --- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h +++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h @@ -57,12 +57,8 @@ #include <qpa/qplatformtheme.h> #include <private/qcore_mac_p.h> -#ifdef Q_OS_OSX -#include <ApplicationServices/ApplicationServices.h> -#else -#include <CoreText/CoreText.h> -#include <CoreGraphics/CoreGraphics.h> -#endif +Q_FORWARD_DECLARE_CF_TYPE(CTFontDescriptor); +Q_FORWARD_DECLARE_CF_TYPE(CTFont); Q_DECLARE_METATYPE(QCFType<CGFontRef>); Q_DECLARE_METATYPE(QCFType<CFURLRef>); @@ -74,18 +70,18 @@ class QCoreTextFontDatabase : public QPlatformFontDatabase public: QCoreTextFontDatabase(); ~QCoreTextFontDatabase(); - void populateFontDatabase() Q_DECL_OVERRIDE; + void populateFontDatabase() override; bool populateFamilyAliases() override; - void populateFamily(const QString &familyName) Q_DECL_OVERRIDE; + void populateFamily(const QString &familyName) override; void invalidate() override; - QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const Q_DECL_OVERRIDE; - QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) Q_DECL_OVERRIDE; - void releaseHandle(void *handle) Q_DECL_OVERRIDE; - bool isPrivateFontFamily(const QString &family) const Q_DECL_OVERRIDE; - QFont defaultFont() const Q_DECL_OVERRIDE; - bool fontsAlwaysScalable() const Q_DECL_OVERRIDE; - QList<int> standardSizes() const Q_DECL_OVERRIDE; + QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const override; + QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) override; + void releaseHandle(void *handle) override; + bool isPrivateFontFamily(const QString &family) const override; + QFont defaultFont() const override; + bool fontsAlwaysScalable() const override; + QList<int> standardSizes() const override; // For iOS and OS X platform themes QFont *themeFont(QPlatformTheme::Font) const; diff --git a/src/platformsupport/fontdatabases/mac/qfontengine_coretext.mm b/src/platformsupport/fontdatabases/mac/qfontengine_coretext.mm index d96158d8f6..25ff69d877 100644 --- a/src/platformsupport/fontdatabases/mac/qfontengine_coretext.mm +++ b/src/platformsupport/fontdatabases/mac/qfontengine_coretext.mm @@ -47,28 +47,18 @@ #include <cmath> -#if defined(Q_OS_OSX) && !QT_OSX_DEPLOYMENT_TARGET_BELOW(__MAC_10_11) +#if defined(Q_OS_MACOS) #import <AppKit/AppKit.h> #endif -#if defined(QT_PLATFORM_UIKIT) && !QT_IOS_DEPLOYMENT_TARGET_BELOW(__IPHONE_8_2) +#if defined(QT_PLATFORM_UIKIT) #import <UIKit/UIKit.h> #endif // These are available cross platform, exported as kCTFontWeightXXX from CoreText.framework, // but they are not documented and are not in public headers so are private API and exposed // only through the NSFontWeightXXX and UIFontWeightXXX aliases in AppKit and UIKit (rdar://26109857) -#if QT_MAC_DEPLOYMENT_TARGET_BELOW(__MAC_10_11, __IPHONE_8_2) -#define kCTFontWeightUltraLight -0.8 -#define kCTFontWeightThin -0.6 -#define kCTFontWeightLight -0.4 -#define kCTFontWeightRegular 0 -#define kCTFontWeightMedium 0.23 -#define kCTFontWeightSemibold 0.3 -#define kCTFontWeightBold 0.4 -#define kCTFontWeightHeavy 0.56 -#define kCTFontWeightBlack 0.62 -#elif defined(Q_OS_OSX) +#if defined(Q_OS_MACOS) #define kCTFontWeightUltraLight NSFontWeightUltraLight #define kCTFontWeightThin NSFontWeightThin #define kCTFontWeightLight NSFontWeightLight @@ -673,11 +663,7 @@ QImage QCoreTextFontEngine::imageForGlyph(glyph_t glyph, QFixed subPixelPosition if (!im.width() || !im.height()) return im; -#ifdef Q_OS_OSX - CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); -#else - CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); -#endif + CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB); uint cgflags = isColorGlyph ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst; #ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version cgflags |= kCGBitmapByteOrder32Host; diff --git a/src/platformsupport/fontdatabases/mac/qfontengine_coretext_p.h b/src/platformsupport/fontdatabases/mac/qfontengine_coretext_p.h index d4c5e70cc1..b77aaa27c1 100644 --- a/src/platformsupport/fontdatabases/mac/qfontengine_coretext_p.h +++ b/src/platformsupport/fontdatabases/mac/qfontengine_coretext_p.h @@ -70,53 +70,53 @@ public: QCoreTextFontEngine(CGFontRef font, const QFontDef &def); ~QCoreTextFontEngine(); - glyph_t glyphIndex(uint ucs4) const Q_DECL_OVERRIDE; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const Q_DECL_OVERRIDE; - void recalcAdvances(QGlyphLayout *, ShaperFlags) const Q_DECL_OVERRIDE; + glyph_t glyphIndex(uint ucs4) const override; + bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + void recalcAdvances(QGlyphLayout *, ShaperFlags) const override; - glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) Q_DECL_OVERRIDE; - glyph_metrics_t boundingBox(glyph_t glyph) Q_DECL_OVERRIDE; + glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) override; + glyph_metrics_t boundingBox(glyph_t glyph) override; - QFixed ascent() const Q_DECL_OVERRIDE; - QFixed capHeight() const Q_DECL_OVERRIDE; - QFixed descent() const Q_DECL_OVERRIDE; - QFixed leading() const Q_DECL_OVERRIDE; - QFixed xHeight() const Q_DECL_OVERRIDE; - qreal maxCharWidth() const Q_DECL_OVERRIDE; - QFixed averageCharWidth() const Q_DECL_OVERRIDE; + QFixed ascent() const override; + QFixed capHeight() const override; + QFixed descent() const override; + QFixed leading() const override; + QFixed xHeight() const override; + qreal maxCharWidth() const override; + QFixed averageCharWidth() const override; void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int numGlyphs, - QPainterPath *path, QTextItem::RenderFlags) Q_DECL_OVERRIDE; + QPainterPath *path, QTextItem::RenderFlags) override; - bool canRender(const QChar *string, int len) const Q_DECL_OVERRIDE; + bool canRender(const QChar *string, int len) const override; - int synthesized() const Q_DECL_OVERRIDE { return synthesisFlags; } - bool supportsSubPixelPositions() const Q_DECL_OVERRIDE { return true; } + int synthesized() const override { return synthesisFlags; } + bool supportsSubPixelPositions() const override { return true; } - QFixed lineThickness() const Q_DECL_OVERRIDE; - QFixed underlinePosition() const Q_DECL_OVERRIDE; + QFixed lineThickness() const override; + QFixed underlinePosition() const override; void draw(CGContextRef ctx, qreal x, qreal y, const QTextItemInt &ti, int paintDeviceHeight); - FaceId faceId() const Q_DECL_OVERRIDE; - bool getSfntTableData(uint /*tag*/, uchar * /*buffer*/, uint * /*length*/) const Q_DECL_OVERRIDE; - void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) Q_DECL_OVERRIDE; - QImage alphaMapForGlyph(glyph_t, QFixed subPixelPosition) Q_DECL_OVERRIDE; - QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; - QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; - glyph_metrics_t alphaMapBoundingBox(glyph_t glyph, QFixed, const QTransform &matrix, GlyphFormat) Q_DECL_OVERRIDE; - QImage bitmapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; - QFixed emSquareSize() const Q_DECL_OVERRIDE; - void doKerning(QGlyphLayout *g, ShaperFlags flags) const Q_DECL_OVERRIDE; - - bool supportsTransformation(const QTransform &transform) const Q_DECL_OVERRIDE; - bool expectsGammaCorrectedBlending() const Q_DECL_OVERRIDE; - - QFontEngine *cloneWithSize(qreal pixelSize) const Q_DECL_OVERRIDE; - Qt::HANDLE handle() const Q_DECL_OVERRIDE; - int glyphMargin(QFontEngine::GlyphFormat format) Q_DECL_OVERRIDE { Q_UNUSED(format); return 0; } - - QFontEngine::Properties properties() const Q_DECL_OVERRIDE; + FaceId faceId() const override; + bool getSfntTableData(uint /*tag*/, uchar * /*buffer*/, uint * /*length*/) const override; + void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) override; + QImage alphaMapForGlyph(glyph_t, QFixed subPixelPosition) override; + QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, const QTransform &t) override; + QImage alphaRGBMapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) override; + glyph_metrics_t alphaMapBoundingBox(glyph_t glyph, QFixed, const QTransform &matrix, GlyphFormat) override; + QImage bitmapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) override; + QFixed emSquareSize() const override; + void doKerning(QGlyphLayout *g, ShaperFlags flags) const override; + + bool supportsTransformation(const QTransform &transform) const override; + bool expectsGammaCorrectedBlending() const override; + + QFontEngine *cloneWithSize(qreal pixelSize) const override; + Qt::HANDLE handle() const override; + int glyphMargin(QFontEngine::GlyphFormat format) override { Q_UNUSED(format); return 0; } + + QFontEngine::Properties properties() const override; static bool ct_getSfntTable(void *user_data, uint tag, uchar *buffer, uint *length); static QFont::Weight qtWeightFromCFWeight(float value); diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase.cpp b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase.cpp index a0adcd6e2e..aab1ab9889 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase.cpp +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase.cpp @@ -76,20 +76,18 @@ typedef HRESULT (WINAPI *DWriteCreateFactoryType)(DWRITE_FACTORY_TYPE, const IID static inline DWriteCreateFactoryType resolveDWriteCreateFactory() { - if (QSysInfo::windowsVersion() < QSysInfo::WV_VISTA) - return Q_NULLPTR; QSystemLibrary library(QStringLiteral("dwrite")); QFunctionPointer result = library.resolve("DWriteCreateFactory"); if (Q_UNLIKELY(!result)) { qWarning("Unable to load dwrite.dll"); - return Q_NULLPTR; + return nullptr; } return reinterpret_cast<DWriteCreateFactoryType>(result); } static void createDirectWriteFactory(IDWriteFactory **factory) { - *factory = Q_NULLPTR; + *factory = nullptr; static const DWriteCreateFactoryType dWriteCreateFactory = resolveDWriteCreateFactory(); if (!dWriteCreateFactory) @@ -539,7 +537,7 @@ namespace { class CustomFontFileLoader { public: - CustomFontFileLoader() : m_directWriteFontFileLoader(Q_NULLPTR) + CustomFontFileLoader() : m_directWriteFontFileLoader(nullptr) { createDirectWriteFactory(&m_directWriteFactory); @@ -874,8 +872,8 @@ FontNames qt_getCanonicalFontNames(const uchar *table, quint32 bytes) if ((platform_id == PlatformId_Microsoft && (encoding_id == 0 || encoding_id == 1)) - && (language_id & 0x3ff) == MS_LangIdEnglish - && *idType < Microsoft) { + && ((language_id & 0x3ff) == MS_LangIdEnglish + || *idType < Microsoft)) { *id = i; *idType = Microsoft; } @@ -1128,7 +1126,7 @@ static int QT_WIN_CALLBACK storeFont(const LOGFONT *logFont, const TEXTMETRIC *t // NEWTEXTMETRICEX (passed for TT fonts) is a NEWTEXTMETRIC, which according // to the documentation is identical to a TEXTMETRIC except for the last four // members, which we don't use anyway - const FONTSIGNATURE *signature = Q_NULLPTR; + const FONTSIGNATURE *signature = nullptr; if (type & TRUETYPE_FONTTYPE) signature = &reinterpret_cast<const NEWTEXTMETRICEX *>(textmetric)->ntmFontSig; addFontToDatabase(familyName, styleName, *logFont, textmetric, signature, type); @@ -1174,6 +1172,46 @@ static int QT_WIN_CALLBACK populateFontFamilies(const LOGFONT *logFont, const TE return 1; // continue } +void QWindowsFontDatabase::addDefaultEUDCFont() +{ + QString path; + { + HKEY key; + if (RegOpenKeyEx(HKEY_CURRENT_USER, + L"EUDC\\1252", + 0, + KEY_READ, + &key) != ERROR_SUCCESS) { + return; + } + + WCHAR value[MAX_PATH]; + DWORD bufferSize = sizeof(value); + ZeroMemory(value, bufferSize); + + if (RegQueryValueEx(key, + L"SystemDefaultEUDCFont", + nullptr, + nullptr, + reinterpret_cast<LPBYTE>(value), + &bufferSize) == ERROR_SUCCESS) { + path = QString::fromWCharArray(value); + } + + RegCloseKey(key); + } + + if (!path.isEmpty()) { + QFile file(path); + if (!file.open(QIODevice::ReadOnly)) { + qCWarning(lcQpaFonts) << "Unable to open default EUDC font:" << path; + return; + } + + m_eudcFonts = addApplicationFont(file.readAll(), path); + } +} + void QWindowsFontDatabase::populateFontDatabase() { removeApplicationFonts(); @@ -1188,6 +1226,7 @@ void QWindowsFontDatabase::populateFontDatabase() QString systemDefaultFamily = QWindowsFontDatabase::systemDefaultFont().family(); if (QPlatformFontDatabase::resolveFontFamilyAlias(systemDefaultFamily) == systemDefaultFamily) QPlatformFontDatabase::registerFontFamily(systemDefaultFamily); + addDefaultEUDCFont(); } typedef QSharedPointer<QWindowsFontEngineData> QWindowsFontEngineDataPtr; @@ -1585,6 +1624,7 @@ void QWindowsFontDatabase::removeApplicationFonts() } } m_applicationFonts.clear(); + m_eudcFonts.clear(); } void QWindowsFontDatabase::releaseHandle(void *handle) @@ -1719,11 +1759,8 @@ LOGFONT QWindowsFontDatabase::fontDefToLOGFONT(const QFontDef &request, const QS qual = PROOF_QUALITY; if (request.styleStrategy & QFont::PreferAntialias) { - if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP && !(request.styleStrategy & QFont::NoSubpixelAntialias)) { - qual = CLEARTYPE_QUALITY; - } else { - qual = ANTIALIASED_QUALITY; - } + qual = (request.styleStrategy & QFont::NoSubpixelAntialias) == 0 + ? CLEARTYPE_QUALITY : ANTIALIASED_QUALITY; } else if (request.styleStrategy & QFont::NoAntialias) { qual = NONANTIALIASED_QUALITY; } else if ((request.styleStrategy & QFont::NoSubpixelAntialias) && sharedFontData()->clearTypeEnabled) { @@ -1849,6 +1886,7 @@ QStringList QWindowsFontDatabase::fallbacksForFamily(const QString &family, QFon { QStringList result; result.append(QWindowsFontDatabase::familyForStyleHint(styleHint)); + result.append(m_eudcFonts); result.append(QWindowsFontDatabase::extraTryFontsForFamily(family)); result.append(QPlatformFontDatabase::fallbacksForFamily(family, style, styleHint, script)); @@ -1910,7 +1948,7 @@ QFontEngine *QWindowsFontDatabase::createEngine(const QFontDef &request, const Q } else { bool isColorFont = false; #if defined(QT_USE_DIRECTWRITE2) - IDWriteFontFace2 *directWriteFontFace2 = Q_NULLPTR; + IDWriteFontFace2 *directWriteFontFace2 = nullptr; if (SUCCEEDED(directWriteFontFace->QueryInterface(__uuidof(IDWriteFontFace2), reinterpret_cast<void **>(&directWriteFontFace2)))) { if (directWriteFontFace2->IsColorFont()) @@ -2038,4 +2076,9 @@ QString QWindowsFontDatabase::readRegistryString(HKEY parentHandle, const wchar_ return result; } +bool QWindowsFontDatabase::isPrivateFontFamily(const QString &family) const +{ + return m_eudcFonts.contains(family) || QPlatformFontDatabase::isPrivateFontFamily(family); +} + QT_END_NAMESPACE diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft.cpp b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft.cpp index 3f03b30f10..78477de38a 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft.cpp +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft.cpp @@ -144,7 +144,7 @@ static FontKeys &fontKeys() return result; } -static const FontKey *findFontKey(const QString &name, int *indexIn = Q_NULLPTR) +static const FontKey *findFontKey(const QString &name, int *indexIn = nullptr) { const FontKeys &keys = fontKeys(); for (auto it = keys.constBegin(), cend = keys.constEnd(); it != cend; ++it) { @@ -157,7 +157,7 @@ static const FontKey *findFontKey(const QString &name, int *indexIn = Q_NULLPTR) } if (indexIn) *indexIn = -1; - return Q_NULLPTR; + return nullptr; } static bool addFontToDatabase(QString familyName, @@ -310,7 +310,7 @@ static int QT_WIN_CALLBACK storeFont(const LOGFONT *logFont, const TEXTMETRIC *t // NEWTEXTMETRICEX (passed for TT fonts) is a NEWTEXTMETRIC, which according // to the documentation is identical to a TEXTMETRIC except for the last four // members, which we don't use anyway - const FONTSIGNATURE *signature = Q_NULLPTR; + const FONTSIGNATURE *signature = nullptr; if (type & TRUETYPE_FONTTYPE) signature = &reinterpret_cast<const NEWTEXTMETRICEX *>(textmetric)->ntmFontSig; addFontToDatabase(faceName, styleName, fullName, *logFont, textmetric, signature, type); diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft_p.h b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft_p.h index 2df81274ad..c3d201b3a0 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft_p.h +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft_p.h @@ -60,18 +60,18 @@ QT_BEGIN_NAMESPACE class QWindowsFontDatabaseFT : public QFreeTypeFontDatabase { public: - void populateFontDatabase() Q_DECL_OVERRIDE; - void populateFamily(const QString &familyName) Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) Q_DECL_OVERRIDE; + void populateFontDatabase() override; + void populateFamily(const QString &familyName) override; + QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, - QFont::HintingPreference hintingPreference) Q_DECL_OVERRIDE; + QFont::HintingPreference hintingPreference) override; QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, - QChar::Script script) const Q_DECL_OVERRIDE; + QChar::Script script) const override; - QString fontDir() const Q_DECL_OVERRIDE; - QFont defaultFont() const Q_DECL_OVERRIDE; + QString fontDir() const override; + QFont defaultFont() const override; }; QT_END_NAMESPACE diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_p.h b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_p.h index 15172c09da..30f5beefdf 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_p.h +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_p.h @@ -95,20 +95,21 @@ public: QWindowsFontDatabase(); ~QWindowsFontDatabase(); - void populateFontDatabase() Q_DECL_OVERRIDE; - void populateFamily(const QString &familyName) Q_DECL_OVERRIDE; - QFontEngineMulti *fontEngineMulti(QFontEngine *fontEngine, QChar::Script script) Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) Q_DECL_OVERRIDE; - QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) Q_DECL_OVERRIDE; - QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const Q_DECL_OVERRIDE; - QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) Q_DECL_OVERRIDE; - void releaseHandle(void *handle) Q_DECL_OVERRIDE; - QString fontDir() const Q_DECL_OVERRIDE; - - QFont defaultFont() const Q_DECL_OVERRIDE { return systemDefaultFont(); } - bool fontsAlwaysScalable() const Q_DECL_OVERRIDE; + void populateFontDatabase() override; + void populateFamily(const QString &familyName) override; + QFontEngineMulti *fontEngineMulti(QFontEngine *fontEngine, QChar::Script script) override; + QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; + QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; + QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const override; + QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) override; + void releaseHandle(void *handle) override; + QString fontDir() const override; + + QFont defaultFont() const override { return systemDefaultFont(); } + bool fontsAlwaysScalable() const override; void derefUniqueFont(const QString &uniqueFont); void refUniqueFont(const QString &uniqueFont); + bool isPrivateFontFamily(const QString &family) const override; static QFont systemDefaultFont(); @@ -134,6 +135,7 @@ public: private: void removeApplicationFonts(); + void addDefaultEUDCFont(); struct WinApplicationFont { HANDLE handle; @@ -150,6 +152,7 @@ private: QMap<QString, UniqueFontData> m_uniqueFontData; static unsigned m_fontOptions; + QStringList m_eudcFonts; }; #ifndef QT_NO_DEBUG_STREAM diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontengine.cpp b/src/platformsupport/fontdatabases/windows/qwindowsfontengine.cpp index 1389b497d5..584e4db05d 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontengine.cpp +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontengine.cpp @@ -132,20 +132,6 @@ bool QWindowsFontEngine::hasCMapTable() const return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('c', 'm', 'a', 'p'), 0, 0, 0) != GDI_ERROR; } -bool QWindowsFontEngine::hasGlyfTable() const -{ - HDC hdc = m_fontEngineData->hdc; - SelectObject(hdc, hfont); - return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('g', 'l', 'y', 'f'), 0, 0, 0) != GDI_ERROR; -} - -bool QWindowsFontEngine::hasEbdtTable() const -{ - HDC hdc = m_fontEngineData->hdc; - SelectObject(hdc, hfont); - return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('E', 'B', 'D', 'T'), 0, 0, 0) != GDI_ERROR; -} - static inline QString stringFromOutLineTextMetric(const OUTLINETEXTMETRIC *otm, PSTR offset) { const uchar *p = reinterpret_cast<const uchar *>(otm) + quintptr(offset); @@ -276,7 +262,7 @@ QWindowsFontEngine::QWindowsFontEngine(const QString &name, userData.insert(QStringLiteral("trueType"), QVariant(bool(ttf))); setUserData(userData); - hasUnreliableOutline = hasGlyfTable() && hasEbdtTable(); + hasUnreliableOutline = (tm.tmPitchAndFamily & (TMPF_TRUETYPE | TMPF_VECTOR)) == 0; } QWindowsFontEngine::~QWindowsFontEngine() @@ -1281,31 +1267,36 @@ QFontEngine *QWindowsMultiFontEngine::loadEngine(int at) lf.lfFaceName[nameSubstituteLength] = 0; } - IDWriteFont *directWriteFont = 0; - HRESULT hr = data->directWriteGdiInterop->CreateFontFromLOGFONT(&lf, &directWriteFont); - if (FAILED(hr)) { - qWarning("%s: %s", __FUNCTION__, - qPrintable(msgDirectWriteFunctionFailed(hr, "CreateFontFromLOGFONT", fam, nameSubstitute))); + HFONT hfont = CreateFontIndirect(&lf); + if (hfont == nullptr) { + qErrnoWarning("%s: CreateFontIndirect failed", __FUNCTION__); } else { - Q_ASSERT(directWriteFont); - IDWriteFontFace *directWriteFontFace = NULL; - HRESULT hr = directWriteFont->CreateFontFace(&directWriteFontFace); + HGDIOBJ oldFont = SelectObject(data->hdc, hfont); + + IDWriteFontFace *directWriteFontFace = nullptr; + QWindowsFontEngineDirectWrite *fedw = nullptr; + HRESULT hr = data->directWriteGdiInterop->CreateFontFaceFromHdc(data->hdc, &directWriteFontFace); if (SUCCEEDED(hr)) { Q_ASSERT(directWriteFontFace); - QWindowsFontEngineDirectWrite *fedw = new QWindowsFontEngineDirectWrite(directWriteFontFace, - fontEngine->fontDef.pixelSize, - data); + fedw = new QWindowsFontEngineDirectWrite(directWriteFontFace, + fontEngine->fontDef.pixelSize, + data); fedw->fontDef.weight = fontEngine->fontDef.weight; if (fontEngine->fontDef.style > QFont::StyleNormal) fedw->fontDef.style = fontEngine->fontDef.style; fedw->fontDef.family = fam; fedw->fontDef.hintingPreference = fontEngine->fontDef.hintingPreference; fedw->fontDef.stretch = fontEngine->fontDef.stretch; - return fedw; } else { qWarning("%s: %s", __FUNCTION__, qPrintable(msgDirectWriteFunctionFailed(hr, "CreateFontFace", fam, nameSubstitute))); } + + SelectObject(data->hdc, oldFont); + DeleteObject(hfont); + + if (fedw != nullptr) + return fedw; } } #endif diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontengine_p.h b/src/platformsupport/fontdatabases/windows/qwindowsfontengine_p.h index 5119adc0eb..2ec391c4da 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontengine_p.h +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontengine_p.h @@ -76,53 +76,53 @@ public: void initFontInfo(const QFontDef &request, int dpi); - QFixed lineThickness() const Q_DECL_OVERRIDE; - Properties properties() const Q_DECL_OVERRIDE; - void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) Q_DECL_OVERRIDE; - FaceId faceId() const Q_DECL_OVERRIDE; - bool getSfntTableData(uint tag, uchar *buffer, uint *length) const Q_DECL_OVERRIDE; - int synthesized() const Q_DECL_OVERRIDE; - QFixed emSquareSize() const Q_DECL_OVERRIDE; - - glyph_t glyphIndex(uint ucs4) const Q_DECL_OVERRIDE; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const Q_DECL_OVERRIDE; - void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags) const Q_DECL_OVERRIDE; - - void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) Q_DECL_OVERRIDE; + QFixed lineThickness() const override; + Properties properties() const override; + void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) override; + FaceId faceId() const override; + bool getSfntTableData(uint tag, uchar *buffer, uint *length) const override; + int synthesized() const override; + QFixed emSquareSize() const override; + + glyph_t glyphIndex(uint ucs4) const override; + bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags) const override; + + void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) override; virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs, - QPainterPath *path, QTextItem::RenderFlags flags) Q_DECL_OVERRIDE; + QPainterPath *path, QTextItem::RenderFlags flags) override; HGDIOBJ selectDesignFont() const; - glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) Q_DECL_OVERRIDE; - glyph_metrics_t boundingBox(glyph_t g) Q_DECL_OVERRIDE { return boundingBox(g, QTransform()); } - glyph_metrics_t boundingBox(glyph_t g, const QTransform &t) Q_DECL_OVERRIDE; + glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) override; + glyph_metrics_t boundingBox(glyph_t g) override { return boundingBox(g, QTransform()); } + glyph_metrics_t boundingBox(glyph_t g, const QTransform &t) override; - QFixed ascent() const Q_DECL_OVERRIDE; - QFixed descent() const Q_DECL_OVERRIDE; - QFixed leading() const Q_DECL_OVERRIDE; - QFixed xHeight() const Q_DECL_OVERRIDE; - QFixed capHeight() const Q_DECL_OVERRIDE; - QFixed averageCharWidth() const Q_DECL_OVERRIDE; - qreal maxCharWidth() const Q_DECL_OVERRIDE; - qreal minLeftBearing() const Q_DECL_OVERRIDE; - qreal minRightBearing() const Q_DECL_OVERRIDE; + QFixed ascent() const override; + QFixed descent() const override; + QFixed leading() const override; + QFixed xHeight() const override; + QFixed capHeight() const override; + QFixed averageCharWidth() const override; + qreal maxCharWidth() const override; + qreal minLeftBearing() const override; + qreal minRightBearing() const override; - QImage alphaMapForGlyph(glyph_t t) Q_DECL_OVERRIDE { return alphaMapForGlyph(t, QTransform()); } - QImage alphaMapForGlyph(glyph_t, const QTransform &xform) Q_DECL_OVERRIDE; - QImage alphaRGBMapForGlyph(glyph_t t, QFixed subPixelPosition, const QTransform &xform) Q_DECL_OVERRIDE; - glyph_metrics_t alphaMapBoundingBox(glyph_t glyph, QFixed, const QTransform &matrix, GlyphFormat) Q_DECL_OVERRIDE; + QImage alphaMapForGlyph(glyph_t t) override { return alphaMapForGlyph(t, QTransform()); } + QImage alphaMapForGlyph(glyph_t, const QTransform &xform) override; + QImage alphaRGBMapForGlyph(glyph_t t, QFixed subPixelPosition, const QTransform &xform) override; + glyph_metrics_t alphaMapBoundingBox(glyph_t glyph, QFixed, const QTransform &matrix, GlyphFormat) override; - QFontEngine *cloneWithSize(qreal pixelSize) const Q_DECL_OVERRIDE; - Qt::HANDLE handle() const Q_DECL_OVERRIDE; - bool supportsTransformation(const QTransform &transform) const Q_DECL_OVERRIDE; + QFontEngine *cloneWithSize(qreal pixelSize) const override; + Qt::HANDLE handle() const override; + bool supportsTransformation(const QTransform &transform) const override; #ifndef Q_CC_MINGW - void getGlyphBearings(glyph_t glyph, qreal *leftBearing = 0, qreal *rightBearing = 0) Q_DECL_OVERRIDE; + void getGlyphBearings(glyph_t glyph, qreal *leftBearing = 0, qreal *rightBearing = 0) override; #endif - bool hasUnreliableGlyphOutline() const Q_DECL_OVERRIDE; + bool hasUnreliableGlyphOutline() const override; int getGlyphIndexes(const QChar *ch, int numChars, QGlyphLayout *glyphs) const; void getCMap(); @@ -138,8 +138,6 @@ private: QImage::Format mask_format); bool hasCFFTable() const; bool hasCMapTable() const; - bool hasGlyfTable() const; - bool hasEbdtTable() const; const QSharedPointer<QWindowsFontEngineData> m_fontEngineData; @@ -175,7 +173,7 @@ class QWindowsMultiFontEngine : public QFontEngineMulti public: explicit QWindowsMultiFontEngine(QFontEngine *fe, int script); - QFontEngine *loadEngine(int at) Q_DECL_OVERRIDE; + QFontEngine *loadEngine(int at) override; }; QT_END_NAMESPACE diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite.cpp b/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite.cpp index f07e711048..0e017c3b77 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite.cpp +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite.cpp @@ -282,7 +282,7 @@ static UUID uuidIdWriteLocalFontFileLoader() QString QWindowsFontEngineDirectWrite::filenameFromFontFile(IDWriteFontFile *fontFile) { - IDWriteFontFileLoader *loader = Q_NULLPTR; + IDWriteFontFileLoader *loader = nullptr; HRESULT hr = fontFile->GetLoader(&loader); if (FAILED(hr)) { @@ -290,11 +290,11 @@ QString QWindowsFontEngineDirectWrite::filenameFromFontFile(IDWriteFontFile *fon return QString(); } - QIdWriteLocalFontFileLoader *localLoader = Q_NULLPTR; + QIdWriteLocalFontFileLoader *localLoader = nullptr; hr = loader->QueryInterface(uuidIdWriteLocalFontFileLoader(), reinterpret_cast<void **>(&localLoader)); - const void *fontFileReferenceKey = Q_NULLPTR; + const void *fontFileReferenceKey = nullptr; UINT32 fontFileReferenceKeySize = 0; if (SUCCEEDED(hr)) { hr = fontFile->GetReferenceKey(&fontFileReferenceKey, @@ -326,10 +326,10 @@ QString QWindowsFontEngineDirectWrite::filenameFromFontFile(IDWriteFontFile *fon ret = QString::fromWCharArray(filePath.data()); } - if (localLoader != Q_NULLPTR) + if (localLoader != nullptr) localLoader->Release(); - if (loader != Q_NULLPTR) + if (loader != nullptr) loader->Release(); return ret; } @@ -349,7 +349,7 @@ void QWindowsFontEngineDirectWrite::collectMetrics() m_lineGap = DESIGN_TO_LOGICAL(metrics.lineGap); m_underlinePosition = DESIGN_TO_LOGICAL(metrics.underlinePosition); - IDWriteFontFile *fontFile = Q_NULLPTR; + IDWriteFontFile *fontFile = nullptr; UINT32 numberOfFiles = 1; if (SUCCEEDED(m_directWriteFontFace->GetFiles(&numberOfFiles, &fontFile))) { m_faceId.filename = QFile::encodeName(filenameFromFontFile(fontFile)); @@ -713,7 +713,7 @@ QImage QWindowsFontEngineDirectWrite::imageForGlyph(glyph_t t, #if defined(QT_USE_DIRECTWRITE2) HRESULT hr = DWRITE_E_NOCOLOR; IDWriteColorGlyphRunEnumerator *enumerator = 0; - IDWriteFactory2 *factory2 = Q_NULLPTR; + IDWriteFactory2 *factory2 = nullptr; if (glyphFormat == QFontEngine::Format_ARGB && SUCCEEDED(m_fontEngineData->directWriteFactory->QueryInterface(__uuidof(IDWriteFactory2), reinterpret_cast<void **>(&factory2)))) { diff --git a/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite_p.h b/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite_p.h index db4e79e44f..83fdddfa26 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite_p.h +++ b/src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite_p.h @@ -80,41 +80,41 @@ public: void initFontInfo(const QFontDef &request, int dpi); - QFixed lineThickness() const Q_DECL_OVERRIDE; - QFixed underlinePosition() const Q_DECL_OVERRIDE; - bool getSfntTableData(uint tag, uchar *buffer, uint *length) const Q_DECL_OVERRIDE; - QFixed emSquareSize() const Q_DECL_OVERRIDE; + QFixed lineThickness() const override; + QFixed underlinePosition() const override; + bool getSfntTableData(uint tag, uchar *buffer, uint *length) const override; + QFixed emSquareSize() const override; - glyph_t glyphIndex(uint ucs4) const Q_DECL_OVERRIDE; + glyph_t glyphIndex(uint ucs4) const override; bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, - ShaperFlags flags) const Q_DECL_OVERRIDE; - void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags) const Q_DECL_OVERRIDE; + ShaperFlags flags) const override; + void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags) const override; void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs, - QPainterPath *path, QTextItem::RenderFlags flags) Q_DECL_OVERRIDE; + QPainterPath *path, QTextItem::RenderFlags flags) override; - glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) Q_DECL_OVERRIDE; - glyph_metrics_t boundingBox(glyph_t g) Q_DECL_OVERRIDE; + glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) override; + glyph_metrics_t boundingBox(glyph_t g) override; glyph_metrics_t alphaMapBoundingBox(glyph_t glyph, QFixed, - const QTransform &matrix, GlyphFormat) Q_DECL_OVERRIDE; + const QTransform &matrix, GlyphFormat) override; - QFixed ascent() const Q_DECL_OVERRIDE; - QFixed capHeight() const Q_DECL_OVERRIDE; - QFixed descent() const Q_DECL_OVERRIDE; - QFixed leading() const Q_DECL_OVERRIDE; - QFixed xHeight() const Q_DECL_OVERRIDE; - qreal maxCharWidth() const Q_DECL_OVERRIDE; - FaceId faceId() const Q_DECL_OVERRIDE; + QFixed ascent() const override; + QFixed capHeight() const override; + QFixed descent() const override; + QFixed leading() const override; + QFixed xHeight() const override; + qreal maxCharWidth() const override; + FaceId faceId() const override; - bool supportsSubPixelPositions() const Q_DECL_OVERRIDE; + bool supportsSubPixelPositions() const override; - QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition) Q_DECL_OVERRIDE; - QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; - QImage alphaRGBMapForGlyph(glyph_t t, QFixed subPixelPosition, const QTransform &xform) Q_DECL_OVERRIDE; - QImage bitmapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) Q_DECL_OVERRIDE; + QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition) override; + QImage alphaMapForGlyph(glyph_t glyph, QFixed subPixelPosition, const QTransform &t) override; + QImage alphaRGBMapForGlyph(glyph_t t, QFixed subPixelPosition, const QTransform &xform) override; + QImage bitmapForGlyph(glyph_t, QFixed subPixelPosition, const QTransform &t) override; - QFontEngine *cloneWithSize(qreal pixelSize) const Q_DECL_OVERRIDE; - Qt::HANDLE handle() const Q_DECL_OVERRIDE; + QFontEngine *cloneWithSize(qreal pixelSize) const override; + Qt::HANDLE handle() const override; const QSharedPointer<QWindowsFontEngineData> &fontEngineData() const { return m_fontEngineData; } diff --git a/src/platformsupport/fontdatabases/windows/qwindowsnativeimage.cpp b/src/platformsupport/fontdatabases/windows/qwindowsnativeimage.cpp index f8fcff952a..67a6619b91 100644 --- a/src/platformsupport/fontdatabases/windows/qwindowsnativeimage.cpp +++ b/src/platformsupport/fontdatabases/windows/qwindowsnativeimage.cpp @@ -98,7 +98,7 @@ static inline HBITMAP createDIB(HDC hdc, int width, int height, bmi.blueMask = 0; } - uchar *bits = Q_NULLPTR; + uchar *bits = nullptr; HBITMAP bitmap = CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO *>(&bmi), DIB_RGB_COLORS, reinterpret_cast<void **>(&bits), 0, 0); if (Q_UNLIKELY(!bitmap || !bits)) diff --git a/src/platformsupport/glxconvenience/qglxconvenience.cpp b/src/platformsupport/glxconvenience/qglxconvenience.cpp index 74b7c63473..8d2e58b57b 100644 --- a/src/platformsupport/glxconvenience/qglxconvenience.cpp +++ b/src/platformsupport/glxconvenience/qglxconvenience.cpp @@ -72,7 +72,11 @@ enum { #undef FontChange #endif -QVector<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit) +#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB +#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2 +#endif + +QVector<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit, int flags) { QVector<int> spec; @@ -116,6 +120,10 @@ QVector<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit) << GLX_SAMPLES_ARB << format.samples(); + if ((flags & QGLX_SUPPORTS_SRGB) && format.colorSpace() == QSurfaceFormat::sRGBColorSpace) + spec << GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB + << True; + spec << GLX_DRAWABLE_TYPE << drawableBit @@ -176,14 +184,14 @@ template <class T> using QXlibArrayPointer = QScopedArrayPointer<T, QXlibScopedPointerDeleter<T>>; } -GLXFBConfig qglx_findConfig(Display *display, int screen , QSurfaceFormat format, bool highestPixelFormat, int drawableBit) +GLXFBConfig qglx_findConfig(Display *display, int screen , QSurfaceFormat format, bool highestPixelFormat, int drawableBit, int flags) { QXcbSoftwareOpenGLEnforcer softwareOpenGLEnforcer; GLXFBConfig config = 0; do { - const QVector<int> spec = qglx_buildSpec(format, drawableBit); + const QVector<int> spec = qglx_buildSpec(format, drawableBit, flags); int confcount = 0; QXlibArrayPointer<GLXFBConfig> configs(glXChooseFBConfig(display, screen, spec.constData(), &confcount)); @@ -202,6 +210,13 @@ GLXFBConfig qglx_findConfig(Display *display, int screen , QSurfaceFormat format for (int i = 0; i < confcount; i++) { GLXFBConfig candidate = configs[i]; + if ((flags & QGLX_SUPPORTS_SRGB) && format.colorSpace() == QSurfaceFormat::sRGBColorSpace) { + int srgbCapable = 0; + glXGetFBConfigAttrib(display, candidate, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable); + if (!srgbCapable) + continue; + } + QXlibPointer<XVisualInfo> visual(glXGetVisualFromFBConfig(display, candidate)); if (visual.isNull()) continue; @@ -227,28 +242,28 @@ GLXFBConfig qglx_findConfig(Display *display, int screen , QSurfaceFormat format return config; } -XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *format, int drawableBit) +XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *format, int drawableBit, int flags) { Q_ASSERT(format); XVisualInfo *visualInfo = 0; - GLXFBConfig config = qglx_findConfig(display, screen, *format, false, drawableBit); + GLXFBConfig config = qglx_findConfig(display, screen, *format, false, drawableBit, flags); if (config) visualInfo = glXGetVisualFromFBConfig(display, config); if (visualInfo) { - qglx_surfaceFormatFromGLXFBConfig(format, display, config); + qglx_surfaceFormatFromGLXFBConfig(format, display, config, flags); return visualInfo; } // attempt to fall back to glXChooseVisual do { - QVector<int> attribs = qglx_buildSpec(*format, drawableBit); + QVector<int> attribs = qglx_buildSpec(*format, drawableBit, flags); visualInfo = glXChooseVisual(display, screen, attribs.data()); if (visualInfo) { - qglx_surfaceFormatFromVisualInfo(format, display, visualInfo); + qglx_surfaceFormatFromVisualInfo(format, display, visualInfo, flags); return visualInfo; } } while (qglx_reduceFormat(format)); @@ -256,7 +271,7 @@ XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *f return visualInfo; } -void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config) +void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config, int flags) { int redSize = 0; int greenSize = 0; @@ -267,6 +282,7 @@ void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, int sampleBuffers = 0; int sampleCount = 0; int stereo = 0; + int srgbCapable = 0; glXGetFBConfigAttrib(display, config, GLX_RED_SIZE, &redSize); glXGetFBConfigAttrib(display, config, GLX_GREEN_SIZE, &greenSize); @@ -276,6 +292,8 @@ void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, glXGetFBConfigAttrib(display, config, GLX_STENCIL_SIZE, &stencilSize); glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleBuffers); glXGetFBConfigAttrib(display, config, GLX_STEREO, &stereo); + if (flags & QGLX_SUPPORTS_SRGB) + glXGetFBConfigAttrib(display, config, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable); format->setRedBufferSize(redSize); format->setGreenBufferSize(greenSize); @@ -287,11 +305,12 @@ void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleCount); format->setSamples(sampleCount); } + format->setColorSpace(srgbCapable ? QSurfaceFormat::sRGBColorSpace : QSurfaceFormat::DefaultColorSpace); format->setStereo(stereo); } -void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, XVisualInfo *visualInfo) +void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, XVisualInfo *visualInfo, int flags) { int redSize = 0; int greenSize = 0; @@ -302,6 +321,7 @@ void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, int sampleBuffers = 0; int sampleCount = 0; int stereo = 0; + int srgbCapable = 0; glXGetConfig(display, visualInfo, GLX_RED_SIZE, &redSize); glXGetConfig(display, visualInfo, GLX_GREEN_SIZE, &greenSize); @@ -311,6 +331,8 @@ void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, glXGetConfig(display, visualInfo, GLX_STENCIL_SIZE, &stencilSize); glXGetConfig(display, visualInfo, GLX_SAMPLES_ARB, &sampleBuffers); glXGetConfig(display, visualInfo, GLX_STEREO, &stereo); + if (flags & QGLX_SUPPORTS_SRGB) + glXGetConfig(display, visualInfo, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgbCapable); format->setRedBufferSize(redSize); format->setGreenBufferSize(greenSize); @@ -322,6 +344,7 @@ void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, glXGetConfig(display, visualInfo, GLX_SAMPLES_ARB, &sampleCount); format->setSamples(sampleCount); } + format->setColorSpace(srgbCapable ? QSurfaceFormat::sRGBColorSpace : QSurfaceFormat::DefaultColorSpace); format->setStereo(stereo); } @@ -390,5 +413,10 @@ bool qglx_reduceFormat(QSurfaceFormat *format) return true; } + if (format->colorSpace() == QSurfaceFormat::sRGBColorSpace) { + format->setColorSpace(QSurfaceFormat::DefaultColorSpace); + return true; + } + return false; } diff --git a/src/platformsupport/glxconvenience/qglxconvenience_p.h b/src/platformsupport/glxconvenience/qglxconvenience_p.h index d422668584..f9647bfd9a 100644 --- a/src/platformsupport/glxconvenience/qglxconvenience_p.h +++ b/src/platformsupport/glxconvenience/qglxconvenience_p.h @@ -57,11 +57,16 @@ #include <X11/Xlib.h> #include <GL/glx.h> -QVector<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit = GLX_WINDOW_BIT); -XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *format, int drawableBit = GLX_WINDOW_BIT); -GLXFBConfig qglx_findConfig(Display *display, int screen, QSurfaceFormat format, bool highestPixelFormat = false, int drawableBit = GLX_WINDOW_BIT); -void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config); -void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, XVisualInfo *visualInfo); +enum QGlxFlags +{ + QGLX_SUPPORTS_SRGB = 0x01 +}; + +QVector<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit = GLX_WINDOW_BIT, int flags = 0); +XVisualInfo *qglx_findVisualInfo(Display *display, int screen, QSurfaceFormat *format, int drawableBit = GLX_WINDOW_BIT, int flags = 0); +GLXFBConfig qglx_findConfig(Display *display, int screen, QSurfaceFormat format, bool highestPixelFormat = false, int drawableBit = GLX_WINDOW_BIT, int flags = 0); +void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config, int flags = 0); +void qglx_surfaceFormatFromVisualInfo(QSurfaceFormat *format, Display *display, XVisualInfo *visualInfo, int flags = 0); bool qglx_reduceFormat(QSurfaceFormat *format); #endif // QGLXCONVENIENCE_H diff --git a/src/platformsupport/graphics/qrasterbackingstore.cpp b/src/platformsupport/graphics/qrasterbackingstore.cpp index b8d393844c..a3ffe11d19 100644 --- a/src/platformsupport/graphics/qrasterbackingstore.cpp +++ b/src/platformsupport/graphics/qrasterbackingstore.cpp @@ -59,20 +59,7 @@ QRasterBackingStore::~QRasterBackingStore() void QRasterBackingStore::resize(const QSize &size, const QRegion &staticContents) { Q_UNUSED(staticContents); - - // We can't guarantee that we have a platform-window at this point, so we have - // to pull out the DPR using QWindow and its QScreen fallback, and then remove - // the Qt scaling factor. - qreal nativeWindowDevicePixelRatio = window()->devicePixelRatio() / QHighDpiScaling::factor(window()); - QSize effectiveBufferSize = size * nativeWindowDevicePixelRatio; - - if (m_image.size() == effectiveBufferSize) - return; - - m_image = QImage(effectiveBufferSize, format()); - m_image.setDevicePixelRatio(nativeWindowDevicePixelRatio); - if (m_image.format() == QImage::Format_ARGB32_Premultiplied) - m_image.fill(Qt::transparent); + m_requestedSize = size; } QImage::Format QRasterBackingStore::format() const @@ -111,11 +98,13 @@ bool QRasterBackingStore::scroll(const QRegion ®ion, int dx, int dy) void QRasterBackingStore::beginPaint(const QRegion ®ion) { - // Keep backing store device pixel ratio in sync with window qreal nativeWindowDevicePixelRatio = window()->handle()->devicePixelRatio(); - if (m_image.devicePixelRatio() != nativeWindowDevicePixelRatio) { - const QSize nativeSize = QHighDpi::toNativePixels(backingStore()->size(), window()); - resize(nativeSize, backingStore()->staticContents()); + QSize effectiveBufferSize = m_requestedSize * nativeWindowDevicePixelRatio; + if (m_image.devicePixelRatio() != nativeWindowDevicePixelRatio || m_image.size() != effectiveBufferSize) { + m_image = QImage(effectiveBufferSize, format()); + m_image.setDevicePixelRatio(nativeWindowDevicePixelRatio); + if (m_image.format() == QImage::Format_ARGB32_Premultiplied) + m_image.fill(Qt::transparent); } if (!m_image.hasAlphaChannel()) @@ -123,9 +112,8 @@ void QRasterBackingStore::beginPaint(const QRegion ®ion) QPainter painter(&m_image); painter.setCompositionMode(QPainter::CompositionMode_Source); - const QColor blank = Qt::transparent; for (const QRect &rect : region) - painter.fillRect(rect, blank); + painter.fillRect(rect, Qt::transparent); } QT_END_NAMESPACE diff --git a/src/platformsupport/graphics/qrasterbackingstore_p.h b/src/platformsupport/graphics/qrasterbackingstore_p.h index 55976d2ceb..357e861d1d 100644 --- a/src/platformsupport/graphics/qrasterbackingstore_p.h +++ b/src/platformsupport/graphics/qrasterbackingstore_p.h @@ -62,17 +62,18 @@ public: QRasterBackingStore(QWindow *window); ~QRasterBackingStore(); - void resize(const QSize &size, const QRegion &staticContents) Q_DECL_OVERRIDE; - bool scroll(const QRegion &area, int dx, int dy) Q_DECL_OVERRIDE; - void beginPaint(const QRegion ®ion) Q_DECL_OVERRIDE; + void resize(const QSize &size, const QRegion &staticContents) override; + bool scroll(const QRegion &area, int dx, int dy) override; + void beginPaint(const QRegion ®ion) override; - QPaintDevice *paintDevice() Q_DECL_OVERRIDE; - QImage toImage() const Q_DECL_OVERRIDE; + QPaintDevice *paintDevice() override; + QImage toImage() const override; protected: virtual QImage::Format format() const; QImage m_image; + QSize m_requestedSize; }; QT_END_NAMESPACE diff --git a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler.cpp b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler.cpp index a069a48388..47a65eded8 100644 --- a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler.cpp +++ b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler.cpp @@ -74,7 +74,7 @@ void QFdContainer::reset() Q_DECL_NOTHROW } QEvdevKeyboardHandler::QEvdevKeyboardHandler(const QString &device, QFdContainer &fd, bool disableZap, bool enableCompose, const QString &keymapFile) - : m_device(device), m_fd(fd.release()), m_notify(Q_NULLPTR), + : m_device(device), m_fd(fd.release()), m_notify(nullptr), m_modifiers(0), m_composing(0), m_dead_unicode(0xffff), m_no_zap(disableZap), m_do_compose(enableCompose), m_keymap(0), m_keymap_size(0), m_keycompose(0), m_keycompose_size(0) @@ -90,7 +90,7 @@ QEvdevKeyboardHandler::QEvdevKeyboardHandler(const QString &device, QFdContainer // socket notifier for events on the keyboard device m_notify = new QSocketNotifier(m_fd.get(), QSocketNotifier::Read, this); - connect(m_notify, SIGNAL(activated(int)), this, SLOT(readKeycode())); + connect(m_notify, &QSocketNotifier::activated, this, &QEvdevKeyboardHandler::readKeycode); } QEvdevKeyboardHandler::~QEvdevKeyboardHandler() @@ -175,7 +175,7 @@ void QEvdevKeyboardHandler::readKeycode() // by the above error over and over again. if (errno == ENODEV) { delete m_notify; - m_notify = Q_NULLPTR; + m_notify = nullptr; m_fd.reset(); } return; diff --git a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler_p.h b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler_p.h index 1ec4915855..7c64c4febb 100644 --- a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler_p.h +++ b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler_p.h @@ -145,7 +145,6 @@ public: class QEvdevKeyboardHandler : public QObject { - Q_OBJECT public: QEvdevKeyboardHandler(const QString &device, QFdContainer &fd, bool disableZap, bool enableCompose, const QString &keymapFile); ~QEvdevKeyboardHandler(); @@ -190,7 +189,6 @@ public: bool loadKeymap(const QString &file); void unloadKeymap(); -private slots: void readKeycode(); KeycodeAction processKeycode(quint16 keycode, bool pressed, bool autorepeat); diff --git a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager.cpp b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager.cpp index 94ebae8f42..85e6a80879 100644 --- a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager.cpp +++ b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager.cpp @@ -88,8 +88,10 @@ QEvdevKeyboardManager::QEvdevKeyboardManager(const QString &key, const QString & for (const QString &device : devices) addKeyboard(device); - connect(m_deviceDiscovery, SIGNAL(deviceDetected(QString)), this, SLOT(addKeyboard(QString))); - connect(m_deviceDiscovery, SIGNAL(deviceRemoved(QString)), this, SLOT(removeKeyboard(QString))); + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceDetected, + this, &QEvdevKeyboardManager::addKeyboard); + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceRemoved, + this, &QEvdevKeyboardManager::removeKeyboard); } } } diff --git a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager_p.h b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager_p.h index d2e34fead3..27ea7e468e 100644 --- a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager_p.h +++ b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardmanager_p.h @@ -63,14 +63,12 @@ QT_BEGIN_NAMESPACE class QEvdevKeyboardManager : public QObject { - Q_OBJECT public: QEvdevKeyboardManager(const QString &key, const QString &specification, QObject *parent = 0); ~QEvdevKeyboardManager(); void loadKeymap(const QString &file); -private slots: void addKeyboard(const QString &deviceNode = QString()); void removeKeyboard(const QString &deviceNode); diff --git a/src/platformsupport/input/evdevmouse/qevdevmousehandler.cpp b/src/platformsupport/input/evdevmouse/qevdevmousehandler.cpp index 9b4bcf1575..04372ae4d9 100644 --- a/src/platformsupport/input/evdevmouse/qevdevmousehandler.cpp +++ b/src/platformsupport/input/evdevmouse/qevdevmousehandler.cpp @@ -116,7 +116,8 @@ QEvdevMouseHandler::QEvdevMouseHandler(const QString &device, int fd, bool abs, // socket notifier for events on the mouse device m_notify = new QSocketNotifier(m_fd, QSocketNotifier::Read, this); - connect(m_notify, SIGNAL(activated(int)), this, SLOT(readMouseData())); + connect(m_notify, &QSocketNotifier::activated, + this, &QEvdevMouseHandler::readMouseData); } QEvdevMouseHandler::~QEvdevMouseHandler() @@ -183,7 +184,7 @@ void QEvdevMouseHandler::sendMouseEvent() m_prevInvalid = false; } - emit handleMouseEvent(x, y, m_abs, m_buttons); + emit handleMouseEvent(x, y, m_abs, m_buttons, m_button, m_eventType); m_prevx = m_x; m_prevy = m_y; @@ -209,7 +210,7 @@ void QEvdevMouseHandler::readMouseData() // by the above error over and over again. if (errno == ENODEV) { delete m_notify; - m_notify = Q_NULLPTR; + m_notify = nullptr; qt_safe_close(m_fd); m_fd = -1; } @@ -236,6 +237,7 @@ void QEvdevMouseHandler::readMouseData() posChanged = true; } } else if (data->type == EV_REL) { + QPoint delta; if (data->code == REL_X) { m_x += data->value; posChanged = true; @@ -244,12 +246,18 @@ void QEvdevMouseHandler::readMouseData() posChanged = true; } else if (data->code == ABS_WHEEL) { // vertical scroll // data->value: 1 == up, -1 == down - const int delta = 120 * data->value; - emit handleWheelEvent(delta, Qt::Vertical); + if (data->value == 1) + delta.setY(120); + else + delta.setY(-120); + emit handleWheelEvent(delta); } else if (data->code == ABS_THROTTLE) { // horizontal scroll // data->value: 1 == right, -1 == left - const int delta = 120 * -data->value; - emit handleWheelEvent(delta, Qt::Horizontal); + if (data->value == 1) + delta.setX(-120); + else + delta.setX(120); + emit handleWheelEvent(delta); } } else if (data->type == EV_KEY && data->code == BTN_TOUCH) { // We care about touchpads only, not touchscreens -> don't map to button press. @@ -278,6 +286,8 @@ void QEvdevMouseHandler::readMouseData() case 0x11f: button = Qt::ExtraButton13; break; } m_buttons.setFlag(button, data->value); + m_button = button; + m_eventType = data->value == 0 ? QEvent::MouseButtonRelease : QEvent::MouseButtonPress; btnChanged = true; } else if (data->type == EV_SYN && data->code == SYN_REPORT) { if (btnChanged) { @@ -285,6 +295,7 @@ void QEvdevMouseHandler::readMouseData() sendMouseEvent(); pendingMouseEvent = false; } else if (posChanged) { + m_eventType = QEvent::MouseMove; posChanged = false; if (m_compression) { pendingMouseEvent = true; diff --git a/src/platformsupport/input/evdevmouse/qevdevmousehandler_p.h b/src/platformsupport/input/evdevmouse/qevdevmousehandler_p.h index eb34334b12..c7f2b04eb2 100644 --- a/src/platformsupport/input/evdevmouse/qevdevmousehandler_p.h +++ b/src/platformsupport/input/evdevmouse/qevdevmousehandler_p.h @@ -53,6 +53,8 @@ #include <QObject> #include <QString> +#include <QPoint> +#include <QEvent> QT_BEGIN_NAMESPACE @@ -65,13 +67,13 @@ public: static QEvdevMouseHandler *create(const QString &device, const QString &specification); ~QEvdevMouseHandler(); -signals: - void handleMouseEvent(int x, int y, bool abs, Qt::MouseButtons buttons); - void handleWheelEvent(int delta, Qt::Orientation orientation); - -private slots: void readMouseData(); +signals: + void handleMouseEvent(int x, int y, bool abs, Qt::MouseButtons buttons, + Qt::MouseButton button, QEvent::Type type); + void handleWheelEvent(QPoint delta); + private: QEvdevMouseHandler(const QString &device, int fd, bool abs, bool compression, int jitterLimit); @@ -86,6 +88,8 @@ private: bool m_abs; bool m_compression; Qt::MouseButtons m_buttons; + Qt::MouseButton m_button; + QEvent::Type m_eventType; int m_jitterLimitSquared; bool m_prevInvalid; int m_hardwareWidth; diff --git a/src/platformsupport/input/evdevmouse/qevdevmousemanager.cpp b/src/platformsupport/input/evdevmouse/qevdevmousemanager.cpp index b2f3fe5787..5264736dd6 100644 --- a/src/platformsupport/input/evdevmouse/qevdevmousemanager.cpp +++ b/src/platformsupport/input/evdevmouse/qevdevmousemanager.cpp @@ -94,13 +94,19 @@ QEvdevMouseManager::QEvdevMouseManager(const QString &key, const QString &specif for (const QString &device : devices) addMouse(device); - connect(m_deviceDiscovery, SIGNAL(deviceDetected(QString)), this, SLOT(addMouse(QString))); - connect(m_deviceDiscovery, SIGNAL(deviceRemoved(QString)), this, SLOT(removeMouse(QString))); + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceDetected, + this, &QEvdevMouseManager::addMouse); + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceRemoved, + this, &QEvdevMouseManager::removeMouse); } } - connect(QGuiApplicationPrivate::inputDeviceManager(), SIGNAL(cursorPositionChangeRequested(QPoint)), - this, SLOT(handleCursorPositionChange(QPoint))); + QInputDeviceManager *manager = QGuiApplicationPrivate::inputDeviceManager(); + connect(manager, &QInputDeviceManager::cursorPositionChangeRequested, [=](const QPoint &pos) { + m_x = pos.x(); + m_y = pos.y(); + clampPosition(); + }); } QEvdevMouseManager::~QEvdevMouseManager() @@ -125,7 +131,8 @@ void QEvdevMouseManager::clampPosition() m_y = g.bottom() - m_yoffset; } -void QEvdevMouseManager::handleMouseEvent(int x, int y, bool abs, Qt::MouseButtons buttons) +void QEvdevMouseManager::handleMouseEvent(int x, int y, bool abs, Qt::MouseButtons buttons, + Qt::MouseButton button, QEvent::Type type) { // update current absolute coordinates if (!abs) { @@ -141,23 +148,25 @@ void QEvdevMouseManager::handleMouseEvent(int x, int y, bool abs, Qt::MouseButto QPoint pos(m_x + m_xoffset, m_y + m_yoffset); // Cannot track the keyboard modifiers ourselves here. Instead, report the // modifiers from the last key event that has been seen by QGuiApplication. - QWindowSystemInterface::handleMouseEvent(0, pos, pos, buttons, QGuiApplication::keyboardModifiers()); + Qt::KeyboardModifiers mods = QGuiApplication::keyboardModifiers(); + QWindowSystemInterface::handleMouseEvent(0, pos, pos, buttons, button, type, mods); } -void QEvdevMouseManager::handleWheelEvent(int delta, Qt::Orientation orientation) +void QEvdevMouseManager::handleWheelEvent(QPoint delta) { QPoint pos(m_x + m_xoffset, m_y + m_yoffset); - QWindowSystemInterface::handleWheelEvent(0, pos, pos, delta, orientation, QGuiApplication::keyboardModifiers()); + QWindowSystemInterface::handleWheelEvent(0, pos, pos, QPoint(), delta, QGuiApplication::keyboardModifiers()); } void QEvdevMouseManager::addMouse(const QString &deviceNode) { qCDebug(qLcEvdevMouse) << "Adding mouse at" << deviceNode; - QEvdevMouseHandler *handler; - handler = QEvdevMouseHandler::create(deviceNode, m_spec); + QEvdevMouseHandler *handler = QEvdevMouseHandler::create(deviceNode, m_spec); if (handler) { - connect(handler, SIGNAL(handleMouseEvent(int,int,bool,Qt::MouseButtons)), this, SLOT(handleMouseEvent(int,int,bool,Qt::MouseButtons))); - connect(handler, SIGNAL(handleWheelEvent(int,Qt::Orientation)), this, SLOT(handleWheelEvent(int,Qt::Orientation))); + connect(handler, &QEvdevMouseHandler::handleMouseEvent, + this, &QEvdevMouseManager::handleMouseEvent); + connect(handler, &QEvdevMouseHandler::handleWheelEvent, + this, &QEvdevMouseManager::handleWheelEvent); m_mice.insert(deviceNode, handler); QInputDeviceManagerPrivate::get(QGuiApplicationPrivate::inputDeviceManager())->setDeviceCount( QInputDeviceManager::DeviceTypePointer, m_mice.count()); @@ -178,11 +187,4 @@ void QEvdevMouseManager::removeMouse(const QString &deviceNode) } } -void QEvdevMouseManager::handleCursorPositionChange(const QPoint &pos) -{ - m_x = pos.x(); - m_y = pos.y(); - clampPosition(); -} - QT_END_NAMESPACE diff --git a/src/platformsupport/input/evdevmouse/qevdevmousemanager_p.h b/src/platformsupport/input/evdevmouse/qevdevmousemanager_p.h index 08b5409d31..13a8e3dec5 100644 --- a/src/platformsupport/input/evdevmouse/qevdevmousemanager_p.h +++ b/src/platformsupport/input/evdevmouse/qevdevmousemanager_p.h @@ -56,6 +56,7 @@ #include <QObject> #include <QHash> #include <QSocketNotifier> +#include <QPoint> QT_BEGIN_NAMESPACE @@ -63,19 +64,16 @@ class QDeviceDiscovery; class QEvdevMouseManager : public QObject { - Q_OBJECT public: QEvdevMouseManager(const QString &key, const QString &specification, QObject *parent = 0); ~QEvdevMouseManager(); -public slots: - void handleMouseEvent(int x, int y, bool abs, Qt::MouseButtons buttons); - void handleWheelEvent(int delta, Qt::Orientation orientation); + void handleMouseEvent(int x, int y, bool abs, Qt::MouseButtons buttons, + Qt::MouseButton button, QEvent::Type type); + void handleWheelEvent(QPoint delta); -private slots: void addMouse(const QString &deviceNode = QString()); void removeMouse(const QString &deviceNode); - void handleCursorPositionChange(const QPoint &pos); private: void clampPosition(); diff --git a/src/platformsupport/input/evdevtablet/qevdevtablethandler.cpp b/src/platformsupport/input/evdevtablet/qevdevtablethandler.cpp index cfc17a79c3..dbab2f6a24 100644 --- a/src/platformsupport/input/evdevtablet/qevdevtablethandler.cpp +++ b/src/platformsupport/input/evdevtablet/qevdevtablethandler.cpp @@ -149,9 +149,11 @@ void QEvdevTabletData::report() qreal pressure = pressureRange ? (state.p - minValues.p) / qreal(pressureRange) : qreal(1); if (state.down || state.lastReportDown) { - QWindowSystemInterface::handleTabletEvent(0, state.down, QPointF(), globalPos, + QWindowSystemInterface::handleTabletEvent(0, QPointF(), globalPos, QTabletEvent::Stylus, pointer, - pressure, 0, 0, 0, 0, 0, q->deviceId(), qGuiApp->keyboardModifiers()); + state.down ? Qt::LeftButton : Qt::NoButton, + pressure, 0, 0, 0, 0, 0, q->deviceId(), + qGuiApp->keyboardModifiers()); } if (state.lastReportTool && !state.tool) diff --git a/src/platformsupport/input/evdevtablet/qevdevtablethandler_p.h b/src/platformsupport/input/evdevtablet/qevdevtablethandler_p.h index 20dfda89f7..66e821117a 100644 --- a/src/platformsupport/input/evdevtablet/qevdevtablethandler_p.h +++ b/src/platformsupport/input/evdevtablet/qevdevtablethandler_p.h @@ -63,15 +63,12 @@ class QEvdevTabletData; class QEvdevTabletHandler : public QObject { - Q_OBJECT - public: explicit QEvdevTabletHandler(const QString &device, const QString &spec = QString(), QObject *parent = 0); ~QEvdevTabletHandler(); qint64 deviceId() const; -private slots: void readData(); private: @@ -88,7 +85,7 @@ class QEvdevTabletHandlerThread : public QDaemonThread public: explicit QEvdevTabletHandlerThread(const QString &device, const QString &spec, QObject *parent = 0); ~QEvdevTabletHandlerThread(); - void run() Q_DECL_OVERRIDE; + void run() override; QEvdevTabletHandler *handler() { return m_handler; } private: diff --git a/src/platformsupport/input/evdevtablet/qevdevtabletmanager.cpp b/src/platformsupport/input/evdevtablet/qevdevtabletmanager.cpp index 4b00424e92..90949408ac 100644 --- a/src/platformsupport/input/evdevtablet/qevdevtabletmanager.cpp +++ b/src/platformsupport/input/evdevtablet/qevdevtabletmanager.cpp @@ -88,8 +88,11 @@ QEvdevTabletManager::QEvdevTabletManager(const QString &key, const QString &spec const QStringList devices = m_deviceDiscovery->scanConnectedDevices(); for (const QString &device : devices) addDevice(device); - connect(m_deviceDiscovery, SIGNAL(deviceDetected(QString)), this, SLOT(addDevice(QString))); - connect(m_deviceDiscovery, SIGNAL(deviceRemoved(QString)), this, SLOT(removeDevice(QString))); + + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceDetected, + this, &QEvdevTabletManager::addDevice); + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceRemoved, + this, &QEvdevTabletManager::removeDevice); } } } diff --git a/src/platformsupport/input/evdevtablet/qevdevtabletmanager_p.h b/src/platformsupport/input/evdevtablet/qevdevtabletmanager_p.h index d166c06cf3..cde91c55aa 100644 --- a/src/platformsupport/input/evdevtablet/qevdevtabletmanager_p.h +++ b/src/platformsupport/input/evdevtablet/qevdevtabletmanager_p.h @@ -62,12 +62,10 @@ class QEvdevTabletHandlerThread; class QEvdevTabletManager : public QObject { - Q_OBJECT public: QEvdevTabletManager(const QString &key, const QString &spec, QObject *parent = 0); ~QEvdevTabletManager(); -private slots: void addDevice(const QString &deviceNode); void removeDevice(const QString &deviceNode); diff --git a/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp b/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp index 5d839cced7..7b7649bc5c 100644 --- a/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp +++ b/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp @@ -148,7 +148,7 @@ public: mutable QPointer<QScreen> m_screen; // Touch filtering and prediction are part of the same thing. The default - // prediction is 0ms, but sensible results can be acheived by setting it + // prediction is 0ms, but sensible results can be achieved by setting it // to, for instance, 16ms. // For filtering to work well, the QPA plugin should provide a dead-steady // implementation of QPlatformWindow::requestUpdate(). @@ -192,9 +192,9 @@ static inline bool testBit(long bit, const long *array) #endif QEvdevTouchScreenHandler::QEvdevTouchScreenHandler(const QString &device, const QString &spec, QObject *parent) - : QObject(parent), m_notify(Q_NULLPTR), m_fd(-1), d(Q_NULLPTR), m_device(Q_NULLPTR) + : QObject(parent), m_notify(nullptr), m_fd(-1), d(nullptr), m_device(nullptr) #if QT_CONFIG(mtdev) - , m_mtdev(Q_NULLPTR) + , m_mtdev(nullptr) #endif { setObjectName(QLatin1String("Evdev Touch Handler")); @@ -231,7 +231,7 @@ QEvdevTouchScreenHandler::QEvdevTouchScreenHandler(const QString &device, const if (m_fd >= 0) { m_notify = new QSocketNotifier(m_fd, QSocketNotifier::Read, this); - connect(m_notify, SIGNAL(activated(int)), this, SLOT(readData())); + connect(m_notify, &QSocketNotifier::activated, this, &QEvdevTouchScreenHandler::readData); } else { qErrnoWarning(errno, "evdevtouch: Cannot open input device %s", qPrintable(device)); return; @@ -427,7 +427,7 @@ err: qErrnoWarning(errno, "evdevtouch: Could not read from input device"); if (errno == ENODEV) { // device got disconnected -> stop reading delete m_notify; - m_notify = Q_NULLPTR; + m_notify = nullptr; QT_CLOSE(m_fd); m_fd = -1; @@ -466,7 +466,7 @@ void QEvdevTouchScreenHandler::unregisterTouchDevice() delete m_device; } - m_device = Q_NULLPTR; + m_device = nullptr; } void QEvdevTouchScreenData::addTouchPoint(const Contact &contact, Qt::TouchPointStates *combinedStates) @@ -781,13 +781,13 @@ void QEvdevTouchScreenData::reportPoints() if (m_filtered) emit q->touchPointsUpdated(); else - QWindowSystemInterface::handleTouchEvent(Q_NULLPTR, q->touchDevice(), m_touchPoints); + QWindowSystemInterface::handleTouchEvent(nullptr, q->touchDevice(), m_touchPoints); } QEvdevTouchScreenHandlerThread::QEvdevTouchScreenHandlerThread(const QString &device, const QString &spec, QObject *parent) - : QDaemonThread(parent), m_device(device), m_spec(spec), m_handler(Q_NULLPTR), m_touchDeviceRegistered(false) + : QDaemonThread(parent), m_device(device), m_spec(spec), m_handler(nullptr), m_touchDeviceRegistered(false) , m_touchUpdatePending(false) - , m_filterWindow(Q_NULLPTR) + , m_filterWindow(nullptr) , m_touchRate(-1) { start(); @@ -812,7 +812,7 @@ void QEvdevTouchScreenHandlerThread::run() exec(); delete m_handler; - m_handler = Q_NULLPTR; + m_handler = nullptr; } bool QEvdevTouchScreenHandlerThread::isTouchDeviceRegistered() const @@ -885,7 +885,7 @@ void QEvdevTouchScreenHandlerThread::filterAndSendTouchPoints() } QList<QWindowSystemInterface::TouchPoint> points = m_handler->d->m_touchPoints; - const QList<QWindowSystemInterface::TouchPoint> &lastPoints = m_handler->d->m_lastTouchPoints; + QList<QWindowSystemInterface::TouchPoint> lastPoints = m_handler->d->m_lastTouchPoints; m_handler->d->m_mutex.unlock(); @@ -953,7 +953,7 @@ void QEvdevTouchScreenHandlerThread::filterAndSendTouchPoints() m_filteredPoints = filteredPoints; - QWindowSystemInterface::handleTouchEvent(Q_NULLPTR, + QWindowSystemInterface::handleTouchEvent(nullptr, m_handler->touchDevice(), points); } diff --git a/src/platformsupport/input/evdevtouch/qevdevtouchhandler_p.h b/src/platformsupport/input/evdevtouch/qevdevtouchhandler_p.h index d22aca3266..56308d0352 100644 --- a/src/platformsupport/input/evdevtouch/qevdevtouchhandler_p.h +++ b/src/platformsupport/input/evdevtouch/qevdevtouchhandler_p.h @@ -75,14 +75,13 @@ class QEvdevTouchScreenHandler : public QObject Q_OBJECT public: - explicit QEvdevTouchScreenHandler(const QString &device, const QString &spec = QString(), QObject *parent = Q_NULLPTR); + explicit QEvdevTouchScreenHandler(const QString &device, const QString &spec = QString(), QObject *parent = nullptr); ~QEvdevTouchScreenHandler(); QTouchDevice *touchDevice() const; bool isFiltered() const; -private slots: void readData(); signals: @@ -108,15 +107,14 @@ class QEvdevTouchScreenHandlerThread : public QDaemonThread { Q_OBJECT public: - explicit QEvdevTouchScreenHandlerThread(const QString &device, const QString &spec, QObject *parent = Q_NULLPTR); + explicit QEvdevTouchScreenHandlerThread(const QString &device, const QString &spec, QObject *parent = nullptr); ~QEvdevTouchScreenHandlerThread(); - void run() Q_DECL_OVERRIDE; + void run() override; bool isTouchDeviceRegistered() const; - bool eventFilter(QObject *object, QEvent *event) Q_DECL_OVERRIDE; + bool eventFilter(QObject *object, QEvent *event) override; -public slots: void scheduleTouchPointUpdate(); signals: diff --git a/src/platformsupport/input/evdevtouch/qevdevtouchmanager.cpp b/src/platformsupport/input/evdevtouch/qevdevtouchmanager.cpp index ab71d08fb1..4cacbf03e5 100644 --- a/src/platformsupport/input/evdevtouch/qevdevtouchmanager.cpp +++ b/src/platformsupport/input/evdevtouch/qevdevtouchmanager.cpp @@ -88,8 +88,11 @@ QEvdevTouchManager::QEvdevTouchManager(const QString &key, const QString &specif const QStringList devices = m_deviceDiscovery->scanConnectedDevices(); for (const QString &device : devices) addDevice(device); - connect(m_deviceDiscovery, SIGNAL(deviceDetected(QString)), this, SLOT(addDevice(QString))); - connect(m_deviceDiscovery, SIGNAL(deviceRemoved(QString)), this, SLOT(removeDevice(QString))); + + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceDetected, + this, &QEvdevTouchManager::addDevice); + connect(m_deviceDiscovery, &QDeviceDiscovery::deviceRemoved, + this, &QEvdevTouchManager::removeDevice); } } } diff --git a/src/platformsupport/input/evdevtouch/qevdevtouchmanager_p.h b/src/platformsupport/input/evdevtouch/qevdevtouchmanager_p.h index 84e857ca57..e524c516f1 100644 --- a/src/platformsupport/input/evdevtouch/qevdevtouchmanager_p.h +++ b/src/platformsupport/input/evdevtouch/qevdevtouchmanager_p.h @@ -62,12 +62,10 @@ class QEvdevTouchScreenHandlerThread; class QEvdevTouchManager : public QObject { - Q_OBJECT public: QEvdevTouchManager(const QString &key, const QString &spec, QObject *parent = 0); ~QEvdevTouchManager(); -private slots: void addDevice(const QString &deviceNode); void removeDevice(const QString &deviceNode); diff --git a/src/platformsupport/input/integrityhid/qintegrityhidmanager.cpp b/src/platformsupport/input/integrityhid/qintegrityhidmanager.cpp index 8089a6e38b..e472693077 100644 --- a/src/platformsupport/input/integrityhid/qintegrityhidmanager.cpp +++ b/src/platformsupport/input/integrityhid/qintegrityhidmanager.cpp @@ -75,8 +75,8 @@ public: { CheckSuccess(gh_hid_close(handle)); }; - void process_event(void) Q_DECL_OVERRIDE; - void async_wait(void) Q_DECL_OVERRIDE; + void process_event(void) override; + void async_wait(void) override; HIDDriver *get_driver(void) { return driver; }; HIDHandle get_handle(void) { return handle; }; private: @@ -94,8 +94,8 @@ public: { qDeleteAll(devices); }; - void process_event(void) Q_DECL_OVERRIDE; - void async_wait(void) Q_DECL_OVERRIDE; + void process_event(void) override; + void async_wait(void) override; void find_devices(void); private: QHash<Value, HIDDeviceHandler *> devices; diff --git a/src/platformsupport/input/libinput/qlibinputhandler.cpp b/src/platformsupport/input/libinput/qlibinputhandler.cpp index 961eb3539f..52eaa18f4b 100644 --- a/src/platformsupport/input/libinput/qlibinputhandler.cpp +++ b/src/platformsupport/input/libinput/qlibinputhandler.cpp @@ -94,7 +94,7 @@ QLibInputHandler::QLibInputHandler(const QString &key, const QString &spec) if (Q_UNLIKELY(!m_udev)) qFatal("Failed to get udev context for libinput"); - m_li = libinput_udev_create_context(&liInterface, Q_NULLPTR, m_udev); + m_li = libinput_udev_create_context(&liInterface, nullptr, m_udev); if (Q_UNLIKELY(!m_li)) qFatal("Failed to get libinput context"); @@ -107,14 +107,17 @@ QLibInputHandler::QLibInputHandler(const QString &key, const QString &spec) m_liFd = libinput_get_fd(m_li); m_notifier.reset(new QSocketNotifier(m_liFd, QSocketNotifier::Read)); - connect(m_notifier.data(), SIGNAL(activated(int)), SLOT(onReadyRead())); + + connect(m_notifier.data(), &QSocketNotifier::activated, this, &QLibInputHandler::onReadyRead); m_pointer.reset(new QLibInputPointer); m_keyboard.reset(new QLibInputKeyboard); m_touch.reset(new QLibInputTouch); - connect(QGuiApplicationPrivate::inputDeviceManager(), SIGNAL(cursorPositionChangeRequested(QPoint)), - this, SLOT(onCursorPositionChangeRequested(QPoint))); + QInputDeviceManager *manager = QGuiApplicationPrivate::inputDeviceManager(); + connect(manager, &QInputDeviceManager::cursorPositionChangeRequested, [=](const QPoint &pos) { + m_pointer->setPos(pos); + }); // Process the initial burst of DEVICE_ADDED events. onReadyRead(); @@ -137,7 +140,7 @@ void QLibInputHandler::onReadyRead() } libinput_event *ev; - while ((ev = libinput_get_event(m_li)) != Q_NULLPTR) { + while ((ev = libinput_get_event(m_li)) != nullptr) { processEvent(ev); libinput_event_destroy(ev); } @@ -154,10 +157,6 @@ void QLibInputHandler::processEvent(libinput_event *ev) // This is not just for hotplugging, it is also called for each input // device libinput reads from on startup. Hence it is suitable for doing // touch device registration. - const char *sysname = libinput_device_get_sysname(dev); // node name without path - const char *name = libinput_device_get_name(dev); - emit deviceAdded(QString::fromUtf8(sysname), QString::fromUtf8(name)); - QInputDeviceManagerPrivate *inputManagerPriv = QInputDeviceManagerPrivate::get( QGuiApplicationPrivate::inputDeviceManager()); if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_TOUCH)) { @@ -180,10 +179,6 @@ void QLibInputHandler::processEvent(libinput_event *ev) } case LIBINPUT_EVENT_DEVICE_REMOVED: { - const char *sysname = libinput_device_get_sysname(dev); - const char *name = libinput_device_get_name(dev); - emit deviceRemoved(QString::fromUtf8(sysname), QString::fromUtf8(name)); - QInputDeviceManagerPrivate *inputManagerPriv = QInputDeviceManagerPrivate::get( QGuiApplicationPrivate::inputDeviceManager()); if (libinput_device_has_capability(dev, LIBINPUT_DEVICE_CAP_TOUCH)) { @@ -236,9 +231,4 @@ void QLibInputHandler::processEvent(libinput_event *ev) } } -void QLibInputHandler::onCursorPositionChangeRequested(const QPoint &pos) -{ - m_pointer->setPos(pos); -} - QT_END_NAMESPACE diff --git a/src/platformsupport/input/libinput/qlibinputhandler_p.h b/src/platformsupport/input/libinput/qlibinputhandler_p.h index f3dcf0f0be..ac7a267a4d 100644 --- a/src/platformsupport/input/libinput/qlibinputhandler_p.h +++ b/src/platformsupport/input/libinput/qlibinputhandler_p.h @@ -68,19 +68,11 @@ class QLibInputTouch; class QLibInputHandler : public QObject { - Q_OBJECT - public: QLibInputHandler(const QString &key, const QString &spec); ~QLibInputHandler(); -signals: - void deviceAdded(const QString &sysname, const QString &name); - void deviceRemoved(const QString &sysname, const QString &name); - -private slots: void onReadyRead(); - void onCursorPositionChangeRequested(const QPoint &pos); private: void processEvent(libinput_event *ev); diff --git a/src/platformsupport/input/libinput/qlibinputkeyboard.cpp b/src/platformsupport/input/libinput/qlibinputkeyboard.cpp index 3722c1ceca..ec01f95947 100644 --- a/src/platformsupport/input/libinput/qlibinputkeyboard.cpp +++ b/src/platformsupport/input/libinput/qlibinputkeyboard.cpp @@ -145,7 +145,7 @@ QLibInputKeyboard::QLibInputKeyboard() qWarning("Failed to create xkb context"); return; } - m_keymap = xkb_keymap_new_from_names(m_ctx, Q_NULLPTR, XKB_KEYMAP_COMPILE_NO_FLAGS); + m_keymap = xkb_keymap_new_from_names(m_ctx, nullptr, XKB_KEYMAP_COMPILE_NO_FLAGS); if (!m_keymap) { qWarning("Failed to compile keymap"); return; @@ -216,8 +216,7 @@ void QLibInputKeyboard::processKey(libinput_event_keyboard *e) xkb_state_update_key(m_state, k, pressed ? XKB_KEY_DOWN : XKB_KEY_UP); QGuiApplicationPrivate::inputDeviceManager()->setKeyboardModifiers(mods, qtkey); - - QWindowSystemInterface::handleExtendedKeyEvent(Q_NULLPTR, + QWindowSystemInterface::handleExtendedKeyEvent(nullptr, pressed ? QEvent::KeyPress : QEvent::KeyRelease, qtkey, mods, k, sym, mods, text); @@ -243,7 +242,7 @@ void QLibInputKeyboard::processKey(libinput_event_keyboard *e) #ifndef QT_NO_XKBCOMMON_EVDEV void QLibInputKeyboard::handleRepeat() { - QWindowSystemInterface::handleExtendedKeyEvent(Q_NULLPTR, QEvent::KeyPress, + QWindowSystemInterface::handleExtendedKeyEvent(nullptr, QEvent::KeyPress, m_repeatData.qtkey, m_repeatData.mods, m_repeatData.nativeScanCode, m_repeatData.virtualKey, m_repeatData.nativeMods, m_repeatData.unicodeText, true, m_repeatData.repeatCount); @@ -287,7 +286,7 @@ int QLibInputKeyboard::keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers *modifiers |= Qt::KeypadModifier; } else if (text.length() == 1 && text.unicode()->unicode() > 0x1f && text.unicode()->unicode() != 0x7f - && !(keysym >= XKB_KEY_dead_grave && keysym <= XKB_KEY_dead_currency)) { + && !(keysym >= XKB_KEY_dead_grave && keysym <= XKB_KEY_dead_longsolidusoverlay)) { code = text.unicode()->toUpper().unicode(); } else { // any other keys diff --git a/src/platformsupport/input/libinput/qlibinputkeyboard_p.h b/src/platformsupport/input/libinput/qlibinputkeyboard_p.h index 12a3eb06eb..b7ee8a363f 100644 --- a/src/platformsupport/input/libinput/qlibinputkeyboard_p.h +++ b/src/platformsupport/input/libinput/qlibinputkeyboard_p.h @@ -64,8 +64,6 @@ QT_BEGIN_NAMESPACE class QLibInputKeyboard : public QObject { - Q_OBJECT - public: QLibInputKeyboard(); ~QLibInputKeyboard(); @@ -73,7 +71,6 @@ public: void processKey(libinput_event_keyboard *e); #ifndef QT_NO_XKBCOMMON_EVDEV -private slots: void handleRepeat(); private: diff --git a/src/platformsupport/input/libinput/qlibinputpointer.cpp b/src/platformsupport/input/libinput/qlibinputpointer.cpp index 734d2fbbc0..cb08ab53b2 100644 --- a/src/platformsupport/input/libinput/qlibinputpointer.cpp +++ b/src/platformsupport/input/libinput/qlibinputpointer.cpp @@ -39,6 +39,7 @@ #include "qlibinputpointer_p.h" #include <libinput.h> +#include <QtCore/QEvent> #include <QtGui/QGuiApplication> #include <QtGui/QScreen> #include <QtGui/private/qguiapplication_p.h> @@ -80,8 +81,10 @@ void QLibInputPointer::processButton(libinput_event_pointer *e) m_buttons.setFlag(button, pressed); - QWindowSystemInterface::handleMouseEvent(Q_NULLPTR, m_pos, m_pos, m_buttons, - QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers()); + QEvent::Type type = pressed ? QEvent::MouseButtonPress : QEvent::MouseButtonRelease; + Qt::KeyboardModifiers mods = QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers(); + + QWindowSystemInterface::handleMouseEvent(nullptr, m_pos, m_pos, m_buttons, button, type, mods); } void QLibInputPointer::processMotion(libinput_event_pointer *e) @@ -94,30 +97,36 @@ void QLibInputPointer::processMotion(libinput_event_pointer *e) m_pos.setX(qBound(g.left(), qRound(m_pos.x() + dx), g.right())); m_pos.setY(qBound(g.top(), qRound(m_pos.y() + dy), g.bottom())); - QWindowSystemInterface::handleMouseEvent(Q_NULLPTR, m_pos, m_pos, m_buttons, - QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers()); + Qt::KeyboardModifiers mods = QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers(); + + QWindowSystemInterface::handleMouseEvent(nullptr, m_pos, m_pos, m_buttons, + Qt::NoButton, QEvent::MouseMove, mods); } void QLibInputPointer::processAxis(libinput_event_pointer *e) { + double value; // default axis value is 15 degrees per wheel click + QPoint angleDelta; #if !QT_CONFIG(libinput_axis_api) - const double v = libinput_event_pointer_get_axis_value(e) * 120; - const Qt::Orientation ori = libinput_event_pointer_get_axis(e) == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL - ? Qt::Vertical : Qt::Horizontal; - QWindowSystemInterface::handleWheelEvent(Q_NULLPTR, m_pos, m_pos, qRound(-v), ori, - QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers()); + value = libinput_event_pointer_get_axis_value(e); + if (libinput_event_pointer_get_axis(e) == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL) + angleDelta.setY(qRound(value)); + else + angleDelta.setX(qRound(value)); #else if (libinput_event_pointer_has_axis(e, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL)) { - const double v = libinput_event_pointer_get_axis_value(e, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL) * 120; - QWindowSystemInterface::handleWheelEvent(Q_NULLPTR, m_pos, m_pos, qRound(-v), Qt::Vertical, - QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers()); + value = libinput_event_pointer_get_axis_value(e, LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL); + angleDelta.setY(qRound(value)); } if (libinput_event_pointer_has_axis(e, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) { - const double v = libinput_event_pointer_get_axis_value(e, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL) * 120; - QWindowSystemInterface::handleWheelEvent(Q_NULLPTR, m_pos, m_pos, qRound(-v), Qt::Horizontal, - QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers()); + value = libinput_event_pointer_get_axis_value(e, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL); + angleDelta.setX(qRound(value)); } #endif + const int factor = 8; + angleDelta *= -factor; + Qt::KeyboardModifiers mods = QGuiApplication::keyboardModifiers(); + QWindowSystemInterface::handleWheelEvent(nullptr, m_pos, m_pos, QPoint(), angleDelta, mods); } void QLibInputPointer::setPos(const QPoint &pos) diff --git a/src/platformsupport/input/libinput/qlibinputtouch.cpp b/src/platformsupport/input/libinput/qlibinputtouch.cpp index 42925a18e1..a65bc91c39 100644 --- a/src/platformsupport/input/libinput/qlibinputtouch.cpp +++ b/src/platformsupport/input/libinput/qlibinputtouch.cpp @@ -53,7 +53,7 @@ QWindowSystemInterface::TouchPoint *QLibInputTouch::DeviceState::point(int32_t s if (m_points.at(i).id == id) return &m_points[i]; - return Q_NULLPTR; + return nullptr; } QLibInputTouch::DeviceState *QLibInputTouch::deviceState(libinput_event_touch *e) @@ -150,7 +150,7 @@ void QLibInputTouch::processTouchCancel(libinput_event_touch *e) { DeviceState *state = deviceState(e); if (state->m_touchDevice) - QWindowSystemInterface::handleTouchCancelEvent(Q_NULLPTR, state->m_touchDevice, QGuiApplication::keyboardModifiers()); + QWindowSystemInterface::handleTouchCancelEvent(nullptr, state->m_touchDevice, QGuiApplication::keyboardModifiers()); else qWarning("TouchCancel without registered device"); } @@ -165,7 +165,7 @@ void QLibInputTouch::processTouchFrame(libinput_event_touch *e) if (state->m_points.isEmpty()) return; - QWindowSystemInterface::handleTouchEvent(Q_NULLPTR, state->m_touchDevice, state->m_points, + QWindowSystemInterface::handleTouchEvent(nullptr, state->m_touchDevice, state->m_points, QGuiApplication::keyboardModifiers()); for (int i = 0; i < state->m_points.count(); ++i) { diff --git a/src/platformsupport/kmsconvenience/qkmsdevice.cpp b/src/platformsupport/kmsconvenience/qkmsdevice.cpp index a8eefe65ed..59db3da776 100644 --- a/src/platformsupport/kmsconvenience/qkmsdevice.cpp +++ b/src/platformsupport/kmsconvenience/qkmsdevice.cpp @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2017 The Qt Company Ltd. ** Copyright (C) 2016 Pelagicore AG ** Copyright (C) 2015 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com> ** Contact: https://www.qt.io/licensing/ @@ -47,6 +47,8 @@ #include <QtCore/QFile> #include <QtCore/QLoggingCategory> +#include <errno.h> + #define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) QT_BEGIN_NAMESPACE @@ -75,7 +77,7 @@ int QKmsDevice::crtcForConnector(drmModeResPtr resources, drmModeConnectorPtr co for (int j = 0; j < resources->count_crtcs; j++) { bool isPossible = possibleCrtcs & (1 << j); - bool isAvailable = !(m_crtc_allocator & 1 << resources->crtcs[j]); + bool isAvailable = !(m_crtc_allocator & (1 << j)); if (isPossible && isAvailable) return j; @@ -162,22 +164,24 @@ static bool parseModeline(const QByteArray &text, drmModeModeInfoPtr mode) QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, drmModeConnectorPtr connector, - VirtualDesktopInfo *vinfo) + ScreenInfo *vinfo) { + Q_ASSERT(vinfo); const QByteArray connectorName = nameForConnector(connector); const int crtc = crtcForConnector(resources, connector); if (crtc < 0) { qWarning() << "No usable crtc/encoder pair for connector" << connectorName; - return Q_NULLPTR; + return nullptr; } OutputConfiguration configuration; QSize configurationSize; + int configurationRefresh = 0; drmModeModeInfo configurationModeline; auto userConfig = m_screenConfig->outputSettings(); - auto userConnectorConfig = userConfig.value(QString::fromUtf8(connectorName)); + QVariantMap userConnectorConfig = userConfig.value(QString::fromUtf8(connectorName)); // default to the preferred mode unless overridden in the config const QByteArray mode = userConnectorConfig.value(QStringLiteral("mode"), QStringLiteral("preferred")) .toByteArray().toLower(); @@ -187,6 +191,10 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, configuration = OutputConfigPreferred; } else if (mode == "current") { configuration = OutputConfigCurrent; + } else if (sscanf(mode.constData(), "%dx%d@%d", &configurationSize.rwidth(), &configurationSize.rheight(), + &configurationRefresh) == 3) + { + configuration = OutputConfigMode; } else if (sscanf(mode.constData(), "%dx%d", &configurationSize.rwidth(), &configurationSize.rheight()) == 2) { configuration = OutputConfigMode; } else if (parseModeline(mode, &configurationModeline)) { @@ -195,31 +203,30 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, qWarning("Invalid mode \"%s\" for output %s", mode.constData(), connectorName.constData()); configuration = OutputConfigPreferred; } - if (vinfo) { - *vinfo = VirtualDesktopInfo(); - vinfo->virtualIndex = userConnectorConfig.value(QStringLiteral("virtualIndex"), INT_MAX).toInt(); - if (userConnectorConfig.contains(QStringLiteral("virtualPos"))) { - const QByteArray vpos = userConnectorConfig.value(QStringLiteral("virtualPos")).toByteArray(); - const QByteArrayList vposComp = vpos.split(','); - if (vposComp.count() == 2) - vinfo->virtualPos = QPoint(vposComp[0].trimmed().toInt(), vposComp[1].trimmed().toInt()); - } - if (userConnectorConfig.value(QStringLiteral("primary")).toBool()) - vinfo->isPrimary = true; + + *vinfo = ScreenInfo(); + vinfo->virtualIndex = userConnectorConfig.value(QStringLiteral("virtualIndex"), INT_MAX).toInt(); + if (userConnectorConfig.contains(QStringLiteral("virtualPos"))) { + const QByteArray vpos = userConnectorConfig.value(QStringLiteral("virtualPos")).toByteArray(); + const QByteArrayList vposComp = vpos.split(','); + if (vposComp.count() == 2) + vinfo->virtualPos = QPoint(vposComp[0].trimmed().toInt(), vposComp[1].trimmed().toInt()); } + if (userConnectorConfig.value(QStringLiteral("primary")).toBool()) + vinfo->isPrimary = true; const uint32_t crtc_id = resources->crtcs[crtc]; if (configuration == OutputConfigOff) { qCDebug(qLcKmsDebug) << "Turning off output" << connectorName; - drmModeSetCrtc(m_dri_fd, crtc_id, 0, 0, 0, 0, 0, Q_NULLPTR); - return Q_NULLPTR; + drmModeSetCrtc(m_dri_fd, crtc_id, 0, 0, 0, 0, 0, nullptr); + return nullptr; } // Skip disconnected output if (configuration == OutputConfigPreferred && connector->connection == DRM_MODE_DISCONNECTED) { qCDebug(qLcKmsDebug) << "Skipping disconnected output" << connectorName; - return Q_NULLPTR; + return nullptr; } // Get the current mode on the current crtc @@ -230,7 +237,7 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, drmModeFreeEncoder(encoder); if (!crtc) - return Q_NULLPTR; + return nullptr; if (crtc->mode_valid) crtc_mode = crtc->mode; @@ -240,7 +247,8 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, QList<drmModeModeInfo> modes; modes.reserve(connector->count_modes); - qCDebug(qLcKmsDebug) << connectorName << "mode count:" << connector->count_modes; + qCDebug(qLcKmsDebug) << connectorName << "mode count:" << connector->count_modes + << "crtc index:" << crtc << "crtc id:" << crtc_id; for (int i = 0; i < connector->count_modes; i++) { const drmModeModeInfo &mode = connector->modes[i]; qCDebug(qLcKmsDebug) << "mode" << i << mode.hdisplay << "x" << mode.vdisplay @@ -256,9 +264,11 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, for (int i = modes.size() - 1; i >= 0; i--) { const drmModeModeInfo &m = modes.at(i); - if (configuration == OutputConfigMode && - m.hdisplay == configurationSize.width() && - m.vdisplay == configurationSize.height()) { + if (configuration == OutputConfigMode + && m.hdisplay == configurationSize.width() + && m.vdisplay == configurationSize.height() + && (!configurationRefresh || m.vrefresh == uint32_t(configurationRefresh))) + { configured = i; } @@ -297,7 +307,7 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, if (selected_mode < 0) { qWarning() << "No modes available for output" << connectorName; - return Q_NULLPTR; + return nullptr; } else { int width = modes[selected_mode].hdisplay; int height = modes[selected_mode].vdisplay; @@ -324,22 +334,72 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, } qCDebug(qLcKmsDebug) << "Physical size is" << physSize << "mm" << "for output" << connectorName; - QKmsOutput output = { - QString::fromUtf8(connectorName), - connector->connector_id, - crtc_id, - physSize, - selected_mode, - false, - drmModeGetCrtc(m_dri_fd, crtc_id), - modes, - connector->subpixel, - connectorProperty(connector, QByteArrayLiteral("DPMS")), - false, - 0, - false - }; + const QByteArray formatStr = userConnectorConfig.value(QStringLiteral("format"), QStringLiteral("xrgb8888")) + .toByteArray().toLower(); + uint32_t drmFormat; + if (formatStr == "xrgb8888") { + drmFormat = DRM_FORMAT_XRGB8888; + } else if (formatStr == "xbgr8888") { + drmFormat = DRM_FORMAT_XBGR8888; + } else if (formatStr == "argb8888") { + drmFormat = DRM_FORMAT_ARGB8888; + } else if (formatStr == "abgr8888") { + drmFormat = DRM_FORMAT_ABGR8888; + } else if (formatStr == "rgb565") { + drmFormat = DRM_FORMAT_RGB565; + } else if (formatStr == "bgr565") { + drmFormat = DRM_FORMAT_BGR565; + } else if (formatStr == "xrgb2101010") { + drmFormat = DRM_FORMAT_XRGB2101010; + } else if (formatStr == "xbgr2101010") { + drmFormat = DRM_FORMAT_XBGR2101010; + } else if (formatStr == "argb2101010") { + drmFormat = DRM_FORMAT_ARGB2101010; + } else if (formatStr == "abgr2101010") { + drmFormat = DRM_FORMAT_ABGR2101010; + } else { + qWarning("Invalid pixel format \"%s\" for output %s", formatStr.constData(), connectorName.constData()); + drmFormat = DRM_FORMAT_XRGB8888; + } + const QString cloneSource = userConnectorConfig.value(QStringLiteral("clones")).toString(); + if (!cloneSource.isEmpty()) + qCDebug(qLcKmsDebug) << "Output" << connectorName << " clones output " << cloneSource; + + QKmsOutput output; + output.name = QString::fromUtf8(connectorName); + output.connector_id = connector->connector_id; + output.crtc_index = crtc; + output.crtc_id = crtc_id; + output.physical_size = physSize; + output.preferred_mode = preferred >= 0 ? preferred : selected_mode; + output.mode = selected_mode; + output.mode_set = false; + output.saved_crtc = drmModeGetCrtc(m_dri_fd, crtc_id); + output.modes = modes; + output.subpixel = connector->subpixel; + output.dpms_prop = connectorProperty(connector, QByteArrayLiteral("DPMS")); + output.edid_blob = connectorPropertyBlob(connector, QByteArrayLiteral("EDID")); + output.wants_forced_plane = false; + output.forced_plane_id = 0; + output.forced_plane_set = false; + output.drm_format = drmFormat; + output.clone_source = cloneSource; + + QString planeListStr; + for (const QKmsPlane &plane : qAsConst(m_planes)) { + if (plane.possibleCrtcs & (1 << output.crtc_index)) { + output.available_planes.append(plane); + planeListStr.append(QString::number(plane.id)); + planeListStr.append(QLatin1Char(' ')); + } + } + qCDebug(qLcKmsDebug, "Output %s can use %d planes: %s", + connectorName.constData(), output.available_planes.count(), qPrintable(planeListStr)); + + // This is for the EGLDevice/EGLStream backend. On some of those devices one + // may want to target a pre-configured plane. It is probably useless for + // eglfs_kms and others. Do not confuse with generic plane support (available_planes). bool ok; int idx = qEnvironmentVariableIntValue("QT_QPA_EGLFS_KMS_PLANE_INDEX", &ok); if (ok) { @@ -348,8 +408,8 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, if (idx >= 0 && idx < int(planeResources->count_planes)) { drmModePlane *plane = drmModeGetPlane(m_dri_fd, planeResources->planes[idx]); if (plane) { - output.wants_plane = true; - output.plane_id = plane->plane_id; + output.wants_forced_plane = true; + output.forced_plane_id = plane->plane_id; qCDebug(qLcKmsDebug, "Forcing plane index %d, plane id %u (belongs to crtc id %u)", idx, plane->plane_id, plane->crtc_id); drmModeFreePlane(plane); @@ -360,8 +420,9 @@ QPlatformScreen *QKmsDevice::createScreenForConnector(drmModeResPtr resources, } } - m_crtc_allocator |= (1 << output.crtc_id); - m_connector_allocator |= (1 << output.connector_id); + m_crtc_allocator |= (1 << output.crtc_index); + + vinfo->output = output; return createScreen(output); } @@ -379,7 +440,24 @@ drmModePropertyPtr QKmsDevice::connectorProperty(drmModeConnectorPtr connector, drmModeFreeProperty(prop); } - return Q_NULLPTR; + return nullptr; +} + +drmModePropertyBlobPtr QKmsDevice::connectorPropertyBlob(drmModeConnectorPtr connector, const QByteArray &name) +{ + drmModePropertyPtr prop; + drmModePropertyBlobPtr blob = nullptr; + + for (int i = 0; i < connector->count_props && !blob; i++) { + prop = drmModeGetProperty(m_dri_fd, connector->props[i]); + if (!prop) + continue; + if ((prop->flags & DRM_MODE_PROP_BLOB) && (strcmp(prop->name, name.constData()) == 0)) + blob = drmModeGetPropertyBlob(m_dri_fd, connector->prop_values[i]); + drmModeFreeProperty(prop); + } + + return blob; } QKmsDevice::QKmsDevice(QKmsScreenConfig *screenConfig, const QString &path) @@ -387,7 +465,6 @@ QKmsDevice::QKmsDevice(QKmsScreenConfig *screenConfig, const QString &path) , m_path(path) , m_dri_fd(-1) , m_crtc_allocator(0) - , m_connector_allocator(0) { if (m_path.isEmpty()) { m_path = m_screenConfig->devicePath(); @@ -406,10 +483,10 @@ QKmsDevice::~QKmsDevice() struct OrderedScreen { OrderedScreen() : screen(nullptr) { } - OrderedScreen(QPlatformScreen *screen, const QKmsDevice::VirtualDesktopInfo &vinfo) + OrderedScreen(QPlatformScreen *screen, const QKmsDevice::ScreenInfo &vinfo) : screen(screen), vinfo(vinfo) { } QPlatformScreen *screen; - QKmsDevice::VirtualDesktopInfo vinfo; + QKmsDevice::ScreenInfo vinfo; }; QDebug operator<<(QDebug dbg, const OrderedScreen &s) @@ -430,12 +507,29 @@ static bool orderedScreenLessThan(const OrderedScreen &a, const OrderedScreen &b void QKmsDevice::createScreens() { + // Headless mode using a render node: cannot do any output related DRM + // stuff. Skip it all and register a dummy screen. + if (m_screenConfig->headless()) { + QPlatformScreen *screen = createHeadlessScreen(); + if (screen) { + qCDebug(qLcKmsDebug, "Headless mode enabled"); + registerScreen(screen, true, QPoint(0, 0), QList<QPlatformScreen *>()); + return; + } else { + qWarning("QKmsDevice: Requested headless mode without support in the backend. Request is ignored."); + } + } + + drmSetClientCap(m_dri_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); + drmModeResPtr resources = drmModeGetResources(m_dri_fd); if (!resources) { - qWarning("drmModeGetResources failed"); + qErrnoWarning(errno, "drmModeGetResources failed"); return; } + discoverPlanes(); + QVector<OrderedScreen> screens; int wantedConnectorIndex = -1; @@ -456,7 +550,7 @@ void QKmsDevice::createScreens() if (!connector) continue; - VirtualDesktopInfo vinfo; + ScreenInfo vinfo; QPlatformScreen *screen = createScreenForConnector(resources, connector, &vinfo); if (screen) screens.append(OrderedScreen(screen, vinfo)); @@ -471,6 +565,32 @@ void QKmsDevice::createScreens() std::stable_sort(screens.begin(), screens.end(), orderedScreenLessThan); qCDebug(qLcKmsDebug) << "Sorted screen list:" << screens; + // The final list of screens is available, so do the second phase setup. + // Hook up clone sources and targets. + for (const OrderedScreen &orderedScreen : screens) { + QVector<QPlatformScreen *> screensCloningThisScreen; + for (const OrderedScreen &s : screens) { + if (s.vinfo.output.clone_source == orderedScreen.vinfo.output.name) + screensCloningThisScreen.append(s.screen); + } + QPlatformScreen *screenThisScreenClones = nullptr; + if (!orderedScreen.vinfo.output.clone_source.isEmpty()) { + for (const OrderedScreen &s : screens) { + if (s.vinfo.output.name == orderedScreen.vinfo.output.clone_source) { + screenThisScreenClones = s.screen; + break; + } + } + } + if (screenThisScreenClones) + qCDebug(qLcKmsDebug) << orderedScreen.screen->name() << "clones" << screenThisScreenClones; + if (!screensCloningThisScreen.isEmpty()) + qCDebug(qLcKmsDebug) << orderedScreen.screen->name() << "is cloned by" << screensCloningThisScreen; + + registerScreenCloning(orderedScreen.screen, screenThisScreenClones, screensCloningThisScreen); + } + + // Figure out the virtual desktop and register the screens to QPA/QGuiApplication. QPoint pos(0, 0); QList<QPlatformScreen *> siblings; QVector<QPoint> virtualPositions; @@ -512,6 +632,132 @@ void QKmsDevice::createScreens() } } +QPlatformScreen *QKmsDevice::createHeadlessScreen() +{ + // headless mode not supported by default + return nullptr; +} + +// not all subclasses support screen cloning +void QKmsDevice::registerScreenCloning(QPlatformScreen *screen, + QPlatformScreen *screenThisScreenClones, + const QVector<QPlatformScreen *> &screensCloningThisScreen) +{ + Q_UNUSED(screen); + Q_UNUSED(screenThisScreenClones); + Q_UNUSED(screensCloningThisScreen); +} + +// drm_property_type_is is not available in old headers +static inline bool propTypeIs(drmModePropertyPtr prop, uint32_t type) +{ + if (prop->flags & DRM_MODE_PROP_EXTENDED_TYPE) + return (prop->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type; + return prop->flags & type; +} + +void QKmsDevice::enumerateProperties(drmModeObjectPropertiesPtr objProps, PropCallback callback) +{ + for (uint32_t propIdx = 0; propIdx < objProps->count_props; ++propIdx) { + drmModePropertyPtr prop = drmModeGetProperty(m_dri_fd, objProps->props[propIdx]); + if (!prop) + continue; + + const quint64 value = objProps->prop_values[propIdx]; + qCDebug(qLcKmsDebug, " property %d: id = %u name = '%s'", propIdx, prop->prop_id, prop->name); + + if (propTypeIs(prop, DRM_MODE_PROP_SIGNED_RANGE)) { + qCDebug(qLcKmsDebug, " type is SIGNED_RANGE, value is %lld, possible values are:", qint64(value)); + for (int i = 0; i < prop->count_values; ++i) + qCDebug(qLcKmsDebug, " %lld", qint64(prop->values[i])); + } else if (propTypeIs(prop, DRM_MODE_PROP_RANGE)) { + qCDebug(qLcKmsDebug, " type is RANGE, value is %llu, possible values are:", value); + for (int i = 0; i < prop->count_values; ++i) + qCDebug(qLcKmsDebug, " %llu", quint64(prop->values[i])); + } else if (propTypeIs(prop, DRM_MODE_PROP_ENUM)) { + qCDebug(qLcKmsDebug, " type is ENUM, value is %llu, possible values are:", value); + for (int i = 0; i < prop->count_enums; ++i) + qCDebug(qLcKmsDebug, " enum %d: %s - %llu", i, prop->enums[i].name, prop->enums[i].value); + } else if (propTypeIs(prop, DRM_MODE_PROP_BITMASK)) { + qCDebug(qLcKmsDebug, " type is BITMASK, value is %llu, possible bits are:", value); + for (int i = 0; i < prop->count_enums; ++i) + qCDebug(qLcKmsDebug, " bitmask %d: %s - %u", i, prop->enums[i].name, 1 << prop->enums[i].value); + } else if (propTypeIs(prop, DRM_MODE_PROP_BLOB)) { + qCDebug(qLcKmsDebug, " type is BLOB"); + } else if (propTypeIs(prop, DRM_MODE_PROP_OBJECT)) { + qCDebug(qLcKmsDebug, " type is OBJECT"); + } + + callback(prop, value); + + drmModeFreeProperty(prop); + } +} + +void QKmsDevice::discoverPlanes() +{ + m_planes.clear(); + + drmModePlaneResPtr planeResources = drmModeGetPlaneResources(m_dri_fd); + if (!planeResources) + return; + + const int countPlanes = planeResources->count_planes; + qCDebug(qLcKmsDebug, "Found %d planes", countPlanes); + for (int planeIdx = 0; planeIdx < countPlanes; ++planeIdx) { + drmModePlanePtr drmplane = drmModeGetPlane(m_dri_fd, planeResources->planes[planeIdx]); + if (!drmplane) { + qCDebug(qLcKmsDebug, "Failed to query plane %d, ignoring", planeIdx); + continue; + } + + QKmsPlane plane; + plane.id = drmplane->plane_id; + plane.possibleCrtcs = drmplane->possible_crtcs; + + const int countFormats = drmplane->count_formats; + QString formatStr; + for (int i = 0; i < countFormats; ++i) { + uint32_t f = drmplane->formats[i]; + plane.supportedFormats.append(f); + QString s; + s.sprintf("%c%c%c%c ", f, f >> 8, f >> 16, f >> 24); + formatStr += s; + } + + qCDebug(qLcKmsDebug, "plane %d: id = %u countFormats = %d possibleCrtcs = 0x%x supported formats = %s", + planeIdx, plane.id, countFormats, plane.possibleCrtcs, qPrintable(formatStr)); + + drmModeFreePlane(drmplane); + + drmModeObjectPropertiesPtr objProps = drmModeObjectGetProperties(m_dri_fd, plane.id, DRM_MODE_OBJECT_PLANE); + if (!objProps) { + qCDebug(qLcKmsDebug, "Failed to query plane %d object properties, ignoring", planeIdx); + continue; + } + + enumerateProperties(objProps, [&plane](drmModePropertyPtr prop, quint64 value) { + if (!strcmp(prop->name, "type")) { + plane.type = QKmsPlane::Type(value); + } else if (!strcmp(prop->name, "rotation")) { + plane.initialRotation = QKmsPlane::Rotations(int(value)); + plane.availableRotations = 0; + if (propTypeIs(prop, DRM_MODE_PROP_BITMASK)) { + for (int i = 0; i < prop->count_enums; ++i) + plane.availableRotations |= QKmsPlane::Rotation(1 << prop->enums[i].value); + } + plane.rotationPropertyId = prop->prop_id; + } + }); + + m_planes.append(plane); + + drmModeFreeObjectProperties(objProps); + } + + drmModeFreePlaneResources(planeResources); +} + int QKmsDevice::fd() const { return m_dri_fd; @@ -533,7 +779,8 @@ QKmsScreenConfig *QKmsDevice::screenConfig() const } QKmsScreenConfig::QKmsScreenConfig() - : m_hwCursor(true) + : m_headless(false) + , m_hwCursor(true) , m_separateScreens(false) , m_pbuffers(false) , m_virtualDesktopLayout(VirtualDesktopLayoutHorizontal) @@ -568,6 +815,16 @@ void QKmsScreenConfig::loadConfig() const QJsonObject object = doc.object(); + const QString headlessStr = object.value(QLatin1String("headless")).toString(); + const QByteArray headless = headlessStr.toUtf8(); + QSize headlessSize; + if (sscanf(headless.constData(), "%dx%d", &headlessSize.rwidth(), &headlessSize.rheight()) == 2) { + m_headless = true; + m_headlessSize = headlessSize; + } else { + m_headless = false; + } + m_hwCursor = object.value(QLatin1String("hwcursor")).toBool(m_hwCursor); m_pbuffers = object.value(QLatin1String("pbuffers")).toBool(m_pbuffers); m_devicePath = object.value(QLatin1String("device")).toString(); @@ -599,6 +856,7 @@ void QKmsScreenConfig::loadConfig() } qCDebug(qLcKmsDebug) << "Requested configuration (some settings may be ignored):\n" + << "\theadless:" << m_headless << "\n" << "\thwcursor:" << m_hwCursor << "\n" << "\tpbuffers:" << m_pbuffers << "\n" << "\tseparateScreens:" << m_separateScreens << "\n" @@ -626,6 +884,11 @@ void QKmsOutput::cleanup(QKmsDevice *device) dpms_prop = nullptr; } + if (edid_blob) { + drmModeFreePropertyBlob(edid_blob); + edid_blob = nullptr; + } + restoreMode(device); if (saved_crtc) { diff --git a/src/platformsupport/kmsconvenience/qkmsdevice_p.h b/src/platformsupport/kmsconvenience/qkmsdevice_p.h index 35a51c18b1..5eecedec39 100644 --- a/src/platformsupport/kmsconvenience/qkmsdevice_p.h +++ b/src/platformsupport/kmsconvenience/qkmsdevice_p.h @@ -59,6 +59,42 @@ #include <xf86drm.h> #include <xf86drmMode.h> +#include <drm_fourcc.h> + +#include <functional> + +// In less fortunate cases one may need to build on a system with dev headers +// from the dark ages. Let's pull a GL and define the missing stuff outselves. + +#ifndef DRM_PLANE_TYPE_OVERLAY +#define DRM_PLANE_TYPE_OVERLAY 0 +#endif +#ifndef DRM_PLANE_TYPE_PRIMARY +#define DRM_PLANE_TYPE_PRIMARY 1 +#endif +#ifndef DRM_PLANE_TYPE_CURSOR +#define DRM_PLANE_TYPE_CURSOR 2 +#endif + +#ifndef DRM_CLIENT_CAP_UNIVERSAL_PLANES +#define DRM_CLIENT_CAP_UNIVERSAL_PLANES 2 +#endif +#ifndef DRM_CLIENT_CAP_ATOMIC +#define DRM_CLIENT_CAP_ATOMIC 3 +#endif + +#ifndef DRM_MODE_PROP_EXTENDED_TYPE +#define DRM_MODE_PROP_EXTENDED_TYPE 0x0000ffc0 +#endif +#ifndef DRM_MODE_PROP_TYPE +#define DRM_MODE_PROP_TYPE(n) ((n) << 6) +#endif +#ifndef DRM_MODE_PROP_OBJECT +#define DRM_MODE_PROP_OBJECT DRM_MODE_PROP_TYPE(1) +#endif +#ifndef DRM_MODE_PROP_SIGNED_RANGE +#define DRM_MODE_PROP_SIGNED_RANGE DRM_MODE_PROP_TYPE(2) +#endif QT_BEGIN_NAMESPACE @@ -76,6 +112,8 @@ public: QString devicePath() const { return m_devicePath; } + bool headless() const { return m_headless; } + QSize headlessSize() const { return m_headlessSize; } bool hwCursor() const { return m_hwCursor; } bool separateScreens() const { return m_separateScreens; } bool supportsPBuffers() const { return m_pbuffers; } @@ -87,6 +125,8 @@ private: void loadConfig(); QString m_devicePath; + bool m_headless; + QSize m_headlessSize; bool m_hwCursor; bool m_separateScreens; bool m_pbuffers; @@ -94,21 +134,63 @@ private: QMap<QString, QVariantMap> m_outputSettings; }; +// NB! QKmsPlane does not store the current state and offers no functions to +// change object properties. Any such functionality belongs to subclasses since +// in some cases atomic operations will be desired where a mere +// drmModeObjectSetProperty would not be acceptable. +struct QKmsPlane +{ + enum Type { + OverlayPlane = DRM_PLANE_TYPE_OVERLAY, + PrimaryPlane = DRM_PLANE_TYPE_PRIMARY, + CursorPlane = DRM_PLANE_TYPE_CURSOR + }; + + enum Rotation { + Rotation0 = 1 << 0, + Rotation90 = 1 << 1, + Rotation180 = 1 << 2, + Rotation270 = 1 << 3, + RotationReflectX = 1 << 4, + RotationReflectY = 1 << 5 + }; + Q_DECLARE_FLAGS(Rotations, Rotation) + + uint32_t id = 0; + Type type = OverlayPlane; + + int possibleCrtcs = 0; + + QVector<uint32_t> supportedFormats; + + Rotations initialRotation = Rotation0; + Rotations availableRotations = Rotation0; + uint32_t rotationPropertyId = 0; +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QKmsPlane::Rotations) + struct QKmsOutput { QString name; - uint32_t connector_id; - uint32_t crtc_id; + uint32_t connector_id = 0; + uint32_t crtc_index = 0; + uint32_t crtc_id = 0; QSizeF physical_size; - int mode; // index of selected mode in list below - bool mode_set; - drmModeCrtcPtr saved_crtc; + int preferred_mode = -1; // index of preferred mode in list below + int mode = -1; // index of selected mode in list below + bool mode_set = false; + drmModeCrtcPtr saved_crtc = nullptr; QList<drmModeModeInfo> modes; - int subpixel; - drmModePropertyPtr dpms_prop; - bool wants_plane; - uint32_t plane_id; - bool plane_set; + int subpixel = DRM_MODE_SUBPIXEL_UNKNOWN; + drmModePropertyPtr dpms_prop = nullptr; + drmModePropertyBlobPtr edid_blob = nullptr; + bool wants_forced_plane = false; + uint32_t forced_plane_id = 0; + bool forced_plane_set = false; + uint32_t drm_format = DRM_FORMAT_XRGB8888; + QString clone_source; + QVector<QKmsPlane> available_planes; void restoreMode(QKmsDevice *device); void cleanup(QKmsDevice *device); @@ -119,11 +201,11 @@ struct QKmsOutput class QKmsDevice { public: - struct VirtualDesktopInfo { - VirtualDesktopInfo() : virtualIndex(0), isPrimary(false) { } - int virtualIndex; + struct ScreenInfo { + int virtualIndex = 0; QPoint virtualPos; - bool isPrimary; + bool isPrimary = false; + QKmsOutput output; }; QKmsDevice(QKmsScreenConfig *screenConfig, const QString &path = QString()); @@ -142,6 +224,10 @@ public: protected: virtual QPlatformScreen *createScreen(const QKmsOutput &output) = 0; + virtual QPlatformScreen *createHeadlessScreen(); + virtual void registerScreenCloning(QPlatformScreen *screen, + QPlatformScreen *screenThisScreenClones, + const QVector<QPlatformScreen *> &screensCloningThisScreen); virtual void registerScreen(QPlatformScreen *screen, bool isPrimary, const QPoint &virtualPos, @@ -151,15 +237,20 @@ protected: int crtcForConnector(drmModeResPtr resources, drmModeConnectorPtr connector); QPlatformScreen *createScreenForConnector(drmModeResPtr resources, drmModeConnectorPtr connector, - VirtualDesktopInfo *vinfo); + ScreenInfo *vinfo); drmModePropertyPtr connectorProperty(drmModeConnectorPtr connector, const QByteArray &name); + drmModePropertyBlobPtr connectorPropertyBlob(drmModeConnectorPtr connector, const QByteArray &name); + typedef std::function<void(drmModePropertyPtr, quint64)> PropCallback; + void enumerateProperties(drmModeObjectPropertiesPtr objProps, PropCallback callback); + void discoverPlanes(); QKmsScreenConfig *m_screenConfig; QString m_path; int m_dri_fd; quint32 m_crtc_allocator; - quint32 m_connector_allocator; + + QVector<QKmsPlane> m_planes; private: Q_DISABLE_COPY(QKmsDevice) diff --git a/src/platformsupport/linuxaccessibility/atspiadaptor.cpp b/src/platformsupport/linuxaccessibility/atspiadaptor.cpp index 6561e95a0d..580cf0e31d 100644 --- a/src/platformsupport/linuxaccessibility/atspiadaptor.cpp +++ b/src/platformsupport/linuxaccessibility/atspiadaptor.cpp @@ -45,7 +45,7 @@ #include <qdbusreply.h> #include <qclipboard.h> -#include <qdebug.h> +#include <QtCore/qloggingcategory.h> #ifndef QT_NO_ACCESSIBILITY #include "socket_interface.h" @@ -65,8 +65,8 @@ QT_BEGIN_NAMESPACE -static bool isDebugging = false; -#define qAtspiDebug if (!::isDebugging); else qDebug +Q_LOGGING_CATEGORY(lcAccessibilityAtspi, "qt.accessibility.atspi") +Q_LOGGING_CATEGORY(lcAccessibilityAtspiCreation, "qt.accessibility.atspi.creation") AtSpiAdaptor::AtSpiAdaptor(DBusConnection *connection, QObject *parent) : QDBusVirtualObject(parent), m_dbus(connection) @@ -128,8 +128,6 @@ AtSpiAdaptor::AtSpiAdaptor(DBusConnection *connection, QObject *parent) , sendWindow_shade(0) , sendWindow_unshade(0) { - ::isDebugging = qEnvironmentVariableIsSet("QT_DEBUG_ACCESSIBILITY"); - m_applicationAdaptor = new QSpiApplicationAdaptor(m_dbus->connection(), this); connect(m_applicationAdaptor, SIGNAL(windowActivated(QObject*,bool)), this, SLOT(windowActivated(QObject*,bool))); @@ -140,9 +138,6 @@ AtSpiAdaptor::AtSpiAdaptor(DBusConnection *connection, QObject *parent) success = success && m_dbus->connection().connect(QLatin1String("org.a11y.atspi.Registry"), QLatin1String("/org/a11y/atspi/registry"), QLatin1String("org.a11y.atspi.Registry"), QLatin1String("EventListenerDeregistered"), this, SLOT(eventListenerDeregistered(QString,QString))); -#ifdef QT_ATSPI_DEBUG - qAtspiDebug() << "Registered event listener change listener: " << success; -#endif } AtSpiAdaptor::~AtSpiAdaptor() @@ -589,7 +584,7 @@ QString AtSpiAdaptor::introspect(const QString &path) const QAccessibleInterface * interface = interfaceFromPath(path); if (!interface) { - qAtspiDebug() << "WARNING Qt AtSpiAdaptor: Could not find accessible on path: " << path; + qCDebug(lcAccessibilityAtspi) << "WARNING Qt AtSpiAdaptor: Could not find accessible on path: " << path; return QString(); } @@ -698,7 +693,7 @@ void AtSpiAdaptor::setBitFlag(const QString &flag) || right.startsWith(QLatin1String("VisibledataChanged"))) { // typo in libatspi sendObject_visible_data_changed = 1; } else { - qAtspiDebug() << "WARNING: subscription string not handled:" << flag; + qCDebug(lcAccessibilityAtspi) << "WARNING: subscription string not handled:" << flag; } } break; @@ -744,7 +739,7 @@ void AtSpiAdaptor::setBitFlag(const QString &flag) } else if (right.startsWith(QLatin1String("DesktopDestroy"))) { // ignore this one } else { - qAtspiDebug() << "WARNING: subscription string not handled:" << flag; + qCDebug(lcAccessibilityAtspi) << "WARNING: subscription string not handled:" << flag; } } break; @@ -763,7 +758,7 @@ void AtSpiAdaptor::setBitFlag(const QString &flag) break; } default: - qAtspiDebug() << "WARNING: subscription string not handled:" << flag; + qCDebug(lcAccessibilityAtspi) << "WARNING: subscription string not handled:" << flag; } } @@ -782,19 +777,19 @@ void AtSpiAdaptor::updateEventListeners() setBitFlag(ev.eventName); m_applicationAdaptor->sendEvents(!evList.isEmpty()); } else { - qAtspiDebug("Could not query active accessibility event listeners."); + qCDebug(lcAccessibilityAtspi) << "Could not query active accessibility event listeners."; } } void AtSpiAdaptor::eventListenerDeregistered(const QString &/*bus*/, const QString &/*path*/) { -// qAtspiDebug() << "AtSpiAdaptor::eventListenerDeregistered: " << bus << path; +// qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::eventListenerDeregistered: " << bus << path; updateEventListeners(); } void AtSpiAdaptor::eventListenerRegistered(const QString &/*bus*/, const QString &/*path*/) { -// qAtspiDebug() << "AtSpiAdaptor::eventListenerRegistered: " << bus << path; +// qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::eventListenerRegistered: " << bus << path; updateEventListeners(); } @@ -859,7 +854,7 @@ QAccessibleInterface *AtSpiAdaptor::interfaceFromPath(const QString& dbusPath) c QStringList parts = dbusPath.split(QLatin1Char('/')); if (parts.size() != 6) { - qAtspiDebug() << "invalid path: " << dbusPath; + qCDebug(lcAccessibilityAtspi) << "invalid path: " << dbusPath; return 0; } @@ -868,7 +863,7 @@ QAccessibleInterface *AtSpiAdaptor::interfaceFromPath(const QString& dbusPath) c // The id is always in the range [INT_MAX+1, UINT_MAX] if ((int)id >= 0) - qWarning() << "No accessible object found for id: " << id; + qCWarning(lcAccessibilityAtspi) << "No accessible object found for id: " << id; return QAccessible::accessibleInterface(id); } @@ -943,7 +938,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event) if (sendObject || sendObject_text_changed) { QAccessibleInterface * iface = event->accessibleInterface(); if (!iface || !iface->textInterface()) { - qAtspiDebug("Received text event for invalid interface."); + qCDebug(lcAccessibilityAtspi) << "Received text event for invalid interface."; return; } QString path = pathForInterface(iface); @@ -1001,7 +996,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event) if (sendObject || sendObject_text_caret_moved) { QAccessibleInterface * iface = event->accessibleInterface(); if (!iface || !iface->textInterface()) { - qWarning() << "Sending TextCaretMoved from object that does not implement text interface: " << iface; + qCWarning(lcAccessibilityAtspi) << "Sending TextCaretMoved from object that does not implement text interface: " << iface; return; } @@ -1029,7 +1024,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event) if (sendObject || sendObject_value_changed || sendObject_property_change_accessible_value) { QAccessibleInterface * iface = event->accessibleInterface(); if (!iface) { - qWarning("ValueChanged event from invalid accessible."); + qCWarning(lcAccessibilityAtspi) << "ValueChanged event from invalid accessible."; return; } if (iface->valueInterface()) { @@ -1048,7 +1043,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event) sendDBusSignal(path, QLatin1String(ATSPI_DBUS_INTERFACE_EVENT_OBJECT), QLatin1String("SelectionChanged"), args2); } else { - qWarning() << "ValueChanged event and no ValueInterface or ComboBox: " << iface; + qCWarning(lcAccessibilityAtspi) << "ValueChanged event and no ValueInterface or ComboBox: " << iface; } } break; @@ -1058,7 +1053,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event) case QAccessible::Selection: { QAccessibleInterface * iface = event->accessibleInterface(); if (!iface) { - qWarning("Selection event from invalid accessible."); + qCWarning(lcAccessibilityAtspi) << "Selection event from invalid accessible."; return; } QString path = pathForInterface(iface); @@ -1075,7 +1070,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event) if (stateChange.checked) { QAccessibleInterface * iface = event->accessibleInterface(); if (!iface) { - qWarning("StateChanged event from invalid accessible."); + qCWarning(lcAccessibilityAtspi) << "StateChanged event from invalid accessible."; return; } int checked = iface->state().checked; @@ -1206,7 +1201,7 @@ void AtSpiAdaptor::notifyAboutCreation(QAccessibleInterface *interface) const // notify about the new child of our parent QAccessibleInterface * parent = interface->parent(); if (!parent) { - qAtspiDebug() << "AtSpiAdaptor::notifyAboutCreation: Could not find parent for " << interface->object(); + qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::notifyAboutCreation: Could not find parent for " << interface->object(); return; } QString path = pathForInterface(interface); @@ -1223,7 +1218,7 @@ void AtSpiAdaptor::notifyAboutDestruction(QAccessibleInterface *interface) const QAccessibleInterface * parent = interface->parent(); if (!parent) { - qAtspiDebug() << "AtSpiAdaptor::notifyAboutDestruction: Could not find parent for " << interface->object(); + qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::notifyAboutDestruction: Could not find parent for " << interface->object(); return; } QString path = pathForInterface(interface); @@ -1251,18 +1246,18 @@ bool AtSpiAdaptor::handleMessage(const QDBusMessage &message, const QDBusConnect // get accessible interface QAccessibleInterface * accessible = interfaceFromPath(message.path()); if (!accessible) { - qAtspiDebug() << "WARNING Qt AtSpiAdaptor: Could not find accessible on path: " << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING Qt AtSpiAdaptor: Could not find accessible on path: " << message.path(); return false; } if (!accessible->isValid()) { - qWarning() << "WARNING Qt AtSpiAdaptor: Accessible invalid: " << accessible << message.path(); + qCWarning(lcAccessibilityAtspi) << "WARNING Qt AtSpiAdaptor: Accessible invalid: " << accessible << message.path(); return false; } QString interface = message.interface(); QString function = message.member(); - // qAtspiDebug() << "AtSpiAdaptor::handleMessage: " << interface << function; + // qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::handleMessage: " << interface << function; if (function == QLatin1String("Introspect")) { //introspect(message.path()); @@ -1294,7 +1289,7 @@ bool AtSpiAdaptor::handleMessage(const QDBusMessage &message, const QDBusConnect if (interface == QLatin1String(ATSPI_DBUS_INTERFACE_TABLE)) return tableInterface(accessible, function, message, connection); - qAtspiDebug() << "AtSpiAdaptor::handleMessage with unknown interface: " << message.path() << interface << function; + qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::handleMessage with unknown interface: " << message.path() << interface << function; return false; } @@ -1302,7 +1297,7 @@ bool AtSpiAdaptor::handleMessage(const QDBusMessage &message, const QDBusConnect bool AtSpiAdaptor::applicationInterface(QAccessibleInterface *interface, const QString &function, const QDBusMessage &message, const QDBusConnection &connection) { if (message.path() != QLatin1String(ATSPI_DBUS_PATH_ROOT)) { - qAtspiDebug() << "WARNING Qt AtSpiAdaptor: Could not find application interface for: " << message.path() << interface; + qCDebug(lcAccessibilityAtspi) << "WARNING Qt AtSpiAdaptor: Could not find application interface for: " << message.path() << interface; return false; } @@ -1333,7 +1328,7 @@ bool AtSpiAdaptor::applicationInterface(QAccessibleInterface *interface, const Q QDBusMessage reply = message.createReply(QVariant::fromValue(QLocale().name())); return connection.send(reply); } - qAtspiDebug() << "AtSpiAdaptor::applicationInterface " << message.path() << interface << function; + qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::applicationInterface " << message.path() << interface << function; return false; } @@ -1354,7 +1349,7 @@ void AtSpiAdaptor::registerApplication() const QSpiObjectReference &socket = reply.value(); accessibilityRegistry = QSpiObjectReference(socket); } else { - qAtspiDebug() << "Error in contacting registry: " + qCDebug(lcAccessibilityAtspi) << "Error in contacting registry: " << reply.error().name() << reply.error().message(); } @@ -1380,7 +1375,7 @@ bool AtSpiAdaptor::accessibleInterface(QAccessibleInterface *interface, const QS if (parent) { childIndex = parent->indexOfChild(interface); if (childIndex < 0) { - qAtspiDebug() << "GetIndexInParent get invalid index: " << childIndex << interface; + qCDebug(lcAccessibilityAtspi) << "GetIndexInParent get invalid index: " << childIndex << interface; } } sendReply(connection, message, childIndex); @@ -1445,7 +1440,7 @@ bool AtSpiAdaptor::accessibleInterface(QAccessibleInterface *interface, const QS } connection.send(message.createReply(QVariant::fromValue(children))); } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::accessibleInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::accessibleInterface does not implement " << function << message.path(); return false; } return true; @@ -1458,14 +1453,10 @@ AtspiRole AtSpiAdaptor::getRole(QAccessibleInterface *interface) const return qSpiRoleMapping[interface->role()].spiRole(); } -//#define ACCESSIBLE_CREATION_DEBUG - QStringList AtSpiAdaptor::accessibleInterfaces(QAccessibleInterface *interface) const { QStringList ifaces; -#ifdef ACCESSIBLE_CREATION_DEBUG - qAtspiDebug() << "AtSpiAdaptor::accessibleInterfaces create: " << interface->object(); -#endif + qCDebug(lcAccessibilityAtspiCreation) << "AtSpiAdaptor::accessibleInterfaces create: " << interface->object(); ifaces << QLatin1String(ATSPI_DBUS_INTERFACE_ACCESSIBLE); if ( (!interface->rect().isEmpty()) || @@ -1477,12 +1468,9 @@ QStringList AtSpiAdaptor::accessibleInterfaces(QAccessibleInterface *interface) (interface->object() && interface->object()->inherits("QSGItem")) ) { ifaces << QLatin1String(ATSPI_DBUS_INTERFACE_COMPONENT); - } -#ifdef ACCESSIBLE_CREATION_DEBUG - else { - qAtspiDebug(" IS NOT a component"); + } else { + qCDebug(lcAccessibilityAtspiCreation) << " IS NOT a component"; } -#endif if (interface->role() == QAccessible::Application) ifaces << QLatin1String(ATSPI_DBUS_INTERFACE_APPLICATION); @@ -1536,7 +1524,7 @@ QString AtSpiAdaptor::pathForObject(QObject *object) const Q_ASSERT(object); if (inheritsQAction(object)) { - qAtspiDebug("AtSpiAdaptor::pathForObject: warning: creating path with QAction as object."); + qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::pathForObject: warning: creating path with QAction as object."; } QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(object); @@ -1613,7 +1601,13 @@ bool AtSpiAdaptor::componentInterface(QAccessibleInterface *interface, const QSt int x = message.arguments().at(0).toInt(); int y = message.arguments().at(1).toInt(); uint coordType = message.arguments().at(2).toUInt(); - Q_UNUSED (coordType) // FIXME + if (coordType == ATSPI_COORD_TYPE_WINDOW) { + QWindow * window = interface->window(); + if (window) { + x += window->position().x(); + y += window->position().y(); + } + } QAccessibleInterface * childInterface(interface->childAt(x, y)); QAccessibleInterface * iface = 0; @@ -1667,21 +1661,21 @@ bool AtSpiAdaptor::componentInterface(QAccessibleInterface *interface, const QSt // int width = message.arguments().at(2).toInt(); // int height = message.arguments().at(3).toInt(); // uint coordinateType = message.arguments().at(4).toUInt(); - qAtspiDebug("SetExtents is not implemented."); + qCDebug(lcAccessibilityAtspi) << "SetExtents is not implemented."; sendReply(connection, message, false); } else if (function == QLatin1String("SetPosition")) { // int x = message.arguments().at(0).toInt(); // int y = message.arguments().at(1).toInt(); // uint coordinateType = message.arguments().at(2).toUInt(); - qAtspiDebug("SetPosition is not implemented."); + qCDebug(lcAccessibilityAtspi) << "SetPosition is not implemented."; sendReply(connection, message, false); } else if (function == QLatin1String("SetSize")) { // int width = message.arguments().at(0).toInt(); // int height = message.arguments().at(1).toInt(); - qAtspiDebug("SetSize is not implemented."); + qCDebug(lcAccessibilityAtspi) << "SetSize is not implemented."; sendReply(connection, message, false); } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::componentInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::componentInterface does not implement " << function << message.path(); return false; } return true; @@ -1743,7 +1737,7 @@ bool AtSpiAdaptor::actionInterface(QAccessibleInterface *interface, const QStrin else sendReply(connection, message, QString()); } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::actionInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::actionInterface does not implement " << function << message.path(); return false; } return true; @@ -1815,7 +1809,7 @@ bool AtSpiAdaptor::textInterface(QAccessibleInterface *interface, const QString Q_UNUSED(x) Q_UNUSED (y) Q_UNUSED(width) Q_UNUSED(height) Q_UNUSED(coordType) Q_UNUSED(xClipType) Q_UNUSED(yClipType) - qAtspiDebug("Not implemented: QSpiAdaptor::GetBoundedRanges"); + qCDebug(lcAccessibilityAtspi) << "Not implemented: QSpiAdaptor::GetBoundedRanges"; sendReply(connection, message, QVariant::fromValue(QSpiTextRangeList())); } else if (function == QLatin1String("GetCharacterAtOffset")) { int offset = message.arguments().at(0).toInt(); @@ -1834,7 +1828,7 @@ bool AtSpiAdaptor::textInterface(QAccessibleInterface *interface, const QString } else if (function == QLatin1String("GetNSelections")) { sendReply(connection, message, interface->textInterface()->selectionCount()); } else if (function == QLatin1String("GetOffsetAtPoint")) { - qAtspiDebug() << message.signature(); + qCDebug(lcAccessibilityAtspi) << message.signature(); Q_ASSERT(!message.signature().isEmpty()); QPoint point(message.arguments().at(0).toInt(), message.arguments().at(1).toInt()); uint coordType = message.arguments().at(2).toUInt(); @@ -1903,7 +1897,7 @@ bool AtSpiAdaptor::textInterface(QAccessibleInterface *interface, const QString interface->textInterface()->setSelection(selectionNum, startOffset, endOffset); sendReply(connection, message, true); } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::textInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::textInterface does not implement " << function << message.path(); return false; } return true; @@ -1979,7 +1973,7 @@ namespace value != QLatin1String("center") ) { value = QString(); - qAtspiDebug() << "Unknown text-align attribute value \"" << value << "\" cannot be translated to AT-SPI."; + qCDebug(lcAccessibilityAtspi) << "Unknown text-align attribute value \"" << value << "\" cannot be translated to AT-SPI."; } } } else if (ia2Name == QLatin1String("font-size")) { @@ -1992,7 +1986,7 @@ namespace value != QLatin1String("oblique") ) { value = QString(); - qAtspiDebug() << "Unknown font-style attribute value \"" << value << "\" cannot be translated to AT-SPI."; + qCDebug(lcAccessibilityAtspi) << "Unknown font-style attribute value \"" << value << "\" cannot be translated to AT-SPI."; } } else if (ia2Name == QLatin1String("text-underline-type")) { name = QStringLiteral("underline"); @@ -2001,7 +1995,7 @@ namespace value != QLatin1String("double") ) { value = QString(); - qAtspiDebug() << "Unknown text-underline-type attribute value \"" << value << "\" cannot be translated to AT-SPI."; + qCDebug(lcAccessibilityAtspi) << "Unknown text-underline-type attribute value \"" << value << "\" cannot be translated to AT-SPI."; } } else if (ia2Name == QLatin1String("font-weight")) { name = QStringLiteral("weight"); @@ -2017,7 +2011,7 @@ namespace value != QLatin1String("sub") ) { value = QString(); - qAtspiDebug() << "Unknown text-position attribute value \"" << value << "\" cannot be translated to AT-SPI."; + qCDebug(lcAccessibilityAtspi) << "Unknown text-position attribute value \"" << value << "\" cannot be translated to AT-SPI."; } } else if (ia2Name == QLatin1String("writing-mode")) { name = QStringLiteral("direction"); @@ -2028,10 +2022,10 @@ namespace else if (value == QLatin1String("tb")) { // IAccessible2 docs refer to XSL, which specifies "tb" is shorthand for "tb-rl"; so at least give a hint about the horizontal direction (ATK does not support vertical direction in this attribute (yet)) value = QStringLiteral("rtl"); - qAtspiDebug() << "writing-mode attribute value \"tb\" translated only w.r.t. horizontal direction; vertical direction ignored"; + qCDebug(lcAccessibilityAtspi) << "writing-mode attribute value \"tb\" translated only w.r.t. horizontal direction; vertical direction ignored"; } else { value = QString(); - qAtspiDebug() << "Unknown writing-mode attribute value \"" << value << "\" cannot be translated to AT-SPI."; + qCDebug(lcAccessibilityAtspi) << "Unknown writing-mode attribute value \"" << value << "\" cannot be translated to AT-SPI."; } } else if (ia2Name == QLatin1String("language")) { // OK - ATK has no docs on the format of the value, IAccessible2 has reasonable format - leave it at that now @@ -2223,7 +2217,7 @@ bool AtSpiAdaptor::editableTextInterface(QAccessibleInterface *interface, const } else if (function == QLatin1String("")) { connection.send(message.createReply()); } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::editableTextInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::editableTextInterface does not implement " << function << message.path(); return false; } return true; @@ -2254,11 +2248,11 @@ bool AtSpiAdaptor::valueInterface(QAccessibleInterface *interface, const QString else if (function == QLatin1String("GetMinimumValue")) value = valueIface->minimumValue(); else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::valueInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::valueInterface does not implement " << function << message.path(); return false; } if (!value.canConvert(QVariant::Double)) { - qAtspiDebug() << "AtSpiAdaptor::valueInterface: Could not convert to double: " << function; + qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::valueInterface: Could not convert to double: " << function; } // explicitly convert to dbus-variant containing one double since atspi expects that @@ -2273,7 +2267,7 @@ bool AtSpiAdaptor::valueInterface(QAccessibleInterface *interface, const QString bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString &function, const QDBusMessage &message, const QDBusConnection &connection) { if (!(interface->tableInterface() || interface->tableCellInterface())) { - qAtspiDebug() << "WARNING Qt AtSpiAdaptor: Could not find table interface for: " << message.path() << interface; + qCDebug(lcAccessibilityAtspi) << "WARNING Qt AtSpiAdaptor: Could not find table interface for: " << message.path() << interface; return false; } @@ -2311,7 +2305,7 @@ bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString (column < 0) || (row >= interface->tableInterface()->rowCount()) || (column >= interface->tableInterface()->columnCount())) { - qAtspiDebug() << "WARNING: invalid index for tableInterface GetAccessibleAt (" << row << ", " << column << ')'; + qCDebug(lcAccessibilityAtspi) << "WARNING: invalid index for tableInterface GetAccessibleAt (" << row << ", " << column << ')'; return false; } @@ -2320,7 +2314,7 @@ bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString if (cell) { ref = QSpiObjectReference(connection, QDBusObjectPath(pathForInterface(cell))); } else { - qAtspiDebug() << "WARNING: no cell interface returned for " << interface->object() << row << column; + qCDebug(lcAccessibilityAtspi) << "WARNING: no cell interface returned for " << interface->object() << row << column; ref = QSpiObjectReference(); } connection.send(message.createReply(QVariant::fromValue(ref))); @@ -2330,11 +2324,11 @@ bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString int column = message.arguments().at(1).toInt(); QAccessibleInterface *cell = interface->tableInterface()->cellAt(row, column); if (!cell) { - qAtspiDebug() << "WARNING: AtSpiAdaptor::GetIndexAt(" << row << ',' << column << ") did not find a cell. " << interface; + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::GetIndexAt(" << row << ',' << column << ") did not find a cell. " << interface; return false; } int index = interface->indexOfChild(cell); - qAtspiDebug() << "QSpiAdaptor::GetIndexAt row:" << row << " col:" << column << " logical index:" << index; + qCDebug(lcAccessibilityAtspi) << "QSpiAdaptor::GetIndexAt row:" << row << " col:" << column << " logical index:" << index; Q_ASSERT(index > 0); connection.send(message.createReply(index)); } else if ((function == QLatin1String("GetColumnAtIndex")) || (function == QLatin1String("GetRowAtIndex"))) { @@ -2350,7 +2344,7 @@ bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString ret = -1; } else { if (!cell->tableCellInterface()) { - qAtspiDebug() << "WARNING: AtSpiAdaptor::" << function << " No table cell interface: " << cell; + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::" << function << " No table cell interface: " << cell; return false; } ret = cell->tableCellInterface()->columnIndex(); @@ -2362,14 +2356,14 @@ bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString ret = index % interface->tableInterface()->columnCount(); } else { if (!cell->tableCellInterface()) { - qAtspiDebug() << "WARNING: AtSpiAdaptor::" << function << " No table cell interface: " << cell; + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::" << function << " No table cell interface: " << cell; return false; } ret = cell->tableCellInterface()->rowIndex(); } } } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::" << function << " No cell at index: " << index << interface; + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::" << function << " No cell at index: " << index << interface; return false; } } @@ -2475,7 +2469,7 @@ bool AtSpiAdaptor::tableInterface(QAccessibleInterface *interface, const QString int row = message.arguments().at(0).toInt(); connection.send(message.createReply(interface->tableInterface()->unselectRow(row))); } else { - qAtspiDebug() << "WARNING: AtSpiAdaptor::tableInterface does not implement " << function << message.path(); + qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::tableInterface does not implement " << function << message.path(); return false; } return true; diff --git a/src/platformsupport/linuxaccessibility/bridge_p.h b/src/platformsupport/linuxaccessibility/bridge_p.h index 1e435ca351..c48bbd3710 100644 --- a/src/platformsupport/linuxaccessibility/bridge_p.h +++ b/src/platformsupport/linuxaccessibility/bridge_p.h @@ -74,7 +74,7 @@ public: virtual ~QSpiAccessibleBridge(); - void notifyAccessibilityUpdate(QAccessibleEvent *event) Q_DECL_OVERRIDE; + void notifyAccessibilityUpdate(QAccessibleEvent *event) override; QDBusConnection dBusConnection() const; public Q_SLOTS: diff --git a/src/platformsupport/platformcompositor/qopenglcompositorbackingstore.cpp b/src/platformsupport/platformcompositor/qopenglcompositorbackingstore.cpp index dbaaf524e8..40400e2a19 100644 --- a/src/platformsupport/platformcompositor/qopenglcompositorbackingstore.cpp +++ b/src/platformsupport/platformcompositor/qopenglcompositorbackingstore.cpp @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2017 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the plugins of the Qt Toolkit. @@ -101,7 +101,7 @@ QOpenGLCompositorBackingStore::~QOpenGLCompositorBackingStore() ctx->makeCurrent(tempSurface.data()); } - if (ctx && m_bsTextureContext && ctx->shareGroup() == m_bsTextureContext->shareGroup()) + if (m_bsTextureContext && ctx->shareGroup() == m_bsTextureContext->shareGroup()) glDeleteTextures(1, &m_bsTexture); else qWarning("QOpenGLCompositorBackingStore: Texture is not valid in the current context"); @@ -196,20 +196,19 @@ void QOpenGLCompositorBackingStore::flush(QWindow *window, const QRegion ®ion dstCtx->makeCurrent(dstWin); updateTexture(); m_textures->clear(); - m_textures->appendTexture(Q_NULLPTR, m_bsTexture, window->geometry()); + m_textures->appendTexture(nullptr, m_bsTexture, window->geometry()); compositor->update(); } void QOpenGLCompositorBackingStore::composeAndFlush(QWindow *window, const QRegion ®ion, const QPoint &offset, - QPlatformTextureList *textures, QOpenGLContext *context, + QPlatformTextureList *textures, bool translucentBackground) { // QOpenGLWidget/QQuickWidget content provided as textures. The raster content goes on top. Q_UNUSED(region); Q_UNUSED(offset); - Q_UNUSED(context); Q_UNUSED(translucentBackground); QOpenGLCompositor *compositor = QOpenGLCompositor::instance(); @@ -218,7 +217,7 @@ void QOpenGLCompositorBackingStore::composeAndFlush(QWindow *window, const QRegi // The compositor's context and the context to which QOpenGLWidget/QQuickWidget // textures belong are not the same. They share resources, though. - Q_ASSERT(context->shareGroup() == dstCtx->shareGroup()); + Q_ASSERT(qt_window_private(window)->shareContext()->shareGroup() == dstCtx->shareGroup()); QWindow *dstWin = compositor->targetWindow(); if (!dstWin) @@ -234,7 +233,7 @@ void QOpenGLCompositorBackingStore::composeAndFlush(QWindow *window, const QRegi textures->clipRect(i), textures->flags(i)); updateTexture(); - m_textures->appendTexture(Q_NULLPTR, m_bsTexture, window->geometry()); + m_textures->appendTexture(nullptr, m_bsTexture, window->geometry()); textures->lock(true); m_lockedWidgetTextures = textures; @@ -281,7 +280,7 @@ void QOpenGLCompositorBackingStore::resize(const QSize &size, const QRegion &sta if (m_bsTexture) { glDeleteTextures(1, &m_bsTexture); m_bsTexture = 0; - m_bsTextureContext = Q_NULLPTR; + m_bsTextureContext = nullptr; } } diff --git a/src/platformsupport/platformcompositor/qopenglcompositorbackingstore_p.h b/src/platformsupport/platformcompositor/qopenglcompositorbackingstore_p.h index 0b025e4304..d88738ea8f 100644 --- a/src/platformsupport/platformcompositor/qopenglcompositorbackingstore_p.h +++ b/src/platformsupport/platformcompositor/qopenglcompositorbackingstore_p.h @@ -66,17 +66,17 @@ public: QOpenGLCompositorBackingStore(QWindow *window); ~QOpenGLCompositorBackingStore(); - QPaintDevice *paintDevice() Q_DECL_OVERRIDE; + QPaintDevice *paintDevice() override; - void beginPaint(const QRegion ®ion) Q_DECL_OVERRIDE; + void beginPaint(const QRegion ®ion) override; - void flush(QWindow *window, const QRegion ®ion, const QPoint &offset) Q_DECL_OVERRIDE; - void resize(const QSize &size, const QRegion &staticContents) Q_DECL_OVERRIDE; + void flush(QWindow *window, const QRegion ®ion, const QPoint &offset) override; + void resize(const QSize &size, const QRegion &staticContents) override; - QImage toImage() const Q_DECL_OVERRIDE; + QImage toImage() const override; void composeAndFlush(QWindow *window, const QRegion ®ion, const QPoint &offset, - QPlatformTextureList *textures, QOpenGLContext *context, - bool translucentBackground) Q_DECL_OVERRIDE; + QPlatformTextureList *textures, + bool translucentBackground) override; const QPlatformTextureList *textures() const { return m_textures; } diff --git a/src/platformsupport/platformsupport.pro b/src/platformsupport/platformsupport.pro index 7db6de78b4..7dbb6f6cae 100644 --- a/src/platformsupport/platformsupport.pro +++ b/src/platformsupport/platformsupport.pro @@ -2,6 +2,7 @@ TEMPLATE = subdirs QT_FOR_CONFIG += gui-private SUBDIRS = \ + edid \ eventdispatchers \ devicediscovery \ fbconvenience \ @@ -15,7 +16,7 @@ qtConfig(evdev)|qtConfig(tslib)|qtConfig(libinput)|qtConfig(integrityhid) { input.depends += devicediscovery } -unix:!darwin: \ +if(unix:!darwin)|qtConfig(xcb): \ SUBDIRS += services qtConfig(opengl): \ @@ -33,12 +34,14 @@ qtConfig(accessibility) { SUBDIRS += linuxaccessibility linuxaccessibility.depends += accessibility } + win32:!winrt: SUBDIRS += windowsuiautomation } darwin { SUBDIRS += \ clipboard \ graphics - macos: \ - SUBDIRS += cglconvenience } + +qtConfig(vulkan): \ + SUBDIRS += vkconvenience diff --git a/src/platformsupport/services/genericunix/qgenericunixservices.cpp b/src/platformsupport/services/genericunix/qgenericunixservices.cpp index cdb5d33859..cb1e367b9f 100644 --- a/src/platformsupport/services/genericunix/qgenericunixservices.cpp +++ b/src/platformsupport/services/genericunix/qgenericunixservices.cpp @@ -49,6 +49,24 @@ #include <QtCore/QStandardPaths> #include <QtCore/QUrl> +#if QT_CONFIG(dbus) +// These QtCore includes are needed for flatpak support +#include <QtCore/private/qcore_unix_p.h> + +#include <QtCore/QFileInfo> +#include <QtCore/QUrlQuery> + +#include <QtDBus/QDBusConnection> +#include <QtDBus/QDBusMessage> +#include <QtDBus/QDBusPendingCall> +#include <QtDBus/QDBusPendingCallWatcher> +#include <QtDBus/QDBusPendingReply> +#include <QtDBus/QDBusUnixFileDescriptor> + +#include <fcntl.h> + +#endif // QT_CONFIG(dbus) + #include <stdlib.h> QT_BEGIN_NAMESPACE @@ -153,6 +171,83 @@ static inline bool launch(const QString &launcher, const QUrl &url) return ok; } +#if QT_CONFIG(dbus) +static inline bool checkRunningUnderFlatpak() +{ + return !QStandardPaths::locate(QStandardPaths::RuntimeLocation, QLatin1String("flatpak-info")).isEmpty(); +} + +static inline bool flatpakOpenUrl(const QUrl &url) +{ + // DBus signature: + // OpenURI (IN s parent_window, + // IN s uri, + // IN a{sv} options, + // OUT o handle) + // Options: + // writable (b) - Whether to allow the chosen application to write to the file. + // This key only takes effect the uri points to a local file that is exported in the document portal, + // and the chosen application is sandboxed itself. + + QDBusMessage message = QDBusMessage::createMethodCall(QLatin1String("org.freedesktop.portal.Desktop"), + QLatin1String("/org/freedesktop/portal/desktop"), + QLatin1String("org.freedesktop.portal.OpenURI"), + QLatin1String("OpenURI")); + // FIXME parent_window_id and handle writable option + message << QString() << url.toString() << QVariantMap(); + + QDBusPendingReply<QDBusObjectPath> reply = QDBusConnection::sessionBus().call(message); + return !reply.isError(); +} + +static inline bool flatpakSendEmail(const QUrl &url) +{ + // DBus signature: + // ComposeEmail (IN s parent_window, + // IN a{sv} options, + // OUT o handle) + // Options: + // address (s) - The email address to send to. + // subject (s) - The subject for the email. + // body (s) - The body for the email. + // attachment_fds (ah) - File descriptors for files to attach. + + QUrlQuery urlQuery(url); + QVariantMap options; + options.insert(QLatin1String("address"), url.path()); + options.insert(QLatin1String("subject"), urlQuery.queryItemValue(QLatin1String("subject"))); + options.insert(QLatin1String("body"), urlQuery.queryItemValue(QLatin1String("body"))); + + // O_PATH seems to be present since Linux 2.6.39, which is not case of RHEL 6 +#ifdef O_PATH + QList<QDBusUnixFileDescriptor> attachments; + const QStringList attachmentUris = urlQuery.allQueryItemValues(QLatin1String("attachment")); + + for (const QString &attachmentUri : attachmentUris) { + const int fd = qt_safe_open(QFile::encodeName(attachmentUri), O_PATH); + if (fd != -1) { + QDBusUnixFileDescriptor descriptor(fd); + attachments << descriptor; + qt_safe_close(fd); + } + } + + options.insert(QLatin1String("attachment_fds"), QVariant::fromValue(attachments)); +#endif + + QDBusMessage message = QDBusMessage::createMethodCall(QLatin1String("org.freedesktop.portal.Desktop"), + QLatin1String("/org/freedesktop/portal/desktop"), + QLatin1String("org.freedesktop.portal.Email"), + QLatin1String("ComposeEmail")); + + // FIXME parent_window_id + message << QString() << options; + + QDBusPendingReply<QDBusObjectPath> reply = QDBusConnection::sessionBus().call(message); + return !reply.isError(); +} +#endif // QT_CONFIG(dbus) + QByteArray QGenericUnixServices::desktopEnvironment() const { static const QByteArray result = detectDesktopEnvironment(); @@ -161,8 +256,18 @@ QByteArray QGenericUnixServices::desktopEnvironment() const bool QGenericUnixServices::openUrl(const QUrl &url) { - if (url.scheme() == QLatin1String("mailto")) + if (url.scheme() == QLatin1String("mailto")) { +#if QT_CONFIG(dbus) + if (checkRunningUnderFlatpak()) + return flatpakSendEmail(url); +#endif return openDocument(url); + } + +#if QT_CONFIG(dbus) + if (checkRunningUnderFlatpak()) + return flatpakOpenUrl(url); +#endif if (m_webBrowser.isEmpty() && !detectWebBrowser(desktopEnvironment(), true, &m_webBrowser)) { qWarning("Unable to detect a web browser to launch '%s'", qPrintable(url.toString())); diff --git a/src/platformsupport/services/genericunix/qgenericunixservices_p.h b/src/platformsupport/services/genericunix/qgenericunixservices_p.h index 205b2e6160..8ac3de6f03 100644 --- a/src/platformsupport/services/genericunix/qgenericunixservices_p.h +++ b/src/platformsupport/services/genericunix/qgenericunixservices_p.h @@ -61,10 +61,10 @@ class QGenericUnixServices : public QPlatformServices public: QGenericUnixServices() {} - QByteArray desktopEnvironment() const Q_DECL_OVERRIDE; + QByteArray desktopEnvironment() const override; - bool openUrl(const QUrl &url) Q_DECL_OVERRIDE; - bool openDocument(const QUrl &url) Q_DECL_OVERRIDE; + bool openUrl(const QUrl &url) override; + bool openDocument(const QUrl &url) override; private: QString m_webBrowser; diff --git a/src/platformsupport/services/services.pro b/src/platformsupport/services/services.pro index 91957a0a78..7ff5e8e179 100644 --- a/src/platformsupport/services/services.pro +++ b/src/platformsupport/services/services.pro @@ -2,12 +2,13 @@ TARGET = QtServiceSupport MODULE = service_support QT = core-private gui-private +qtConfig(dbus): QT += dbus + CONFIG += static internal_module DEFINES += QT_NO_CAST_FROM_ASCII PRECOMPILED_HEADER = ../../corelib/global/qt_pch.h -unix:!darwin: \ - include($$PWD/genericunix/genericunix.pri) +include($$PWD/genericunix/genericunix.pri) load(qt_module) diff --git a/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenuadaptor.cpp b/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenuadaptor.cpp index 354b9c3a2e..eabb4b4122 100644 --- a/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenuadaptor.cpp +++ b/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenuadaptor.cpp @@ -122,7 +122,7 @@ void QDBusMenuAdaptor::Event(int id, const QString &eventId, const QDBusVariant emit item->hovered(); if (eventId == QLatin1String("closed")) { // There is no explicit AboutToHide method, so map closed event to aboutToHide method - const QDBusPlatformMenu *menu = Q_NULLPTR; + const QDBusPlatformMenu *menu = nullptr; if (item) menu = static_cast<const QDBusPlatformMenu *>(item->menu()); else if (id == 0) diff --git a/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenubar_p.h b/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenubar_p.h index 8266a395f5..364e7da4b6 100644 --- a/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenubar_p.h +++ b/src/platformsupport/themes/genericunix/dbusmenu/qdbusmenubar_p.h @@ -67,12 +67,12 @@ public: QDBusMenuBar(); virtual ~QDBusMenuBar(); - void insertMenu(QPlatformMenu *menu, QPlatformMenu *before) Q_DECL_OVERRIDE; - void removeMenu(QPlatformMenu *menu) Q_DECL_OVERRIDE; - void syncMenu(QPlatformMenu *menu) Q_DECL_OVERRIDE; - void handleReparent(QWindow *newParentWindow) Q_DECL_OVERRIDE; - QPlatformMenu *menuForTag(quintptr tag) const Q_DECL_OVERRIDE; - QPlatformMenu *createMenu() const Q_DECL_OVERRIDE; + void insertMenu(QPlatformMenu *menu, QPlatformMenu *before) override; + void removeMenu(QPlatformMenu *menu) override; + void syncMenu(QPlatformMenu *menu) override; + void handleReparent(QWindow *newParentWindow) override; + QPlatformMenu *menuForTag(quintptr tag) const override; + QPlatformMenu *createMenu() const override; private: QDBusPlatformMenu *m_menu; diff --git a/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu.cpp b/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu.cpp index 4b099e5c0e..fc1b37f2f2 100644 --- a/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu.cpp +++ b/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu.cpp @@ -50,9 +50,8 @@ Q_LOGGING_CATEGORY(qLcMenu, "qt.qpa.menu") static int nextDBusID = 1; QHash<int, QDBusPlatformMenuItem *> menuItemsByID; -QDBusPlatformMenuItem::QDBusPlatformMenuItem(quintptr tag) - : m_tag(tag ? tag : reinterpret_cast<quintptr>(this)) // QMenu will overwrite this later - , m_subMenu(Q_NULLPTR) +QDBusPlatformMenuItem::QDBusPlatformMenuItem() + : m_subMenu(nullptr) , m_role(NoRole) , m_isEnabled(true) , m_isVisible(true) @@ -69,12 +68,7 @@ QDBusPlatformMenuItem::~QDBusPlatformMenuItem() { menuItemsByID.remove(m_dbusID); if (m_subMenu) - static_cast<QDBusPlatformMenu *>(m_subMenu)->setContainingMenuItem(Q_NULLPTR); -} - -void QDBusPlatformMenuItem::setTag(quintptr tag) -{ - m_tag = tag; + static_cast<QDBusPlatformMenu *>(m_subMenu)->setContainingMenuItem(nullptr); } void QDBusPlatformMenuItem::setText(const QString &text) @@ -94,7 +88,7 @@ void QDBusPlatformMenuItem::setIcon(const QIcon &icon) void QDBusPlatformMenuItem::setMenu(QPlatformMenu *menu) { if (m_subMenu) - static_cast<QDBusPlatformMenu *>(m_subMenu)->setContainingMenuItem(Q_NULLPTR); + static_cast<QDBusPlatformMenu *>(m_subMenu)->setContainingMenuItem(nullptr); m_subMenu = menu; if (menu) static_cast<QDBusPlatformMenu *>(menu)->setContainingMenuItem(this); @@ -153,7 +147,7 @@ QDBusPlatformMenuItem *QDBusPlatformMenuItem::byId(int id) // a default-constructed nullptr value into menuItemsByID if (menuItemsByID.contains(id)) return menuItemsByID[id]; - return Q_NULLPTR; + return nullptr; } QList<const QDBusPlatformMenuItem *> QDBusPlatformMenuItem::byIds(const QList<int> &ids) @@ -167,19 +161,18 @@ QList<const QDBusPlatformMenuItem *> QDBusPlatformMenuItem::byIds(const QList<in } -QDBusPlatformMenu::QDBusPlatformMenu(quintptr tag) - : m_tag(tag ? tag : reinterpret_cast<quintptr>(this)) - , m_isEnabled(true) +QDBusPlatformMenu::QDBusPlatformMenu() + : m_isEnabled(true) , m_isVisible(true) , m_revision(1) - , m_containingMenuItem(Q_NULLPTR) + , m_containingMenuItem(nullptr) { } QDBusPlatformMenu::~QDBusPlatformMenu() { if (m_containingMenuItem) - m_containingMenuItem->setMenu(Q_NULLPTR); + m_containingMenuItem->setMenu(nullptr); } void QDBusPlatformMenu::insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before) @@ -252,11 +245,6 @@ void QDBusPlatformMenu::emitUpdated() emit updated(++m_revision, 0); } -void QDBusPlatformMenu::setTag(quintptr tag) -{ - m_tag = tag; -} - void QDBusPlatformMenu::setText(const QString &text) { m_text = text; diff --git a/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu_p.h b/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu_p.h index 49b7316d11..8a31f82fb0 100644 --- a/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu_p.h +++ b/src/platformsupport/themes/genericunix/dbusmenu/qdbusplatformmenu_p.h @@ -73,50 +73,44 @@ class QDBusPlatformMenuItem : public QPlatformMenuItem Q_OBJECT public: - QDBusPlatformMenuItem(quintptr tag = 0LL); + QDBusPlatformMenuItem(); ~QDBusPlatformMenuItem(); - quintptr tag()const Q_DECL_OVERRIDE { return m_tag; } - void setTag(quintptr tag) Q_DECL_OVERRIDE; - const QString text() const { return m_text; } - void setText(const QString &text) Q_DECL_OVERRIDE; + void setText(const QString &text) override; QIcon icon() const { return m_icon; } - void setIcon(const QIcon &icon) Q_DECL_OVERRIDE; + void setIcon(const QIcon &icon) override; const QPlatformMenu *menu() const { return m_subMenu; } - void setMenu(QPlatformMenu *menu) Q_DECL_OVERRIDE; + void setMenu(QPlatformMenu *menu) override; bool isEnabled() const { return m_isEnabled; } - void setEnabled(bool enabled) Q_DECL_OVERRIDE; + void setEnabled(bool enabled) override; bool isVisible() const { return m_isVisible; } - void setVisible(bool isVisible) Q_DECL_OVERRIDE; + void setVisible(bool isVisible) override; bool isSeparator() const { return m_isSeparator; } - void setIsSeparator(bool isSeparator) Q_DECL_OVERRIDE; - void setFont(const QFont &font) Q_DECL_OVERRIDE { Q_UNUSED(font); } - void setRole(MenuRole role) Q_DECL_OVERRIDE; + void setIsSeparator(bool isSeparator) override; + void setFont(const QFont &font) override { Q_UNUSED(font); } + void setRole(MenuRole role) override; bool isCheckable() const { return m_isCheckable; } - void setCheckable(bool checkable) Q_DECL_OVERRIDE; + void setCheckable(bool checkable) override; bool isChecked() const { return m_isChecked; } - void setChecked(bool isChecked) Q_DECL_OVERRIDE; + void setChecked(bool isChecked) override; bool hasExclusiveGroup() const { return m_hasExclusiveGroup; } - void setHasExclusiveGroup(bool hasExclusiveGroup) Q_DECL_OVERRIDE; + void setHasExclusiveGroup(bool hasExclusiveGroup) override; #ifndef QT_NO_SHORTCUT QKeySequence shortcut() const { return m_shortcut; } - void setShortcut(const QKeySequence& shortcut) Q_DECL_OVERRIDE; + void setShortcut(const QKeySequence& shortcut) override; #endif - void setIconSize(int size) Q_DECL_OVERRIDE { Q_UNUSED(size); } - void setNativeContents(WId item) Q_DECL_OVERRIDE { Q_UNUSED(item); } + void setIconSize(int size) override { Q_UNUSED(size); } + void setNativeContents(WId item) override { Q_UNUSED(item); } int dbusID() const { return m_dbusID; } void trigger(); - bool operator==(const QDBusPlatformMenuItem& other) { return m_tag == other.m_tag; } - static QDBusPlatformMenuItem *byId(int id); static QList<const QDBusPlatformMenuItem *> byIds(const QList<int> &ids); private: - quintptr m_tag; QString m_text; QIcon m_icon; QPlatformMenu *m_subMenu; @@ -137,42 +131,37 @@ class QDBusPlatformMenu : public QPlatformMenu Q_OBJECT public: - QDBusPlatformMenu(quintptr tag = 0LL); + QDBusPlatformMenu(); ~QDBusPlatformMenu(); - void insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before) Q_DECL_OVERRIDE; - void removeMenuItem(QPlatformMenuItem *menuItem) Q_DECL_OVERRIDE; + void insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *before) override; + void removeMenuItem(QPlatformMenuItem *menuItem) override; void syncSubMenu(const QDBusPlatformMenu *menu); - void syncMenuItem(QPlatformMenuItem *menuItem) Q_DECL_OVERRIDE; - void syncSeparatorsCollapsible(bool enable) Q_DECL_OVERRIDE { Q_UNUSED(enable); } - - quintptr tag()const Q_DECL_OVERRIDE { return m_tag; } - void setTag(quintptr tag) Q_DECL_OVERRIDE; + void syncMenuItem(QPlatformMenuItem *menuItem) override; + void syncSeparatorsCollapsible(bool enable) override { Q_UNUSED(enable); } const QString text() const { return m_text; } - void setText(const QString &text) Q_DECL_OVERRIDE; + void setText(const QString &text) override; QIcon icon() const { return m_icon; } - void setIcon(const QIcon &icon) Q_DECL_OVERRIDE; - bool isEnabled() const Q_DECL_OVERRIDE { return m_isEnabled; } - void setEnabled(bool enabled) Q_DECL_OVERRIDE; + void setIcon(const QIcon &icon) override; + bool isEnabled() const override { return m_isEnabled; } + void setEnabled(bool enabled) override; bool isVisible() const { return m_isVisible; } - void setVisible(bool visible) Q_DECL_OVERRIDE; - void setMinimumWidth(int width) Q_DECL_OVERRIDE { Q_UNUSED(width); } - void setFont(const QFont &font) Q_DECL_OVERRIDE { Q_UNUSED(font); } - void setMenuType(MenuType type) Q_DECL_OVERRIDE { Q_UNUSED(type); } + void setVisible(bool visible) override; + void setMinimumWidth(int width) override { Q_UNUSED(width); } + void setFont(const QFont &font) override { Q_UNUSED(font); } + void setMenuType(MenuType type) override { Q_UNUSED(type); } void setContainingMenuItem(QDBusPlatformMenuItem *item); - void showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item) Q_DECL_OVERRIDE; + void showPopup(const QWindow *parentWindow, const QRect &targetRect, const QPlatformMenuItem *item) override; - void dismiss() Q_DECL_OVERRIDE { } // Closes this and all its related menu popups + void dismiss() override { } // Closes this and all its related menu popups - QPlatformMenuItem *menuItemAt(int position) const Q_DECL_OVERRIDE; - QPlatformMenuItem *menuItemForTag(quintptr tag) const Q_DECL_OVERRIDE; + QPlatformMenuItem *menuItemAt(int position) const override; + QPlatformMenuItem *menuItemForTag(quintptr tag) const override; const QList<QDBusPlatformMenuItem *> items() const; - QPlatformMenuItem *createMenuItem() const Q_DECL_OVERRIDE; - QPlatformMenu *createSubMenu() const Q_DECL_OVERRIDE; - - bool operator==(const QDBusPlatformMenu& other) { return m_tag == other.m_tag; } + QPlatformMenuItem *createMenuItem() const override; + QPlatformMenu *createSubMenu() const override; uint revision() const { return m_revision; } @@ -184,7 +173,6 @@ signals: void popupRequested(int id, uint timestamp); private: - quintptr m_tag; QString m_text; QIcon m_icon; bool m_isEnabled; diff --git a/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon.cpp b/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon.cpp index 9baf94726d..8480c15fb7 100644 --- a/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon.cpp +++ b/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon.cpp @@ -102,17 +102,17 @@ static int instanceCount = 0; */ QDBusTrayIcon::QDBusTrayIcon() - : m_dbusConnection(Q_NULLPTR) + : m_dbusConnection(nullptr) , m_adaptor(new QStatusNotifierItemAdaptor(this)) - , m_menuAdaptor(Q_NULLPTR) - , m_menu(Q_NULLPTR) - , m_notifier(Q_NULLPTR) + , m_menuAdaptor(nullptr) + , m_menu(nullptr) + , m_notifier(nullptr) , m_instanceId(KDEItemFormat.arg(QCoreApplication::applicationPid()).arg(++instanceCount)) , m_category(QStringLiteral("ApplicationStatus")) , m_defaultStatus(QStringLiteral("Active")) // be visible all the time. QSystemTrayIcon has no API to control this. , m_status(m_defaultStatus) - , m_tempIcon(Q_NULLPTR) - , m_tempAttentionIcon(Q_NULLPTR) + , m_tempIcon(nullptr) + , m_tempAttentionIcon(nullptr) , m_registered(false) { qCDebug(qLcTray); @@ -149,9 +149,9 @@ void QDBusTrayIcon::cleanup() if (m_registered) dBusConnection()->unregisterTrayIcon(this); delete m_dbusConnection; - m_dbusConnection = Q_NULLPTR; + m_dbusConnection = nullptr; delete m_notifier; - m_notifier = Q_NULLPTR; + m_notifier = nullptr; m_registered = false; } @@ -203,7 +203,7 @@ QTemporaryFile *QDBusTrayIcon::tempIcon(const QIcon &icon) necessity_checked = true; } if (!necessary) - return Q_NULLPTR; + return nullptr; qreal dpr = qGuiApp->devicePixelRatio(); QTemporaryFile *ret = new QTemporaryFile(TempFileTemplate, this); ret->open(); diff --git a/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon_p.h b/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon_p.h index 4c9bc8f7e3..7034a7edb4 100644 --- a/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon_p.h +++ b/src/platformsupport/themes/genericunix/dbustray/qdbustrayicon_p.h @@ -91,18 +91,18 @@ public: QDBusMenuConnection * dBusConnection(); - void init() Q_DECL_OVERRIDE; - void cleanup() Q_DECL_OVERRIDE; - void updateIcon(const QIcon &icon) Q_DECL_OVERRIDE; - void updateToolTip(const QString &tooltip) Q_DECL_OVERRIDE; - void updateMenu(QPlatformMenu *menu) Q_DECL_OVERRIDE; - QPlatformMenu *createMenu() const Q_DECL_OVERRIDE; + void init() override; + void cleanup() override; + void updateIcon(const QIcon &icon) override; + void updateToolTip(const QString &tooltip) override; + void updateMenu(QPlatformMenu *menu) override; + QPlatformMenu *createMenu() const override; void showMessage(const QString &title, const QString &msg, - const QIcon &icon, MessageIcon iconType, int msecs) Q_DECL_OVERRIDE; + const QIcon &icon, MessageIcon iconType, int msecs) override; - bool isSystemTrayAvailable() const Q_DECL_OVERRIDE; - bool supportsMessages() const Q_DECL_OVERRIDE { return true; } - QRect geometry() const Q_DECL_OVERRIDE { return QRect(); } + bool isSystemTrayAvailable() const override; + bool supportsMessages() const override { return true; } + QRect geometry() const override { return QRect(); } QString category() const { return m_category; } QString status() const { return m_status; } diff --git a/src/platformsupport/themes/genericunix/dbustray/qdbustraytypes.cpp b/src/platformsupport/themes/genericunix/dbustray/qdbustraytypes.cpp index fc0fa00655..fc49fcbea9 100644 --- a/src/platformsupport/themes/genericunix/dbustray/qdbustraytypes.cpp +++ b/src/platformsupport/themes/genericunix/dbustray/qdbustraytypes.cpp @@ -104,7 +104,7 @@ QXdgDBusImageVector iconToQXdgDBusImageVector(const QIcon &icon) } // copy and endian-convert QXdgDBusImageStruct kim(im.width(), im.height()); - const uchar *end = im.constBits() + im.byteCount(); + const uchar *end = im.constBits() + im.sizeInBytes(); uchar *dest = reinterpret_cast<uchar *>(kim.data.data()); for (const uchar *src = im.constBits(); src < end; src += 4, dest += 4) qToUnaligned(qToBigEndian<quint32>(qFromUnaligned<quint32>(src)), dest); diff --git a/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp b/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp index 4e7421e98f..63a860f251 100644 --- a/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp +++ b/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp @@ -87,14 +87,6 @@ void ResourceHelper::clear() std::fill(fonts, fonts + QPlatformTheme::NFonts, static_cast<QFont *>(0)); } -/*! - \class QGenericX11ThemeQKdeTheme - \brief QGenericX11Theme is a generic theme implementation for X11. - \since 5.0 - \internal - \ingroup qpa -*/ - const char *QGenericUnixTheme::name = "generic"; // Default system font, corresponding to the value returned by 4.8 for @@ -186,6 +178,12 @@ QStringList QGenericUnixTheme::xdgIconThemePaths() paths.append(xdgIconsDir.absoluteFilePath()); } + return paths; +} + +QStringList QGenericUnixTheme::iconFallbackPaths() +{ + QStringList paths; const QFileInfo pixmapsIconsDir(QStringLiteral("/usr/share/pixmaps")); if (pixmapsIconsDir.isDir()) paths.append(pixmapsIconsDir.absoluteFilePath()); @@ -207,7 +205,7 @@ QPlatformSystemTrayIcon *QGenericUnixTheme::createPlatformSystemTrayIcon() const { if (isDBusTrayAvailable()) return new QDBusTrayIcon(); - return Q_NULLPTR; + return nullptr; } #endif @@ -218,6 +216,8 @@ QVariant QGenericUnixTheme::themeHint(ThemeHint hint) const return QVariant(QString(QStringLiteral("hicolor"))); case QPlatformTheme::IconThemeSearchPaths: return xdgIconThemePaths(); + case QPlatformTheme::IconFallbackSearchPaths: + return iconFallbackPaths(); case QPlatformTheme::DialogButtonBoxButtonsHaveIcons: return QVariant(true); case QPlatformTheme::StyleNames: { @@ -682,7 +682,7 @@ QPlatformSystemTrayIcon *QKdeTheme::createPlatformSystemTrayIcon() const { if (isDBusTrayAvailable()) return new QDBusTrayIcon(); - return Q_NULLPTR; + return nullptr; } #endif @@ -701,7 +701,7 @@ const char *QGnomeTheme::name = "gnome"; class QGnomeThemePrivate : public QPlatformThemePrivate { public: - QGnomeThemePrivate() : systemFont(Q_NULLPTR), fixedFont(Q_NULLPTR) {} + QGnomeThemePrivate() : systemFont(nullptr), fixedFont(nullptr) {} ~QGnomeThemePrivate() { delete systemFont; delete fixedFont; } void configureFonts(const QString >kFontName) const @@ -801,7 +801,7 @@ QPlatformSystemTrayIcon *QGnomeTheme::createPlatformSystemTrayIcon() const { if (isDBusTrayAvailable()) return new QDBusTrayIcon(); - return Q_NULLPTR; + return nullptr; } #endif @@ -839,7 +839,7 @@ QPlatformTheme *QGenericUnixTheme::createUnixTheme(const QString &name) #endif if (name == QLatin1String(QGnomeTheme::name)) return new QGnomeTheme; - return Q_NULLPTR; + return nullptr; } QStringList QGenericUnixTheme::themeNames() diff --git a/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h b/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h index da13390662..865a624694 100644 --- a/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h +++ b/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h @@ -81,15 +81,16 @@ public: static QPlatformTheme *createUnixTheme(const QString &name); static QStringList themeNames(); - const QFont *font(Font type) const Q_DECL_OVERRIDE; - QVariant themeHint(ThemeHint hint) const Q_DECL_OVERRIDE; + const QFont *font(Font type) const override; + QVariant themeHint(ThemeHint hint) const override; static QStringList xdgIconThemePaths(); + static QStringList iconFallbackPaths(); #ifndef QT_NO_DBUS - QPlatformMenuBar *createPlatformMenuBar() const Q_DECL_OVERRIDE; + QPlatformMenuBar *createPlatformMenuBar() const override; #endif #if !defined(QT_NO_DBUS) && !defined(QT_NO_SYSTEMTRAYICON) - QPlatformSystemTrayIcon *createPlatformSystemTrayIcon() const Q_DECL_OVERRIDE; + QPlatformSystemTrayIcon *createPlatformSystemTrayIcon() const override; #endif static const char *name; @@ -105,19 +106,19 @@ public: QKdeTheme(const QStringList& kdeDirs, int kdeVersion); static QPlatformTheme *createKdeTheme(); - QVariant themeHint(ThemeHint hint) const Q_DECL_OVERRIDE; + QVariant themeHint(ThemeHint hint) const override; QIcon fileIcon(const QFileInfo &fileInfo, QPlatformTheme::IconOptions iconOptions = 0) const override; - const QPalette *palette(Palette type = SystemPalette) const Q_DECL_OVERRIDE; + const QPalette *palette(Palette type = SystemPalette) const override; - const QFont *font(Font type) const Q_DECL_OVERRIDE; + const QFont *font(Font type) const override; #ifndef QT_NO_DBUS - QPlatformMenuBar *createPlatformMenuBar() const Q_DECL_OVERRIDE; + QPlatformMenuBar *createPlatformMenuBar() const override; #endif #if !defined(QT_NO_DBUS) && !defined(QT_NO_SYSTEMTRAYICON) - QPlatformSystemTrayIcon *createPlatformSystemTrayIcon() const Q_DECL_OVERRIDE; + QPlatformSystemTrayIcon *createPlatformSystemTrayIcon() const override; #endif static const char *name; @@ -131,18 +132,18 @@ class QGnomeTheme : public QPlatformTheme Q_DECLARE_PRIVATE(QGnomeTheme) public: QGnomeTheme(); - QVariant themeHint(ThemeHint hint) const Q_DECL_OVERRIDE; + QVariant themeHint(ThemeHint hint) const override; QIcon fileIcon(const QFileInfo &fileInfo, QPlatformTheme::IconOptions = 0) const override; - const QFont *font(Font type) const Q_DECL_OVERRIDE; - QString standardButtonText(int button) const Q_DECL_OVERRIDE; + const QFont *font(Font type) const override; + QString standardButtonText(int button) const override; virtual QString gtkFontName() const; #ifndef QT_NO_DBUS - QPlatformMenuBar *createPlatformMenuBar() const Q_DECL_OVERRIDE; + QPlatformMenuBar *createPlatformMenuBar() const override; #endif #if !defined(QT_NO_DBUS) && !defined(QT_NO_SYSTEMTRAYICON) - QPlatformSystemTrayIcon *createPlatformSystemTrayIcon() const Q_DECL_OVERRIDE; + QPlatformSystemTrayIcon *createPlatformSystemTrayIcon() const override; #endif static const char *name; diff --git a/src/platformsupport/themes/themes.pro b/src/platformsupport/themes/themes.pro index aeed4d2f47..44f94fafc8 100644 --- a/src/platformsupport/themes/themes.pro +++ b/src/platformsupport/themes/themes.pro @@ -6,7 +6,7 @@ CONFIG += static internal_module DEFINES += QT_NO_CAST_FROM_ASCII -unix:!darwin: \ +if(unix:!darwin)|qtConfig(xcb): \ include($$PWD/genericunix/genericunix.pri) HEADERS += \ diff --git a/src/platformsupport/vkconvenience/qbasicvulkanplatforminstance.cpp b/src/platformsupport/vkconvenience/qbasicvulkanplatforminstance.cpp new file mode 100644 index 0000000000..382d142334 --- /dev/null +++ b/src/platformsupport/vkconvenience/qbasicvulkanplatforminstance.cpp @@ -0,0 +1,357 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qbasicvulkanplatforminstance_p.h" +#include <QLibrary> +#include <QCoreApplication> +#include <QVector> +#include <QLoggingCategory> + +QT_BEGIN_NAMESPACE + +Q_LOGGING_CATEGORY(lcPlatVk, "qt.vulkan") + +/*! + \class QBasicPlatformVulkanInstance + \brief A generic platform Vulkan instance implementation. + \since 5.10 + \internal + \ingroup qpa + + Implements QPlatformVulkanInstance, serving as a base for platform-specific + implementations. The library loading and any WSI-specifics are excluded. + + Subclasses are expected to call init() from their constructor and + initInstance() from their createOrAdoptInstance() implementation. + */ + +QBasicPlatformVulkanInstance::QBasicPlatformVulkanInstance() + : m_vkInst(VK_NULL_HANDLE), + m_vkGetInstanceProcAddr(nullptr), + m_ownsVkInst(false), + m_errorCode(VK_SUCCESS), + m_debugCallback(0) +{ +} + +QBasicPlatformVulkanInstance::~QBasicPlatformVulkanInstance() +{ + if (!m_vkInst) + return; + + if (m_debugCallback && m_vkDestroyDebugReportCallbackEXT) + m_vkDestroyDebugReportCallbackEXT(m_vkInst, m_debugCallback, nullptr); + + if (m_ownsVkInst) + m_vkDestroyInstance(m_vkInst, nullptr); +} + +void QBasicPlatformVulkanInstance::init(QLibrary *lib) +{ + if (m_vkGetInstanceProcAddr) + return; + + qCDebug(lcPlatVk, "Vulkan init (%s)", qPrintable(lib->fileName())); + + // While not strictly required with every implementation, try to follow the spec + // and do not rely on core functions being exported. + // + // 1. dlsym vkGetInstanceProcAddr + // 2. with a special null instance resolve vkCreateInstance and vkEnumerateInstance* + // 3. all other core functions are resolved with the created instance + + m_vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(lib->resolve("vkGetInstanceProcAddr")); + if (!m_vkGetInstanceProcAddr) { + qWarning("Failed to find vkGetInstanceProcAddr"); + return; + } + + m_vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(m_vkGetInstanceProcAddr(VK_NULL_HANDLE, "vkCreateInstance")); + if (!m_vkCreateInstance) { + qWarning("Failed to find vkCreateInstance"); + return; + } + m_vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>( + m_vkGetInstanceProcAddr(VK_NULL_HANDLE, "vkEnumerateInstanceLayerProperties")); + if (!m_vkEnumerateInstanceLayerProperties) { + qWarning("Failed to find vkEnumerateInstanceLayerProperties"); + return; + } + m_vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>( + m_vkGetInstanceProcAddr(VK_NULL_HANDLE, "vkEnumerateInstanceExtensionProperties")); + if (!m_vkEnumerateInstanceExtensionProperties) { + qWarning("Failed to find vkEnumerateInstanceExtensionProperties"); + return; + } + + uint32_t layerCount = 0; + m_vkEnumerateInstanceLayerProperties(&layerCount, nullptr); + if (layerCount) { + QVector<VkLayerProperties> layerProps(layerCount); + m_vkEnumerateInstanceLayerProperties(&layerCount, layerProps.data()); + m_supportedLayers.reserve(layerCount); + for (const VkLayerProperties &p : qAsConst(layerProps)) { + QVulkanLayer layer; + layer.name = p.layerName; + layer.version = p.implementationVersion; + layer.specVersion = QVersionNumber(VK_VERSION_MAJOR(p.specVersion), + VK_VERSION_MINOR(p.specVersion), + VK_VERSION_PATCH(p.specVersion)); + layer.description = p.description; + m_supportedLayers.append(layer); + } + } + qCDebug(lcPlatVk) << "Supported Vulkan instance layers:" << m_supportedLayers; + + uint32_t extCount = 0; + m_vkEnumerateInstanceExtensionProperties(nullptr, &extCount, nullptr); + if (extCount) { + QVector<VkExtensionProperties> extProps(extCount); + m_vkEnumerateInstanceExtensionProperties(nullptr, &extCount, extProps.data()); + m_supportedExtensions.reserve(extCount); + for (const VkExtensionProperties &p : qAsConst(extProps)) { + QVulkanExtension ext; + ext.name = p.extensionName; + ext.version = p.specVersion; + m_supportedExtensions.append(ext); + } + } + qDebug(lcPlatVk) << "Supported Vulkan instance extensions:" << m_supportedExtensions; +} + +QVulkanInfoVector<QVulkanLayer> QBasicPlatformVulkanInstance::supportedLayers() const +{ + return m_supportedLayers; +} + +QVulkanInfoVector<QVulkanExtension> QBasicPlatformVulkanInstance::supportedExtensions() const +{ + return m_supportedExtensions; +} + +void QBasicPlatformVulkanInstance::initInstance(QVulkanInstance *instance, const QByteArrayList &extraExts) +{ + if (!m_vkGetInstanceProcAddr) { + qWarning("initInstance: No Vulkan library available"); + return; + } + + m_vkInst = instance->vkInstance(); // when non-null we are adopting an existing instance + + QVulkanInstance::Flags flags = instance->flags(); + m_enabledLayers = instance->layers(); + m_enabledExtensions = instance->extensions(); + + if (!m_vkInst) { + VkApplicationInfo appInfo; + memset(&appInfo, 0, sizeof(appInfo)); + appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + QByteArray appName = QCoreApplication::applicationName().toUtf8(); + appInfo.pApplicationName = appName.constData(); + const QVersionNumber apiVersion = instance->apiVersion(); + if (!apiVersion.isNull()) { + appInfo.apiVersion = VK_MAKE_VERSION(apiVersion.majorVersion(), + apiVersion.minorVersion(), + apiVersion.microVersion()); + } + + if (!flags.testFlag(QVulkanInstance::NoDebugOutputRedirect)) + m_enabledExtensions.append("VK_EXT_debug_report"); + + m_enabledExtensions.append("VK_KHR_surface"); + + for (const QByteArray &ext : extraExts) + m_enabledExtensions.append(ext); + + // No clever stuff with QSet and friends: the order for layers matters + // and the user-provided order must be kept. + for (int i = 0; i < m_enabledLayers.count(); ++i) { + const QByteArray &layerName(m_enabledLayers[i]); + if (!m_supportedLayers.contains(layerName)) + m_enabledLayers.removeAt(i--); + } + qDebug(lcPlatVk) << "Enabling Vulkan instance layers:" << m_enabledLayers; + for (int i = 0; i < m_enabledExtensions.count(); ++i) { + const QByteArray &extName(m_enabledExtensions[i]); + if (!m_supportedExtensions.contains(extName)) + m_enabledExtensions.removeAt(i--); + } + qDebug(lcPlatVk) << "Enabling Vulkan instance extensions:" << m_enabledExtensions; + + VkInstanceCreateInfo instInfo; + memset(&instInfo, 0, sizeof(instInfo)); + instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + instInfo.pApplicationInfo = &appInfo; + + QVector<const char *> layerNameVec; + for (const QByteArray &ba : qAsConst(m_enabledLayers)) + layerNameVec.append(ba.constData()); + if (!layerNameVec.isEmpty()) { + instInfo.enabledLayerCount = layerNameVec.count(); + instInfo.ppEnabledLayerNames = layerNameVec.constData(); + } + + QVector<const char *> extNameVec; + for (const QByteArray &ba : qAsConst(m_enabledExtensions)) + extNameVec.append(ba.constData()); + if (!extNameVec.isEmpty()) { + instInfo.enabledExtensionCount = extNameVec.count(); + instInfo.ppEnabledExtensionNames = extNameVec.constData(); + } + + m_errorCode = m_vkCreateInstance(&instInfo, nullptr, &m_vkInst); + if (m_errorCode != VK_SUCCESS || !m_vkInst) { + qWarning("Failed to create Vulkan instance: %d", m_errorCode); + return; + } + + m_vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(m_vkGetInstanceProcAddr(m_vkInst, "vkDestroyInstance")); + if (!m_vkDestroyInstance) { + qWarning("Failed to find vkDestroyInstance"); + m_vkInst = VK_NULL_HANDLE; + return; + } + + m_ownsVkInst = true; + } + + m_getPhysDevSurfaceSupport = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>( + m_vkGetInstanceProcAddr(m_vkInst, "vkGetPhysicalDeviceSurfaceSupportKHR")); + if (!m_getPhysDevSurfaceSupport) + qWarning("Failed to find vkGetPhysicalDeviceSurfaceSupportKHR"); + + if (!flags.testFlag(QVulkanInstance::NoDebugOutputRedirect)) + setupDebugOutput(); +} + +bool QBasicPlatformVulkanInstance::isValid() const +{ + return m_vkInst != VK_NULL_HANDLE; +} + +VkResult QBasicPlatformVulkanInstance::errorCode() const +{ + return m_errorCode; +} + +VkInstance QBasicPlatformVulkanInstance::vkInstance() const +{ + return m_vkInst; +} + +QByteArrayList QBasicPlatformVulkanInstance::enabledLayers() const +{ + return m_enabledLayers; +} + +QByteArrayList QBasicPlatformVulkanInstance::enabledExtensions() const +{ + return m_enabledExtensions; +} + +PFN_vkVoidFunction QBasicPlatformVulkanInstance::getInstanceProcAddr(const char *name) +{ + if (!name) + return nullptr; + + const bool needsNullInstance = !strcmp(name, "vkEnumerateInstanceLayerProperties") + || !strcmp(name, "vkEnumerateInstanceExtensionProperties"); + + return m_vkGetInstanceProcAddr(needsNullInstance ? 0 : m_vkInst, name); +} + +bool QBasicPlatformVulkanInstance::supportsPresent(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + QWindow *window) +{ + if (!m_getPhysDevSurfaceSupport) + return true; + + VkSurfaceKHR surface = QVulkanInstance::surfaceForWindow(window); + VkBool32 supported = false; + m_getPhysDevSurfaceSupport(physicalDevice, queueFamilyIndex, surface, &supported); + + return supported; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL defaultDebugCallbackFunc(VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char *pLayerPrefix, + const char *pMessage, + void *pUserData) +{ + Q_UNUSED(flags); + Q_UNUSED(objectType); + Q_UNUSED(object); + Q_UNUSED(location); + Q_UNUSED(pUserData); + + // not categorized, just route to plain old qDebug + qDebug("vkDebug: %s: %d: %s", pLayerPrefix, messageCode, pMessage); + + return VK_FALSE; +} + +void QBasicPlatformVulkanInstance::setupDebugOutput() +{ + if (!m_enabledExtensions.contains("VK_EXT_debug_report")) + return; + + PFN_vkCreateDebugReportCallbackEXT createDebugReportCallback = reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>( + m_vkGetInstanceProcAddr(m_vkInst, "vkCreateDebugReportCallbackEXT")); + m_vkDestroyDebugReportCallbackEXT = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>( + m_vkGetInstanceProcAddr(m_vkInst, "vkDestroyDebugReportCallbackEXT")); + + VkDebugReportCallbackCreateInfoEXT dbgCallbackInfo; + memset(&dbgCallbackInfo, 0, sizeof(dbgCallbackInfo)); + dbgCallbackInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; + dbgCallbackInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT + | VK_DEBUG_REPORT_WARNING_BIT_EXT + | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; + dbgCallbackInfo.pfnCallback = defaultDebugCallbackFunc; + + VkResult err = createDebugReportCallback(m_vkInst, &dbgCallbackInfo, nullptr, &m_debugCallback); + if (err != VK_SUCCESS) + qWarning("Failed to create debug report callback: %d", err); +} + +QT_END_NAMESPACE diff --git a/src/platformsupport/vkconvenience/qbasicvulkanplatforminstance_p.h b/src/platformsupport/vkconvenience/qbasicvulkanplatforminstance_p.h new file mode 100644 index 0000000000..748b138f01 --- /dev/null +++ b/src/platformsupport/vkconvenience/qbasicvulkanplatforminstance_p.h @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QBASICVULKANPLATFORMINSTANCE_P_H +#define QBASICVULKANPLATFORMINSTANCE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <qpa/qplatformvulkaninstance.h> + +QT_BEGIN_NAMESPACE + +class QLibrary; + +class QBasicPlatformVulkanInstance : public QPlatformVulkanInstance +{ +public: + QBasicPlatformVulkanInstance(); + ~QBasicPlatformVulkanInstance(); + + QVulkanInfoVector<QVulkanLayer> supportedLayers() const override; + QVulkanInfoVector<QVulkanExtension> supportedExtensions() const override; + bool isValid() const override; + VkResult errorCode() const override; + VkInstance vkInstance() const override; + QByteArrayList enabledLayers() const override; + QByteArrayList enabledExtensions() const override; + PFN_vkVoidFunction getInstanceProcAddr(const char *name) override; + bool supportsPresent(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, QWindow *window) override; + +protected: + void init(QLibrary *lib); + void initInstance(QVulkanInstance *instance, const QByteArrayList &extraExts); + + VkInstance m_vkInst; + PFN_vkGetInstanceProcAddr m_vkGetInstanceProcAddr; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR m_getPhysDevSurfaceSupport; + +private: + void setupDebugOutput(); + + bool m_ownsVkInst; + VkResult m_errorCode; + QVulkanInfoVector<QVulkanLayer> m_supportedLayers; + QVulkanInfoVector<QVulkanExtension> m_supportedExtensions; + QByteArrayList m_enabledLayers; + QByteArrayList m_enabledExtensions; + + PFN_vkCreateInstance m_vkCreateInstance; + PFN_vkEnumerateInstanceLayerProperties m_vkEnumerateInstanceLayerProperties; + PFN_vkEnumerateInstanceExtensionProperties m_vkEnumerateInstanceExtensionProperties; + + PFN_vkDestroyInstance m_vkDestroyInstance; + + VkDebugReportCallbackEXT m_debugCallback; + PFN_vkDestroyDebugReportCallbackEXT m_vkDestroyDebugReportCallbackEXT; +}; + +QT_END_NAMESPACE + +#endif // QBASICVULKANPLATFORMINSTANCE_P_H diff --git a/src/platformsupport/vkconvenience/vkconvenience.pro b/src/platformsupport/vkconvenience/vkconvenience.pro new file mode 100644 index 0000000000..7a4cdb041d --- /dev/null +++ b/src/platformsupport/vkconvenience/vkconvenience.pro @@ -0,0 +1,16 @@ +TARGET = QtVulkanSupport +MODULE = vulkan_support + +QT = core-private gui-private +CONFIG += static internal_module + +DEFINES += QT_NO_CAST_FROM_ASCII +PRECOMPILED_HEADER = ../../corelib/global/qt_pch.h + +SOURCES += \ + qbasicvulkanplatforminstance.cpp + +HEADERS += \ + qbasicvulkanplatforminstance_p.h + +load(qt_module) diff --git a/src/platformsupport/windowsuiautomation/qwindowsuiawrapper.cpp b/src/platformsupport/windowsuiautomation/qwindowsuiawrapper.cpp new file mode 100644 index 0000000000..79541fe636 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/qwindowsuiawrapper.cpp @@ -0,0 +1,117 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <initguid.h> + +#include "qwindowsuiawrapper_p.h" +#include <QtCore/private/qsystemlibrary_p.h> + +QT_BEGIN_NAMESPACE + +// private constructor +QWindowsUiaWrapper::QWindowsUiaWrapper() +{ + QSystemLibrary uiaLib(QStringLiteral("UIAutomationCore")); + if (uiaLib.load()) { + m_pUiaReturnRawElementProvider = reinterpret_cast<PtrUiaReturnRawElementProvider>(uiaLib.resolve("UiaReturnRawElementProvider")); + m_pUiaHostProviderFromHwnd = reinterpret_cast<PtrUiaHostProviderFromHwnd>(uiaLib.resolve("UiaHostProviderFromHwnd")); + m_pUiaRaiseAutomationPropertyChangedEvent = reinterpret_cast<PtrUiaRaiseAutomationPropertyChangedEvent>(uiaLib.resolve("UiaRaiseAutomationPropertyChangedEvent")); + m_pUiaRaiseAutomationEvent = reinterpret_cast<PtrUiaRaiseAutomationEvent>(uiaLib.resolve("UiaRaiseAutomationEvent")); + m_pUiaClientsAreListening = reinterpret_cast<PtrUiaClientsAreListening>(uiaLib.resolve("UiaClientsAreListening")); + } +} + +QWindowsUiaWrapper::~QWindowsUiaWrapper() +{ +} + +// shared instance +QWindowsUiaWrapper *QWindowsUiaWrapper::instance() +{ + static QWindowsUiaWrapper wrapper; + return &wrapper; +} + +// True if all symbols resolved. +BOOL QWindowsUiaWrapper::ready() +{ + return m_pUiaReturnRawElementProvider + && m_pUiaHostProviderFromHwnd + && m_pUiaRaiseAutomationPropertyChangedEvent + && m_pUiaRaiseAutomationEvent + && m_pUiaClientsAreListening; +} + +BOOL QWindowsUiaWrapper::clientsAreListening() +{ + if (!m_pUiaClientsAreListening) + return FALSE; + return m_pUiaClientsAreListening(); +} + +LRESULT QWindowsUiaWrapper::returnRawElementProvider(HWND hwnd, WPARAM wParam, LPARAM lParam, IRawElementProviderSimple *el) +{ + if (!m_pUiaReturnRawElementProvider) + return static_cast<LRESULT>(NULL); + return m_pUiaReturnRawElementProvider(hwnd, wParam, lParam, el); +} + +HRESULT QWindowsUiaWrapper::hostProviderFromHwnd(HWND hwnd, IRawElementProviderSimple **ppProvider) +{ + if (!m_pUiaHostProviderFromHwnd) + return UIA_E_NOTSUPPORTED; + return m_pUiaHostProviderFromHwnd(hwnd, ppProvider); +} + +HRESULT QWindowsUiaWrapper::raiseAutomationPropertyChangedEvent(IRawElementProviderSimple *pProvider, PROPERTYID id, VARIANT oldValue, VARIANT newValue) +{ + if (!m_pUiaRaiseAutomationPropertyChangedEvent) + return UIA_E_NOTSUPPORTED; + return m_pUiaRaiseAutomationPropertyChangedEvent(pProvider, id, oldValue, newValue); +} + +HRESULT QWindowsUiaWrapper::raiseAutomationEvent(IRawElementProviderSimple *pProvider, EVENTID id) +{ + if (!m_pUiaRaiseAutomationEvent) + return UIA_E_NOTSUPPORTED; + return m_pUiaRaiseAutomationEvent(pProvider, id); +} + +QT_END_NAMESPACE + diff --git a/src/platformsupport/windowsuiautomation/qwindowsuiawrapper_p.h b/src/platformsupport/windowsuiautomation/qwindowsuiawrapper_p.h new file mode 100644 index 0000000000..3ebc3008d3 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/qwindowsuiawrapper_p.h @@ -0,0 +1,100 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QWINDOWSUIAWRAPPER_H +#define QWINDOWSUIAWRAPPER_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of other Qt classes. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtGui/private/qtguiglobal_p.h> + +#include "uiatypes_p.h" +#include "uiaattributeids_p.h" +#include "uiacontroltypeids_p.h" +#include "uiaerrorids_p.h" +#include "uiaeventids_p.h" +#include "uiageneralids_p.h" +#include "uiapatternids_p.h" +#include "uiapropertyids_p.h" +#include "uiaserverinterfaces_p.h" +#include "uiaclientinterfaces_p.h" + +QT_REQUIRE_CONFIG(accessibility); + +QT_BEGIN_NAMESPACE + +class QWindowsUiaWrapper +{ + QWindowsUiaWrapper(); + virtual ~QWindowsUiaWrapper(); +public: + static QWindowsUiaWrapper *instance(); + BOOL ready(); + BOOL clientsAreListening(); + LRESULT returnRawElementProvider(HWND hwnd, WPARAM wParam, LPARAM lParam, IRawElementProviderSimple *el); + HRESULT hostProviderFromHwnd(HWND hwnd, IRawElementProviderSimple **ppProvider); + HRESULT raiseAutomationPropertyChangedEvent(IRawElementProviderSimple *pProvider, PROPERTYID id, VARIANT oldValue, VARIANT newValue); + HRESULT raiseAutomationEvent(IRawElementProviderSimple *pProvider, EVENTID id); + +private: + typedef LRESULT (WINAPI *PtrUiaReturnRawElementProvider)(HWND, WPARAM, LPARAM, IRawElementProviderSimple *); + typedef HRESULT (WINAPI *PtrUiaHostProviderFromHwnd)(HWND, IRawElementProviderSimple **); + typedef HRESULT (WINAPI *PtrUiaRaiseAutomationPropertyChangedEvent)(IRawElementProviderSimple *, PROPERTYID, VARIANT, VARIANT); + typedef HRESULT (WINAPI *PtrUiaRaiseAutomationEvent)(IRawElementProviderSimple *, EVENTID); + typedef BOOL (WINAPI *PtrUiaClientsAreListening)(); + PtrUiaReturnRawElementProvider m_pUiaReturnRawElementProvider = nullptr; + PtrUiaHostProviderFromHwnd m_pUiaHostProviderFromHwnd = nullptr; + PtrUiaRaiseAutomationPropertyChangedEvent m_pUiaRaiseAutomationPropertyChangedEvent = nullptr; + PtrUiaRaiseAutomationEvent m_pUiaRaiseAutomationEvent = nullptr; + PtrUiaClientsAreListening m_pUiaClientsAreListening = nullptr; +}; + +QT_END_NAMESPACE + +#endif //QWINDOWSUIAWRAPPER_H + diff --git a/src/platformsupport/windowsuiautomation/uiaattributeids_p.h b/src/platformsupport/windowsuiautomation/uiaattributeids_p.h new file mode 100644 index 0000000000..52e7306a67 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiaattributeids_p.h @@ -0,0 +1,88 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIAATTRIBUTEIDS_H +#define UIAATTRIBUTEIDS_H + +#define UIA_AnimationStyleAttributeId 40000 +#define UIA_BackgroundColorAttributeId 40001 +#define UIA_BulletStyleAttributeId 40002 +#define UIA_CapStyleAttributeId 40003 +#define UIA_CultureAttributeId 40004 +#define UIA_FontNameAttributeId 40005 +#define UIA_FontSizeAttributeId 40006 +#define UIA_FontWeightAttributeId 40007 +#define UIA_ForegroundColorAttributeId 40008 +#define UIA_HorizontalTextAlignmentAttributeId 40009 +#define UIA_IndentationFirstLineAttributeId 40010 +#define UIA_IndentationLeadingAttributeId 40011 +#define UIA_IndentationTrailingAttributeId 40012 +#define UIA_IsHiddenAttributeId 40013 +#define UIA_IsItalicAttributeId 40014 +#define UIA_IsReadOnlyAttributeId 40015 +#define UIA_IsSubscriptAttributeId 40016 +#define UIA_IsSuperscriptAttributeId 40017 +#define UIA_MarginBottomAttributeId 40018 +#define UIA_MarginLeadingAttributeId 40019 +#define UIA_MarginTopAttributeId 40020 +#define UIA_MarginTrailingAttributeId 40021 +#define UIA_OutlineStylesAttributeId 40022 +#define UIA_OverlineColorAttributeId 40023 +#define UIA_OverlineStyleAttributeId 40024 +#define UIA_StrikethroughColorAttributeId 40025 +#define UIA_StrikethroughStyleAttributeId 40026 +#define UIA_TabsAttributeId 40027 +#define UIA_TextFlowDirectionsAttributeId 40028 +#define UIA_UnderlineColorAttributeId 40029 +#define UIA_UnderlineStyleAttributeId 40030 +#define UIA_AnnotationTypesAttributeId 40031 +#define UIA_AnnotationObjectsAttributeId 40032 +#define UIA_StyleNameAttributeId 40033 +#define UIA_StyleIdAttributeId 40034 +#define UIA_LinkAttributeId 40035 +#define UIA_IsActiveAttributeId 40036 +#define UIA_SelectionActiveEndAttributeId 40037 +#define UIA_CaretPositionAttributeId 40038 +#define UIA_CaretBidiModeAttributeId 40039 +#define UIA_LineSpacingAttributeId 40040 +#define UIA_BeforeParagraphSpacingAttributeId 40041 +#define UIA_AfterParagraphSpacingAttributeId 40042 +#define UIA_SayAsInterpretAsAttributeId 40043 + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiaclientinterfaces_p.h b/src/platformsupport/windowsuiautomation/uiaclientinterfaces_p.h new file mode 100644 index 0000000000..b95c05f6a4 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiaclientinterfaces_p.h @@ -0,0 +1,255 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIACLIENTINTERFACES_H +#define UIACLIENTINTERFACES_H + +#include <Unknwn.h> + +#ifndef __IUIAutomationElement_INTERFACE_DEFINED__ + +struct IUIAutomationCondition; +struct IUIAutomationCacheRequest; +struct IUIAutomationElementArray; +struct IUIAutomationTreeWalker; +struct IUIAutomationEventHandler; +struct IUIAutomationPropertyChangedEventHandler; +struct IUIAutomationStructureChangedEventHandler; +struct IUIAutomationFocusChangedEventHandler; +struct IUIAutomationProxyFactory; +struct IUIAutomationProxyFactoryEntry; +struct IUIAutomationProxyFactoryMapping; +#ifndef __IAccessible_FWD_DEFINED__ +#define __IAccessible_FWD_DEFINED__ +struct IAccessible; +#endif /* __IAccessible_FWD_DEFINED__ */ + +#define __IUIAutomationElement_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IUIAutomationElement, 0xd22108aa, 0x8ac5, 0x49a5, 0x83,0x7b, 0x37,0xbb,0xb3,0xd7,0x59,0x1e); +MIDL_INTERFACE("d22108aa-8ac5-49a5-837b-37bbb3d7591e") +IUIAutomationElement : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE SetFocus() = 0; + virtual HRESULT STDMETHODCALLTYPE GetRuntimeId(__RPC__deref_out_opt SAFEARRAY **runtimeId) = 0; + virtual HRESULT STDMETHODCALLTYPE FindFirst(enum TreeScope scope, __RPC__in_opt IUIAutomationCondition *condition, __RPC__deref_out_opt IUIAutomationElement **found) = 0; + virtual HRESULT STDMETHODCALLTYPE FindAll(enum TreeScope scope, __RPC__in_opt IUIAutomationCondition *condition, __RPC__deref_out_opt IUIAutomationElementArray **found) = 0; + virtual HRESULT STDMETHODCALLTYPE FindFirstBuildCache(enum TreeScope scope, __RPC__in_opt IUIAutomationCondition *condition, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **found) = 0; + virtual HRESULT STDMETHODCALLTYPE FindAllBuildCache(enum TreeScope scope, __RPC__in_opt IUIAutomationCondition *condition, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElementArray **found) = 0; + virtual HRESULT STDMETHODCALLTYPE BuildUpdatedCache(__RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **updatedElement) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCurrentPropertyValue(PROPERTYID propertyId, __RPC__out VARIANT *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCurrentPropertyValueEx(PROPERTYID propertyId, BOOL ignoreDefaultValue, __RPC__out VARIANT *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCachedPropertyValue(PROPERTYID propertyId, __RPC__out VARIANT *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCachedPropertyValueEx(PROPERTYID propertyId, BOOL ignoreDefaultValue, __RPC__out VARIANT *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCurrentPatternAs(PATTERNID patternId, __RPC__in REFIID riid, __RPC__deref_out_opt void **patternObject) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCachedPatternAs(PATTERNID patternId, __RPC__in REFIID riid, __RPC__deref_out_opt void **patternObject) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCurrentPattern(PATTERNID patternId, __RPC__deref_out_opt IUnknown **patternObject) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCachedPattern(PATTERNID patternId, __RPC__deref_out_opt IUnknown **patternObject) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCachedParent(__RPC__deref_out_opt IUIAutomationElement **parent) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCachedChildren(__RPC__deref_out_opt IUIAutomationElementArray **children) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentProcessId(__RPC__out int *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentControlType(__RPC__out CONTROLTYPEID *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentLocalizedControlType(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentName(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentAcceleratorKey(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentAccessKey(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentHasKeyboardFocus(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsKeyboardFocusable(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsEnabled(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentAutomationId(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentClassName(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentHelpText(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentCulture(__RPC__out int *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsControlElement(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsContentElement(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsPassword(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentNativeWindowHandle(__RPC__deref_out_opt UIA_HWND *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentItemType(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsOffscreen(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentOrientation(__RPC__out enum OrientationType *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentFrameworkId(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsRequiredForForm(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentItemStatus(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentBoundingRectangle(__RPC__out RECT *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentLabeledBy(__RPC__deref_out_opt IUIAutomationElement **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentAriaRole(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentAriaProperties(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentIsDataValidForForm(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentControllerFor(__RPC__deref_out_opt IUIAutomationElementArray **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentDescribedBy(__RPC__deref_out_opt IUIAutomationElementArray **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentFlowsTo(__RPC__deref_out_opt IUIAutomationElementArray **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CurrentProviderDescription(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedProcessId(__RPC__out int *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedControlType(__RPC__out CONTROLTYPEID *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedLocalizedControlType(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedName(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedAcceleratorKey(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedAccessKey(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedHasKeyboardFocus(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsKeyboardFocusable(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsEnabled(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedAutomationId(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedClassName(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedHelpText(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedCulture(__RPC__out int *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsControlElement(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsContentElement(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsPassword(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedNativeWindowHandle(__RPC__deref_out_opt UIA_HWND *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedItemType(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsOffscreen(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedOrientation(__RPC__out enum OrientationType *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedFrameworkId(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsRequiredForForm(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedItemStatus(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedBoundingRectangle(__RPC__out RECT *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedLabeledBy(__RPC__deref_out_opt IUIAutomationElement **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedAriaRole(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedAriaProperties(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedIsDataValidForForm(__RPC__out BOOL *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedControllerFor(__RPC__deref_out_opt IUIAutomationElementArray **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedDescribedBy(__RPC__deref_out_opt IUIAutomationElementArray **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedFlowsTo(__RPC__deref_out_opt IUIAutomationElementArray **retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CachedProviderDescription(__RPC__deref_out_opt BSTR *retVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetClickablePoint(__RPC__out POINT *clickable, __RPC__out BOOL *gotClickable) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IUIAutomationElement, 0xd22108aa, 0x8ac5, 0x49a5, 0x83,0x7b, 0x37,0xbb,0xb3,0xd7,0x59,0x1e) +#endif +#endif + + +#ifndef __IUIAutomation_INTERFACE_DEFINED__ +#define __IUIAutomation_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IUIAutomation, 0x30cbe57d, 0xd9d0, 0x452a, 0xab,0x13, 0x7a,0xc5,0xac,0x48,0x25,0xee); +MIDL_INTERFACE("30cbe57d-d9d0-452a-ab13-7ac5ac4825ee") +IUIAutomation : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE CompareElements(__RPC__in_opt IUIAutomationElement *el1, __RPC__in_opt IUIAutomationElement *el2, __RPC__out BOOL *areSame) = 0; + virtual HRESULT STDMETHODCALLTYPE CompareRuntimeIds(__RPC__in SAFEARRAY * runtimeId1, __RPC__in SAFEARRAY * runtimeId2, __RPC__out BOOL *areSame) = 0; + virtual HRESULT STDMETHODCALLTYPE GetRootElement(__RPC__deref_out_opt IUIAutomationElement **root) = 0; + virtual HRESULT STDMETHODCALLTYPE ElementFromHandle(__RPC__in UIA_HWND hwnd, __RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE ElementFromPoint(POINT pt, __RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE GetFocusedElement(__RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE GetRootElementBuildCache(__RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **root) = 0; + virtual HRESULT STDMETHODCALLTYPE ElementFromHandleBuildCache(__RPC__in UIA_HWND hwnd, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE ElementFromPointBuildCache(POINT pt, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE GetFocusedElementBuildCache(__RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateTreeWalker(__RPC__in_opt IUIAutomationCondition *pCondition, __RPC__deref_out_opt IUIAutomationTreeWalker **walker) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ControlViewWalker(__RPC__deref_out_opt IUIAutomationTreeWalker **walker) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ContentViewWalker(__RPC__deref_out_opt IUIAutomationTreeWalker **walker) = 0; + virtual HRESULT STDMETHODCALLTYPE get_RawViewWalker(__RPC__deref_out_opt IUIAutomationTreeWalker **walker) = 0; + virtual HRESULT STDMETHODCALLTYPE get_RawViewCondition(__RPC__deref_out_opt IUIAutomationCondition **condition) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ControlViewCondition(__RPC__deref_out_opt IUIAutomationCondition **condition) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ContentViewCondition(__RPC__deref_out_opt IUIAutomationCondition **condition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateCacheRequest(__RPC__deref_out_opt IUIAutomationCacheRequest **cacheRequest) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateTrueCondition(__RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateFalseCondition(__RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreatePropertyCondition(PROPERTYID propertyId, VARIANT value, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreatePropertyConditionEx(PROPERTYID propertyId, VARIANT value, enum PropertyConditionFlags flags, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateAndCondition(__RPC__in_opt IUIAutomationCondition *condition1, __RPC__in_opt IUIAutomationCondition *condition2, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateAndConditionFromArray(__RPC__in_opt SAFEARRAY * conditions, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateAndConditionFromNativeArray(__RPC__in_ecount_full(conditionCount) IUIAutomationCondition **conditions, int conditionCount, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateOrCondition(__RPC__in_opt IUIAutomationCondition *condition1, __RPC__in_opt IUIAutomationCondition *condition2, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateOrConditionFromArray(__RPC__in_opt SAFEARRAY * conditions, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateOrConditionFromNativeArray(__RPC__in_ecount_full(conditionCount) IUIAutomationCondition **conditions, int conditionCount, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateNotCondition(__RPC__in_opt IUIAutomationCondition *condition, __RPC__deref_out_opt IUIAutomationCondition **newCondition) = 0; + virtual HRESULT STDMETHODCALLTYPE AddAutomationEventHandler(EVENTID eventId, __RPC__in_opt IUIAutomationElement *element, enum TreeScope scope, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__in_opt IUIAutomationEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE RemoveAutomationEventHandler(EVENTID eventId, __RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE AddPropertyChangedEventHandlerNativeArray(__RPC__in_opt IUIAutomationElement *element, enum TreeScope scope, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__in_opt IUIAutomationPropertyChangedEventHandler *handler, __RPC__in_ecount_full(propertyCount) PROPERTYID *propertyArray, int propertyCount) = 0; + virtual HRESULT STDMETHODCALLTYPE AddPropertyChangedEventHandler(__RPC__in_opt IUIAutomationElement *element, enum TreeScope scope, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__in_opt IUIAutomationPropertyChangedEventHandler *handler, __RPC__in SAFEARRAY * propertyArray) = 0; + virtual HRESULT STDMETHODCALLTYPE RemovePropertyChangedEventHandler(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationPropertyChangedEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE AddStructureChangedEventHandler(__RPC__in_opt IUIAutomationElement *element, enum TreeScope scope, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__in_opt IUIAutomationStructureChangedEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE RemoveStructureChangedEventHandler(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationStructureChangedEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE AddFocusChangedEventHandler(__RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__in_opt IUIAutomationFocusChangedEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE RemoveFocusChangedEventHandler(__RPC__in_opt IUIAutomationFocusChangedEventHandler *handler) = 0; + virtual HRESULT STDMETHODCALLTYPE RemoveAllEventHandlers() = 0; + virtual HRESULT STDMETHODCALLTYPE IntNativeArrayToSafeArray(__RPC__in_ecount_full(arrayCount) int *array, int arrayCount, __RPC__deref_out_opt SAFEARRAY **safeArray) = 0; + virtual HRESULT STDMETHODCALLTYPE IntSafeArrayToNativeArray(__RPC__in SAFEARRAY * intArray, __RPC__deref_out_ecount_full_opt(*arrayCount) int **array, __RPC__out int *arrayCount) = 0; + virtual HRESULT STDMETHODCALLTYPE RectToVariant(RECT rc, __RPC__out VARIANT *var) = 0; + virtual HRESULT STDMETHODCALLTYPE VariantToRect(VARIANT var, __RPC__out RECT *rc) = 0; + virtual HRESULT STDMETHODCALLTYPE SafeArrayToRectNativeArray(__RPC__in SAFEARRAY * rects, __RPC__deref_out_ecount_full_opt(*rectArrayCount) RECT **rectArray, __RPC__out int *rectArrayCount) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateProxyFactoryEntry(__RPC__in_opt IUIAutomationProxyFactory *factory, __RPC__deref_out_opt IUIAutomationProxyFactoryEntry **factoryEntry) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ProxyFactoryMapping(__RPC__deref_out_opt IUIAutomationProxyFactoryMapping **factoryMapping) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPropertyProgrammaticName(PROPERTYID property, __RPC__deref_out_opt BSTR *name) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPatternProgrammaticName(PATTERNID pattern, __RPC__deref_out_opt BSTR *name) = 0; + virtual HRESULT STDMETHODCALLTYPE PollForPotentialSupportedPatterns(__RPC__in_opt IUIAutomationElement *pElement, __RPC__deref_out_opt SAFEARRAY **patternIds, __RPC__deref_out_opt SAFEARRAY **patternNames) = 0; + virtual HRESULT STDMETHODCALLTYPE PollForPotentialSupportedProperties(__RPC__in_opt IUIAutomationElement *pElement, __RPC__deref_out_opt SAFEARRAY **propertyIds, __RPC__deref_out_opt SAFEARRAY **propertyNames) = 0; + virtual HRESULT STDMETHODCALLTYPE CheckNotSupported(VARIANT value, __RPC__out BOOL *isNotSupported) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ReservedNotSupportedValue(__RPC__deref_out_opt IUnknown **notSupportedValue) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ReservedMixedAttributeValue(__RPC__deref_out_opt IUnknown **mixedAttributeValue) = 0; + virtual HRESULT STDMETHODCALLTYPE ElementFromIAccessible(__RPC__in_opt IAccessible *accessible, int childId, __RPC__deref_out_opt IUIAutomationElement **element) = 0; + virtual HRESULT STDMETHODCALLTYPE ElementFromIAccessibleBuildCache(__RPC__in_opt IAccessible *accessible, int childId, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **element) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IUIAutomation, 0x30cbe57d, 0xd9d0, 0x452a, 0xab,0x13, 0x7a,0xc5,0xac,0x48,0x25,0xee) +#endif +#endif + + +#ifndef __IUIAutomationTreeWalker_INTERFACE_DEFINED__ +#define __IUIAutomationTreeWalker_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IUIAutomationTreeWalker, 0x4042c624, 0x389c, 0x4afc, 0xa6,0x30, 0x9d,0xf8,0x54,0xa5,0x41,0xfc); +MIDL_INTERFACE("4042c624-389c-4afc-a630-9df854a541fc") +IUIAutomationTreeWalker : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetParentElement(__RPC__in_opt IUIAutomationElement *element, __RPC__deref_out_opt IUIAutomationElement **parent) = 0; + virtual HRESULT STDMETHODCALLTYPE GetFirstChildElement(__RPC__in_opt IUIAutomationElement *element, __RPC__deref_out_opt IUIAutomationElement **first) = 0; + virtual HRESULT STDMETHODCALLTYPE GetLastChildElement(__RPC__in_opt IUIAutomationElement *element, __RPC__deref_out_opt IUIAutomationElement **last) = 0; + virtual HRESULT STDMETHODCALLTYPE GetNextSiblingElement(__RPC__in_opt IUIAutomationElement *element, __RPC__deref_out_opt IUIAutomationElement **next) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPreviousSiblingElement(__RPC__in_opt IUIAutomationElement *element, __RPC__deref_out_opt IUIAutomationElement **previous) = 0; + virtual HRESULT STDMETHODCALLTYPE NormalizeElement(__RPC__in_opt IUIAutomationElement *element, __RPC__deref_out_opt IUIAutomationElement **normalized) = 0; + virtual HRESULT STDMETHODCALLTYPE GetParentElementBuildCache(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **parent) = 0; + virtual HRESULT STDMETHODCALLTYPE GetFirstChildElementBuildCache(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **first) = 0; + virtual HRESULT STDMETHODCALLTYPE GetLastChildElementBuildCache(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **last) = 0; + virtual HRESULT STDMETHODCALLTYPE GetNextSiblingElementBuildCache(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **next) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPreviousSiblingElementBuildCache(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **previous) = 0; + virtual HRESULT STDMETHODCALLTYPE NormalizeElementBuildCache(__RPC__in_opt IUIAutomationElement *element, __RPC__in_opt IUIAutomationCacheRequest *cacheRequest, __RPC__deref_out_opt IUIAutomationElement **normalized) = 0; + virtual HRESULT STDMETHODCALLTYPE get_Condition(__RPC__deref_out_opt IUIAutomationCondition **condition) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IUIAutomationTreeWalker, 0x4042c624, 0x389c, 0x4afc, 0xa6,0x30, 0x9d,0xf8,0x54,0xa5,0x41,0xfc) +#endif +#endif + +DEFINE_GUID(CLSID_CUIAutomation, 0xff48dba4, 0x60ef, 0x4201, 0xaa,0x87, 0x54,0x10,0x3e,0xef,0x59,0x4e); + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiacontroltypeids_p.h b/src/platformsupport/windowsuiautomation/uiacontroltypeids_p.h new file mode 100644 index 0000000000..d77fc68da9 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiacontroltypeids_p.h @@ -0,0 +1,85 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIACONTROLTYPEIDS_H +#define UIACONTROLTYPEIDS_H + +#define UIA_ButtonControlTypeId 50000 +#define UIA_CalendarControlTypeId 50001 +#define UIA_CheckBoxControlTypeId 50002 +#define UIA_ComboBoxControlTypeId 50003 +#define UIA_EditControlTypeId 50004 +#define UIA_HyperlinkControlTypeId 50005 +#define UIA_ImageControlTypeId 50006 +#define UIA_ListItemControlTypeId 50007 +#define UIA_ListControlTypeId 50008 +#define UIA_MenuControlTypeId 50009 +#define UIA_MenuBarControlTypeId 50010 +#define UIA_MenuItemControlTypeId 50011 +#define UIA_ProgressBarControlTypeId 50012 +#define UIA_RadioButtonControlTypeId 50013 +#define UIA_ScrollBarControlTypeId 50014 +#define UIA_SliderControlTypeId 50015 +#define UIA_SpinnerControlTypeId 50016 +#define UIA_StatusBarControlTypeId 50017 +#define UIA_TabControlTypeId 50018 +#define UIA_TabItemControlTypeId 50019 +#define UIA_TextControlTypeId 50020 +#define UIA_ToolBarControlTypeId 50021 +#define UIA_ToolTipControlTypeId 50022 +#define UIA_TreeControlTypeId 50023 +#define UIA_TreeItemControlTypeId 50024 +#define UIA_CustomControlTypeId 50025 +#define UIA_GroupControlTypeId 50026 +#define UIA_ThumbControlTypeId 50027 +#define UIA_DataGridControlTypeId 50028 +#define UIA_DataItemControlTypeId 50029 +#define UIA_DocumentControlTypeId 50030 +#define UIA_SplitButtonControlTypeId 50031 +#define UIA_WindowControlTypeId 50032 +#define UIA_PaneControlTypeId 50033 +#define UIA_HeaderControlTypeId 50034 +#define UIA_HeaderItemControlTypeId 50035 +#define UIA_TableControlTypeId 50036 +#define UIA_TitleBarControlTypeId 50037 +#define UIA_SeparatorControlTypeId 50038 +#define UIA_SemanticZoomControlTypeId 50039 +#define UIA_AppBarControlTypeId 50040 + +#endif diff --git a/src/platformsupport/cglconvenience/cglconvenience_p.h b/src/platformsupport/windowsuiautomation/uiaerrorids_p.h index e531e73549..c25453007d 100644 --- a/src/platformsupport/cglconvenience/cglconvenience_p.h +++ b/src/platformsupport/windowsuiautomation/uiaerrorids_p.h @@ -1,9 +1,9 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2017 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** -** This file is part of the plugins of the Qt Toolkit. +** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage @@ -37,25 +37,15 @@ ** ****************************************************************************/ -#ifndef QMACGLCONVENIENCE_H -#define QMACGLCONVENIENCE_H +#ifndef UIAERRORIDS_H +#define UIAERRORIDS_H -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists purely as an -// implementation detail. This header file may change from version to -// version without notice, or even be removed. -// -// We mean it. -// +#define UIA_E_ELEMENTNOTENABLED 0x80040200 +#define UIA_E_ELEMENTNOTAVAILABLE 0x80040201 +#define UIA_E_NOCLICKABLEPOINT 0x80040202 +#define UIA_E_PROXYASSEMBLYNOTLOADED 0x80040203 +#define UIA_E_NOTSUPPORTED 0x80040204 +#define UIA_E_INVALIDOPERATION 0x80131509 +#define UIA_E_TIMEOUT 0x80131505 -#include <QSurfaceFormat> -#include <QString> -#include <OpenGL/OpenGL.h> - -QSurfaceFormat qcgl_surfaceFormat(); -void *qcgl_createNSOpenGLPixelFormat(const QSurfaceFormat &format); - -#endif // QMACGLCONVENIENCE_H +#endif diff --git a/src/platformsupport/windowsuiautomation/uiaeventids_p.h b/src/platformsupport/windowsuiautomation/uiaeventids_p.h new file mode 100644 index 0000000000..2b414968ed --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiaeventids_p.h @@ -0,0 +1,79 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIAEVENTIDS_H +#define UIAEVENTIDS_H + +#define UIA_ToolTipOpenedEventId 20000 +#define UIA_ToolTipClosedEventId 20001 +#define UIA_StructureChangedEventId 20002 +#define UIA_MenuOpenedEventId 20003 +#define UIA_AutomationPropertyChangedEventId 20004 +#define UIA_AutomationFocusChangedEventId 20005 +#define UIA_AsyncContentLoadedEventId 20006 +#define UIA_MenuClosedEventId 20007 +#define UIA_LayoutInvalidatedEventId 20008 +#define UIA_Invoke_InvokedEventId 20009 +#define UIA_SelectionItem_ElementAddedToSelectionEventId 20010 +#define UIA_SelectionItem_ElementRemovedFromSelectionEventId 20011 +#define UIA_SelectionItem_ElementSelectedEventId 20012 +#define UIA_Selection_InvalidatedEventId 20013 +#define UIA_Text_TextSelectionChangedEventId 20014 +#define UIA_Text_TextChangedEventId 20015 +#define UIA_Window_WindowOpenedEventId 20016 +#define UIA_Window_WindowClosedEventId 20017 +#define UIA_MenuModeStartEventId 20018 +#define UIA_MenuModeEndEventId 20019 +#define UIA_InputReachedTargetEventId 20020 +#define UIA_InputReachedOtherElementEventId 20021 +#define UIA_InputDiscardedEventId 20022 +#define UIA_SystemAlertEventId 20023 +#define UIA_LiveRegionChangedEventId 20024 +#define UIA_HostedFragmentRootsInvalidatedEventId 20025 +#define UIA_Drag_DragStartEventId 20026 +#define UIA_Drag_DragCancelEventId 20027 +#define UIA_Drag_DragCompleteEventId 20028 +#define UIA_DropTarget_DragEnterEventId 20029 +#define UIA_DropTarget_DragLeaveEventId 20030 +#define UIA_DropTarget_DroppedEventId 20031 +#define UIA_TextEdit_TextChangedEventId 20032 +#define UIA_TextEdit_ConversionTargetChangedEventId 20033 +#define UIA_ChangesEventId 20034 + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiageneralids_p.h b/src/platformsupport/windowsuiautomation/uiageneralids_p.h new file mode 100644 index 0000000000..62c795b94a --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiageneralids_p.h @@ -0,0 +1,46 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIAGENERALIDS_H +#define UIAGENERALIDS_H + +#define UiaAppendRuntimeId 3 +#define UiaRootObjectId -25 + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiapatternids_p.h b/src/platformsupport/windowsuiautomation/uiapatternids_p.h new file mode 100644 index 0000000000..114aabcaa5 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiapatternids_p.h @@ -0,0 +1,78 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIAPATTERNIDS_H +#define UIAPATTERNIDS_H + +#define UIA_InvokePatternId 10000 +#define UIA_SelectionPatternId 10001 +#define UIA_ValuePatternId 10002 +#define UIA_RangeValuePatternId 10003 +#define UIA_ScrollPatternId 10004 +#define UIA_ExpandCollapsePatternId 10005 +#define UIA_GridPatternId 10006 +#define UIA_GridItemPatternId 10007 +#define UIA_MultipleViewPatternId 10008 +#define UIA_WindowPatternId 10009 +#define UIA_SelectionItemPatternId 10010 +#define UIA_DockPatternId 10011 +#define UIA_TablePatternId 10012 +#define UIA_TableItemPatternId 10013 +#define UIA_TextPatternId 10014 +#define UIA_TogglePatternId 10015 +#define UIA_TransformPatternId 10016 +#define UIA_ScrollItemPatternId 10017 +#define UIA_LegacyIAccessiblePatternId 10018 +#define UIA_ItemContainerPatternId 10019 +#define UIA_VirtualizedItemPatternId 10020 +#define UIA_SynchronizedInputPatternId 10021 +#define UIA_ObjectModelPatternId 10022 +#define UIA_AnnotationPatternId 10023 +#define UIA_TextPattern2Id 10024 +#define UIA_StylesPatternId 10025 +#define UIA_SpreadsheetPatternId 10026 +#define UIA_SpreadsheetItemPatternId 10027 +#define UIA_TransformPattern2Id 10028 +#define UIA_TextChildPatternId 10029 +#define UIA_DragPatternId 10030 +#define UIA_DropTargetPatternId 10031 +#define UIA_TextEditPatternId 10032 +#define UIA_CustomNavigationPatternId 10033 + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiapropertyids_p.h b/src/platformsupport/windowsuiautomation/uiapropertyids_p.h new file mode 100644 index 0000000000..5c35c956f8 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiapropertyids_p.h @@ -0,0 +1,212 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIAPROPERTYIDS_H +#define UIAPROPERTYIDS_H + +#define UIA_RuntimeIdPropertyId 30000 +#define UIA_BoundingRectanglePropertyId 30001 +#define UIA_ProcessIdPropertyId 30002 +#define UIA_ControlTypePropertyId 30003 +#define UIA_LocalizedControlTypePropertyId 30004 +#define UIA_NamePropertyId 30005 +#define UIA_AcceleratorKeyPropertyId 30006 +#define UIA_AccessKeyPropertyId 30007 +#define UIA_HasKeyboardFocusPropertyId 30008 +#define UIA_IsKeyboardFocusablePropertyId 30009 +#define UIA_IsEnabledPropertyId 30010 +#define UIA_AutomationIdPropertyId 30011 +#define UIA_ClassNamePropertyId 30012 +#define UIA_HelpTextPropertyId 30013 +#define UIA_ClickablePointPropertyId 30014 +#define UIA_CulturePropertyId 30015 +#define UIA_IsControlElementPropertyId 30016 +#define UIA_IsContentElementPropertyId 30017 +#define UIA_LabeledByPropertyId 30018 +#define UIA_IsPasswordPropertyId 30019 +#define UIA_NativeWindowHandlePropertyId 30020 +#define UIA_ItemTypePropertyId 30021 +#define UIA_IsOffscreenPropertyId 30022 +#define UIA_OrientationPropertyId 30023 +#define UIA_FrameworkIdPropertyId 30024 +#define UIA_IsRequiredForFormPropertyId 30025 +#define UIA_ItemStatusPropertyId 30026 +#define UIA_IsDockPatternAvailablePropertyId 30027 +#define UIA_IsExpandCollapsePatternAvailablePropertyId 30028 +#define UIA_IsGridItemPatternAvailablePropertyId 30029 +#define UIA_IsGridPatternAvailablePropertyId 30030 +#define UIA_IsInvokePatternAvailablePropertyId 30031 +#define UIA_IsMultipleViewPatternAvailablePropertyId 30032 +#define UIA_IsRangeValuePatternAvailablePropertyId 30033 +#define UIA_IsScrollPatternAvailablePropertyId 30034 +#define UIA_IsScrollItemPatternAvailablePropertyId 30035 +#define UIA_IsSelectionItemPatternAvailablePropertyId 30036 +#define UIA_IsSelectionPatternAvailablePropertyId 30037 +#define UIA_IsTablePatternAvailablePropertyId 30038 +#define UIA_IsTableItemPatternAvailablePropertyId 30039 +#define UIA_IsTextPatternAvailablePropertyId 30040 +#define UIA_IsTogglePatternAvailablePropertyId 30041 +#define UIA_IsTransformPatternAvailablePropertyId 30042 +#define UIA_IsValuePatternAvailablePropertyId 30043 +#define UIA_IsWindowPatternAvailablePropertyId 30044 +#define UIA_ValueValuePropertyId 30045 +#define UIA_ValueIsReadOnlyPropertyId 30046 +#define UIA_RangeValueValuePropertyId 30047 +#define UIA_RangeValueIsReadOnlyPropertyId 30048 +#define UIA_RangeValueMinimumPropertyId 30049 +#define UIA_RangeValueMaximumPropertyId 30050 +#define UIA_RangeValueLargeChangePropertyId 30051 +#define UIA_RangeValueSmallChangePropertyId 30052 +#define UIA_ScrollHorizontalScrollPercentPropertyId 30053 +#define UIA_ScrollHorizontalViewSizePropertyId 30054 +#define UIA_ScrollVerticalScrollPercentPropertyId 30055 +#define UIA_ScrollVerticalViewSizePropertyId 30056 +#define UIA_ScrollHorizontallyScrollablePropertyId 30057 +#define UIA_ScrollVerticallyScrollablePropertyId 30058 +#define UIA_SelectionSelectionPropertyId 30059 +#define UIA_SelectionCanSelectMultiplePropertyId 30060 +#define UIA_SelectionIsSelectionRequiredPropertyId 30061 +#define UIA_GridRowCountPropertyId 30062 +#define UIA_GridColumnCountPropertyId 30063 +#define UIA_GridItemRowPropertyId 30064 +#define UIA_GridItemColumnPropertyId 30065 +#define UIA_GridItemRowSpanPropertyId 30066 +#define UIA_GridItemColumnSpanPropertyId 30067 +#define UIA_GridItemContainingGridPropertyId 30068 +#define UIA_DockDockPositionPropertyId 30069 +#define UIA_ExpandCollapseExpandCollapseStatePropertyId 30070 +#define UIA_MultipleViewCurrentViewPropertyId 30071 +#define UIA_MultipleViewSupportedViewsPropertyId 30072 +#define UIA_WindowCanMaximizePropertyId 30073 +#define UIA_WindowCanMinimizePropertyId 30074 +#define UIA_WindowWindowVisualStatePropertyId 30075 +#define UIA_WindowWindowInteractionStatePropertyId 30076 +#define UIA_WindowIsModalPropertyId 30077 +#define UIA_WindowIsTopmostPropertyId 30078 +#define UIA_SelectionItemIsSelectedPropertyId 30079 +#define UIA_SelectionItemSelectionContainerPropertyId 30080 +#define UIA_TableRowHeadersPropertyId 30081 +#define UIA_TableColumnHeadersPropertyId 30082 +#define UIA_TableRowOrColumnMajorPropertyId 30083 +#define UIA_TableItemRowHeaderItemsPropertyId 30084 +#define UIA_TableItemColumnHeaderItemsPropertyId 30085 +#define UIA_ToggleToggleStatePropertyId 30086 +#define UIA_TransformCanMovePropertyId 30087 +#define UIA_TransformCanResizePropertyId 30088 +#define UIA_TransformCanRotatePropertyId 30089 +#define UIA_IsLegacyIAccessiblePatternAvailablePropertyId 30090 +#define UIA_LegacyIAccessibleChildIdPropertyId 30091 +#define UIA_LegacyIAccessibleNamePropertyId 30092 +#define UIA_LegacyIAccessibleValuePropertyId 30093 +#define UIA_LegacyIAccessibleDescriptionPropertyId 30094 +#define UIA_LegacyIAccessibleRolePropertyId 30095 +#define UIA_LegacyIAccessibleStatePropertyId 30096 +#define UIA_LegacyIAccessibleHelpPropertyId 30097 +#define UIA_LegacyIAccessibleKeyboardShortcutPropertyId 30098 +#define UIA_LegacyIAccessibleSelectionPropertyId 30099 +#define UIA_LegacyIAccessibleDefaultActionPropertyId 30100 +#define UIA_AriaRolePropertyId 30101 +#define UIA_AriaPropertiesPropertyId 30102 +#define UIA_IsDataValidForFormPropertyId 30103 +#define UIA_ControllerForPropertyId 30104 +#define UIA_DescribedByPropertyId 30105 +#define UIA_FlowsToPropertyId 30106 +#define UIA_ProviderDescriptionPropertyId 30107 +#define UIA_IsItemContainerPatternAvailablePropertyId 30108 +#define UIA_IsVirtualizedItemPatternAvailablePropertyId 30109 +#define UIA_IsSynchronizedInputPatternAvailablePropertyId 30110 +#define UIA_OptimizeForVisualContentPropertyId 30111 +#define UIA_IsObjectModelPatternAvailablePropertyId 30112 +#define UIA_AnnotationAnnotationTypeIdPropertyId 30113 +#define UIA_AnnotationAnnotationTypeNamePropertyId 30114 +#define UIA_AnnotationAuthorPropertyId 30115 +#define UIA_AnnotationDateTimePropertyId 30116 +#define UIA_AnnotationTargetPropertyId 30117 +#define UIA_IsAnnotationPatternAvailablePropertyId 30118 +#define UIA_IsTextPattern2AvailablePropertyId 30119 +#define UIA_StylesStyleIdPropertyId 30120 +#define UIA_StylesStyleNamePropertyId 30121 +#define UIA_StylesFillColorPropertyId 30122 +#define UIA_StylesFillPatternStylePropertyId 30123 +#define UIA_StylesShapePropertyId 30124 +#define UIA_StylesFillPatternColorPropertyId 30125 +#define UIA_StylesExtendedPropertiesPropertyId 30126 +#define UIA_IsStylesPatternAvailablePropertyId 30127 +#define UIA_IsSpreadsheetPatternAvailablePropertyId 30128 +#define UIA_SpreadsheetItemFormulaPropertyId 30129 +#define UIA_SpreadsheetItemAnnotationObjectsPropertyId 30130 +#define UIA_SpreadsheetItemAnnotationTypesPropertyId 30131 +#define UIA_IsSpreadsheetItemPatternAvailablePropertyId 30132 +#define UIA_Transform2CanZoomPropertyId 30133 +#define UIA_IsTransformPattern2AvailablePropertyId 30134 +#define UIA_LiveSettingPropertyId 30135 +#define UIA_IsTextChildPatternAvailablePropertyId 30136 +#define UIA_IsDragPatternAvailablePropertyId 30137 +#define UIA_DragIsGrabbedPropertyId 30138 +#define UIA_DragDropEffectPropertyId 30139 +#define UIA_DragDropEffectsPropertyId 30140 +#define UIA_IsDropTargetPatternAvailablePropertyId 30141 +#define UIA_DropTargetDropTargetEffectPropertyId 30142 +#define UIA_DropTargetDropTargetEffectsPropertyId 30143 +#define UIA_DragGrabbedItemsPropertyId 30144 +#define UIA_Transform2ZoomLevelPropertyId 30145 +#define UIA_Transform2ZoomMinimumPropertyId 30146 +#define UIA_Transform2ZoomMaximumPropertyId 30147 +#define UIA_FlowsFromPropertyId 30148 +#define UIA_IsTextEditPatternAvailablePropertyId 30149 +#define UIA_IsPeripheralPropertyId 30150 +#define UIA_IsCustomNavigationPatternAvailablePropertyId 30151 +#define UIA_PositionInSetPropertyId 30152 +#define UIA_SizeOfSetPropertyId 30153 +#define UIA_LevelPropertyId 30154 +#define UIA_AnnotationTypesPropertyId 30155 +#define UIA_AnnotationObjectsPropertyId 30156 +#define UIA_LandmarkTypePropertyId 30157 +#define UIA_LocalizedLandmarkTypePropertyId 30158 +#define UIA_FullDescriptionPropertyId 30159 +#define UIA_FillColorPropertyId 30160 +#define UIA_OutlineColorPropertyId 30161 +#define UIA_FillTypePropertyId 30162 +#define UIA_VisualEffectsPropertyId 30163 +#define UIA_OutlineThicknessPropertyId 30164 +#define UIA_CenterPointPropertyId 30165 +#define UIA_RotationPropertyId 30166 +#define UIA_SizePropertyId 30167 + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiaserverinterfaces_p.h b/src/platformsupport/windowsuiautomation/uiaserverinterfaces_p.h new file mode 100644 index 0000000000..caae84755b --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiaserverinterfaces_p.h @@ -0,0 +1,352 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIASERVERINTERFACES_H +#define UIASERVERINTERFACES_H + +#include <Unknwn.h> + +#ifndef __IRawElementProviderSimple_INTERFACE_DEFINED__ +#define __IRawElementProviderSimple_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IRawElementProviderSimple, 0xd6dd68d1, 0x86fd, 0x4332, 0x86,0x66, 0x9a,0xbe,0xde,0xa2,0xd2,0x4c); +MIDL_INTERFACE("d6dd68d1-86fd-4332-8666-9abedea2d24c") +IRawElementProviderSimple : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE get_ProviderOptions(__RPC__out enum ProviderOptions *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPatternProvider(PATTERNID patternId, __RPC__deref_out_opt IUnknown **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(PROPERTYID propertyId, __RPC__out VARIANT *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_HostRawElementProvider(__RPC__deref_out_opt IRawElementProviderSimple **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IRawElementProviderSimple, 0xd6dd68d1, 0x86fd, 0x4332, 0x86,0x66, 0x9a,0xbe,0xde,0xa2,0xd2,0x4c) +#endif +#endif + + +#ifndef __IRawElementProviderFragmentRoot_FWD_DEFINED__ +#define __IRawElementProviderFragmentRoot_FWD_DEFINED__ +typedef interface IRawElementProviderFragmentRoot IRawElementProviderFragmentRoot; +#endif + + +#ifndef __IRawElementProviderFragment_FWD_DEFINED__ +#define __IRawElementProviderFragment_FWD_DEFINED__ +typedef interface IRawElementProviderFragment IRawElementProviderFragment; +#endif + + +#ifndef __IRawElementProviderFragment_INTERFACE_DEFINED__ +#define __IRawElementProviderFragment_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IRawElementProviderFragment, 0xf7063da8, 0x8359, 0x439c, 0x92,0x97, 0xbb,0xc5,0x29,0x9a,0x7d,0x87); +MIDL_INTERFACE("f7063da8-8359-439c-9297-bbc5299a7d87") +IRawElementProviderFragment : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE Navigate(enum NavigateDirection direction, __RPC__deref_out_opt IRawElementProviderFragment **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetRuntimeId(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_BoundingRectangle(__RPC__out struct UiaRect *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetEmbeddedFragmentRoots(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE SetFocus() = 0; + virtual HRESULT STDMETHODCALLTYPE get_FragmentRoot(__RPC__deref_out_opt IRawElementProviderFragmentRoot **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IRawElementProviderFragment, 0xf7063da8, 0x8359, 0x439c, 0x92,0x97, 0xbb,0xc5,0x29,0x9a,0x7d,0x87) +#endif +#endif + + +#ifndef __IRawElementProviderFragmentRoot_INTERFACE_DEFINED__ +#define __IRawElementProviderFragmentRoot_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IRawElementProviderFragmentRoot, 0x620ce2a5, 0xab8f, 0x40a9, 0x86,0xcb, 0xde,0x3c,0x75,0x59,0x9b,0x58); +MIDL_INTERFACE("620ce2a5-ab8f-40a9-86cb-de3c75599b58") +IRawElementProviderFragmentRoot : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE ElementProviderFromPoint(double x, double y, __RPC__deref_out_opt IRawElementProviderFragment **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetFocus(__RPC__deref_out_opt IRawElementProviderFragment **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IRawElementProviderFragmentRoot, 0x620ce2a5, 0xab8f, 0x40a9, 0x86,0xcb, 0xde,0x3c,0x75,0x59,0x9b,0x58) +#endif +#endif + + +#ifndef __IValueProvider_INTERFACE_DEFINED__ +#define __IValueProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IValueProvider, 0xc7935180, 0x6fb3, 0x4201, 0xb1,0x74, 0x7d,0xf7,0x3a,0xdb,0xf6,0x4a); +MIDL_INTERFACE("c7935180-6fb3-4201-b174-7df73adbf64a") +IValueProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE SetValue(__RPC__in LPCWSTR val) = 0; + virtual HRESULT STDMETHODCALLTYPE get_Value(__RPC__deref_out_opt BSTR *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_IsReadOnly(__RPC__out BOOL *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IValueProvider, 0xc7935180, 0x6fb3, 0x4201, 0xb1,0x74, 0x7d,0xf7,0x3a,0xdb,0xf6,0x4a) +#endif +#endif + + +#ifndef __IRangeValueProvider_INTERFACE_DEFINED__ +#define __IRangeValueProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IRangeValueProvider, 0x36dc7aef, 0x33e6, 0x4691, 0xaf,0xe1, 0x2b,0xe7,0x27,0x4b,0x3d,0x33); +MIDL_INTERFACE("36dc7aef-33e6-4691-afe1-2be7274b3d33") +IRangeValueProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE SetValue(double val) = 0; + virtual HRESULT STDMETHODCALLTYPE get_Value(__RPC__out double *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_IsReadOnly(__RPC__out BOOL *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_Maximum(__RPC__out double *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_Minimum(__RPC__out double *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_LargeChange(__RPC__out double *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_SmallChange(__RPC__out double *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IRangeValueProvider, 0x36dc7aef, 0x33e6, 0x4691, 0xaf,0xe1, 0x2b,0xe7,0x27,0x4b,0x3d,0x33) +#endif +#endif + + +#ifndef __ITextRangeProvider_INTERFACE_DEFINED__ +#define __ITextRangeProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ITextRangeProvider, 0x5347ad7b, 0xc355, 0x46f8, 0xaf,0xf5, 0x90,0x90,0x33,0x58,0x2f,0x63); +MIDL_INTERFACE("5347ad7b-c355-46f8-aff5-909033582f63") +ITextRangeProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE Clone(__RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE Compare(__RPC__in_opt ITextRangeProvider *range, __RPC__out BOOL *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE CompareEndpoints(enum TextPatternRangeEndpoint endpoint, __RPC__in_opt ITextRangeProvider *targetRange, enum TextPatternRangeEndpoint targetEndpoint, __RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE ExpandToEnclosingUnit(enum TextUnit unit) = 0; + virtual HRESULT STDMETHODCALLTYPE FindAttribute(TEXTATTRIBUTEID attributeId, VARIANT val, BOOL backward, __RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE FindText(__RPC__in BSTR text, BOOL backward, BOOL ignoreCase, __RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetAttributeValue(TEXTATTRIBUTEID attributeId, __RPC__out VARIANT *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetBoundingRectangles(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetEnclosingElement(__RPC__deref_out_opt IRawElementProviderSimple **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetText(int maxLength, __RPC__deref_out_opt BSTR *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE Move(enum TextUnit unit, int count, __RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE MoveEndpointByUnit(enum TextPatternRangeEndpoint endpoint, enum TextUnit unit, int count, __RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE MoveEndpointByRange(enum TextPatternRangeEndpoint endpoint, __RPC__in_opt ITextRangeProvider *targetRange, enum TextPatternRangeEndpoint targetEndpoint) = 0; + virtual HRESULT STDMETHODCALLTYPE Select() = 0; + virtual HRESULT STDMETHODCALLTYPE AddToSelection() = 0; + virtual HRESULT STDMETHODCALLTYPE RemoveFromSelection() = 0; + virtual HRESULT STDMETHODCALLTYPE ScrollIntoView(BOOL alignToTop) = 0; + virtual HRESULT STDMETHODCALLTYPE GetChildren(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ITextRangeProvider, 0x5347ad7b, 0xc355, 0x46f8, 0xaf,0xf5, 0x90,0x90,0x33,0x58,0x2f,0x63) +#endif +#endif + + +#ifndef __ITextProvider_INTERFACE_DEFINED__ +#define __ITextProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ITextProvider, 0x3589c92c, 0x63f3, 0x4367, 0x99,0xbb, 0xad,0xa6,0x53,0xb7,0x7c,0xf2); +MIDL_INTERFACE("3589c92c-63f3-4367-99bb-ada653b77cf2") +ITextProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetSelection(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetVisibleRanges(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE RangeFromChild(__RPC__in_opt IRawElementProviderSimple *childElement, __RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE RangeFromPoint(struct UiaPoint point, __RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_DocumentRange(__RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_SupportedTextSelection(__RPC__out enum SupportedTextSelection *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ITextProvider, 0x3589c92c, 0x63f3, 0x4367, 0x99,0xbb, 0xad,0xa6,0x53,0xb7,0x7c,0xf2) +#endif +#endif + + +#ifndef __ITextProvider2_INTERFACE_DEFINED__ +#define __ITextProvider2_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ITextProvider2, 0x0dc5e6ed, 0x3e16, 0x4bf1, 0x8f,0x9a, 0xa9,0x79,0x87,0x8b,0xc1,0x95); +MIDL_INTERFACE("0dc5e6ed-3e16-4bf1-8f9a-a979878bc195") +ITextProvider2 : public ITextProvider +{ +public: + virtual HRESULT STDMETHODCALLTYPE RangeFromAnnotation(__RPC__in_opt IRawElementProviderSimple *annotationElement, __RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetCaretRange(__RPC__out BOOL *isActive, __RPC__deref_out_opt ITextRangeProvider **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ITextProvider2, 0x0dc5e6ed, 0x3e16, 0x4bf1, 0x8f,0x9a, 0xa9,0x79,0x87,0x8b,0xc1,0x95) +#endif +#endif + + +#ifndef __IToggleProvider_INTERFACE_DEFINED__ +#define __IToggleProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IToggleProvider, 0x56d00bd0, 0xc4f4, 0x433c, 0xa8,0x36, 0x1a,0x52,0xa5,0x7e,0x08,0x92); +MIDL_INTERFACE("56d00bd0-c4f4-433c-a836-1a52a57e0892") +IToggleProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE Toggle() = 0; + virtual HRESULT STDMETHODCALLTYPE get_ToggleState(__RPC__out enum ToggleState *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IToggleProvider, 0x56d00bd0, 0xc4f4, 0x433c, 0xa8,0x36, 0x1a,0x52,0xa5,0x7e,0x08,0x92) +#endif +#endif + + +#ifndef __IInvokeProvider_INTERFACE_DEFINED__ +#define __IInvokeProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IInvokeProvider, 0x54fcb24b, 0xe18e, 0x47a2, 0xb4,0xd3, 0xec,0xcb,0xe7,0x75,0x99,0xa2); +MIDL_INTERFACE("54fcb24b-e18e-47a2-b4d3-eccbe77599a2") +IInvokeProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE Invoke() = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IInvokeProvider, 0x54fcb24b, 0xe18e, 0x47a2, 0xb4,0xd3, 0xec,0xcb,0xe7,0x75,0x99,0xa2) +#endif +#endif + + +#ifndef __ISelectionProvider_INTERFACE_DEFINED__ +#define __ISelectionProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ISelectionProvider, 0xfb8b03af, 0x3bdf, 0x48d4, 0xbd,0x36, 0x1a,0x65,0x79,0x3b,0xe1,0x68); +MIDL_INTERFACE("fb8b03af-3bdf-48d4-bd36-1a65793be168") +ISelectionProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetSelection(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_CanSelectMultiple(__RPC__out BOOL *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_IsSelectionRequired(__RPC__out BOOL *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ISelectionProvider, 0xfb8b03af, 0x3bdf, 0x48d4, 0xbd,0x36, 0x1a,0x65,0x79,0x3b,0xe1,0x68) +#endif +#endif + + +#ifndef __ISelectionItemProvider_INTERFACE_DEFINED__ +#define __ISelectionItemProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ISelectionItemProvider, 0x2acad808, 0xb2d4, 0x452d, 0xa4,0x07, 0x91,0xff,0x1a,0xd1,0x67,0xb2); +MIDL_INTERFACE("2acad808-b2d4-452d-a407-91ff1ad167b2") +ISelectionItemProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE Select() = 0; + virtual HRESULT STDMETHODCALLTYPE AddToSelection() = 0; + virtual HRESULT STDMETHODCALLTYPE RemoveFromSelection() = 0; + virtual HRESULT STDMETHODCALLTYPE get_IsSelected(__RPC__out BOOL *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_SelectionContainer(__RPC__deref_out_opt IRawElementProviderSimple **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ISelectionItemProvider, 0x2acad808, 0xb2d4, 0x452d, 0xa4,0x07, 0x91,0xff,0x1a,0xd1,0x67,0xb2) +#endif +#endif + + +#ifndef __ITableProvider_INTERFACE_DEFINED__ +#define __ITableProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ITableProvider, 0x9c860395, 0x97b3, 0x490a, 0xb5,0x2a, 0x85,0x8c,0xc2,0x2a,0xf1,0x66); +MIDL_INTERFACE("9c860395-97b3-490a-b52a-858cc22af166") +ITableProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetRowHeaders(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetColumnHeaders(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_RowOrColumnMajor(__RPC__out enum RowOrColumnMajor *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ITableProvider, 0x9c860395, 0x97b3, 0x490a, 0xb5,0x2a, 0x85,0x8c,0xc2,0x2a,0xf1,0x66) +#endif +#endif + + +#ifndef __ITableItemProvider_INTERFACE_DEFINED__ +#define __ITableItemProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_ITableItemProvider, 0xb9734fa6, 0x771f, 0x4d78, 0x9c,0x90, 0x25,0x17,0x99,0x93,0x49,0xcd); +MIDL_INTERFACE("b9734fa6-771f-4d78-9c90-2517999349cd") +ITableItemProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetRowHeaderItems(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE GetColumnHeaderItems(__RPC__deref_out_opt SAFEARRAY **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(ITableItemProvider, 0xb9734fa6, 0x771f, 0x4d78, 0x9c,0x90, 0x25,0x17,0x99,0x93,0x49,0xcd) +#endif +#endif + + +#ifndef __IGridProvider_INTERFACE_DEFINED__ +#define __IGridProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IGridProvider, 0xb17d6187, 0x0907, 0x464b, 0xa1,0x68, 0x0e,0xf1,0x7a,0x15,0x72,0xb1); +MIDL_INTERFACE("b17d6187-0907-464b-a168-0ef17a1572b1") +IGridProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetItem(int row, int column, __RPC__deref_out_opt IRawElementProviderSimple **pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_RowCount(__RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ColumnCount(__RPC__out int *pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IGridProvider, 0xb17d6187, 0x0907, 0x464b, 0xa1,0x68, 0x0e,0xf1,0x7a,0x15,0x72,0xb1) +#endif +#endif + + +#ifndef __IGridItemProvider_INTERFACE_DEFINED__ +#define __IGridItemProvider_INTERFACE_DEFINED__ +DEFINE_GUID(IID_IGridItemProvider, 0xd02541f1, 0xfb81, 0x4d64, 0xae,0x32, 0xf5,0x20,0xf8,0xa6,0xdb,0xd1); +MIDL_INTERFACE("d02541f1-fb81-4d64-ae32-f520f8a6dbd1") +IGridItemProvider : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE get_Row(__RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_Column(__RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_RowSpan(__RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ColumnSpan(__RPC__out int *pRetVal) = 0; + virtual HRESULT STDMETHODCALLTYPE get_ContainingGrid(__RPC__deref_out_opt IRawElementProviderSimple **pRetVal) = 0; +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IGridItemProvider, 0xd02541f1, 0xfb81, 0x4d64, 0xae,0x32, 0xf5,0x20,0xf8,0xa6,0xdb,0xd1) +#endif +#endif + +#endif diff --git a/src/platformsupport/windowsuiautomation/uiatypes_p.h b/src/platformsupport/windowsuiautomation/uiatypes_p.h new file mode 100644 index 0000000000..25d8b8cb2b --- /dev/null +++ b/src/platformsupport/windowsuiautomation/uiatypes_p.h @@ -0,0 +1,145 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UIATYPES_H +#define UIATYPES_H + +typedef int PROPERTYID; +typedef int PATTERNID; +typedef int EVENTID; +typedef int TEXTATTRIBUTEID; +typedef int CONTROLTYPEID; +typedef int LANDMARKTYPEID; +typedef int METADATAID; + +typedef void *UIA_HWND; + +enum NavigateDirection { + NavigateDirection_Parent = 0, + NavigateDirection_NextSibling = 1, + NavigateDirection_PreviousSibling = 2, + NavigateDirection_FirstChild = 3, + NavigateDirection_LastChild = 4 +}; + +enum ProviderOptions { + ProviderOptions_ClientSideProvider = 0x1, + ProviderOptions_ServerSideProvider = 0x2, + ProviderOptions_NonClientAreaProvider = 0x4, + ProviderOptions_OverrideProvider = 0x8, + ProviderOptions_ProviderOwnsSetFocus = 0x10, + ProviderOptions_UseComThreading = 0x20, + ProviderOptions_RefuseNonClientSupport = 0x40, + ProviderOptions_HasNativeIAccessible = 0x80, + ProviderOptions_UseClientCoordinates = 0x100 +}; + +enum SupportedTextSelection { + SupportedTextSelection_None = 0, + SupportedTextSelection_Single = 1, + SupportedTextSelection_Multiple = 2 +}; + +enum TextUnit { + TextUnit_Character = 0, + TextUnit_Format = 1, + TextUnit_Word = 2, + TextUnit_Line = 3, + TextUnit_Paragraph = 4, + TextUnit_Page = 5, + TextUnit_Document = 6 +}; + +enum TextPatternRangeEndpoint { + TextPatternRangeEndpoint_Start = 0, + TextPatternRangeEndpoint_End = 1 +}; + +enum CaretPosition { + CaretPosition_Unknown = 0, + CaretPosition_EndOfLine = 1, + CaretPosition_BeginningOfLine = 2 +}; + +enum ToggleState { + ToggleState_Off = 0, + ToggleState_On = 1, + ToggleState_Indeterminate = 2 +}; + +enum RowOrColumnMajor { + RowOrColumnMajor_RowMajor = 0, + RowOrColumnMajor_ColumnMajor = 1, + RowOrColumnMajor_Indeterminate = 2 +}; + +enum TreeScope { + TreeScope_None = 0, + TreeScope_Element = 0x1, + TreeScope_Children = 0x2, + TreeScope_Descendants = 0x4, + TreeScope_Parent = 0x8, + TreeScope_Ancestors = 0x10, + TreeScope_Subtree = TreeScope_Element | TreeScope_Children | TreeScope_Descendants +}; + +enum OrientationType { + OrientationType_None = 0, + OrientationType_Horizontal = 1, + OrientationType_Vertical = 2 +}; + +enum PropertyConditionFlags { + PropertyConditionFlags_None = 0, + PropertyConditionFlags_IgnoreCase = 1 +}; + +struct UiaRect { + double left; + double top; + double width; + double height; +}; + +struct UiaPoint { + double x; + double y; +}; + +#endif diff --git a/src/platformsupport/windowsuiautomation/windowsuiautomation.pro b/src/platformsupport/windowsuiautomation/windowsuiautomation.pro new file mode 100644 index 0000000000..97cdb60ef9 --- /dev/null +++ b/src/platformsupport/windowsuiautomation/windowsuiautomation.pro @@ -0,0 +1,23 @@ +TARGET = QtWindowsUIAutomationSupport +MODULE = windowsuiautomation_support + +QT = core-private gui-private +CONFIG += static internal_module + +HEADERS += \ + qwindowsuiawrapper_p.h \ + uiaattributeids_p.h \ + uiacontroltypeids_p.h \ + uiaerrorids_p.h \ + uiaeventids_p.h \ + uiageneralids_p.h \ + uiaserverinterfaces_p.h \ + uiaclientinterfaces_p.h \ + uiapatternids_p.h \ + uiapropertyids_p.h \ + uiatypes_p.h + +SOURCES += \ + qwindowsuiawrapper.cpp + +load(qt_module) |