diff options
Diffstat (limited to 'src/gui/kernel/qplatformsharedgraphicscache_qpa.cpp')
| -rw-r--r-- | src/gui/kernel/qplatformsharedgraphicscache_qpa.cpp | 212 |
1 files changed, 212 insertions, 0 deletions
diff --git a/src/gui/kernel/qplatformsharedgraphicscache_qpa.cpp b/src/gui/kernel/qplatformsharedgraphicscache_qpa.cpp new file mode 100644 index 0000000000..67a59b0e44 --- /dev/null +++ b/src/gui/kernel/qplatformsharedgraphicscache_qpa.cpp @@ -0,0 +1,212 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qplatformsharedgraphicscache_qpa.h" + +QT_BEGIN_NAMESPACE + +/*! + \class QPlatformSharedGraphicsCache + \since 5.0 + \internal + \preliminary + \ingroup qpa + \brief The QPlatformSharedGraphicsCache is an abstraction of a cross-process graphics cache. + + If supported, it is possible to retrieve a QPlatformSharedGraphicsCache object from the + platform integration. This is typically used to store graphical items which should be shared + between several processes. + + Items are requested from the cache by calling requestItems(). If the cache contains the + requested items in the requested cache, the itemsAvailable() signal is emitted with the ID of + the graphical buffer and each item's coordinates inside the buffer. Before requesting items + from a cache, the user must call ensureCacheInitialized() to set the correct parameters for + the cache. + + If the cache does not yet contain the requested items, it will emit a similar itemsMissing() + signal. The client can then call updateItems() with rasterizations of the items and they will be + entered into the shared cache. As the items are rendered into the cache, itemsAvailable() signals + will be emitted for each of the items which have previously been requested and which have not + yet been reported as ready. +*/ + +/*! + \enum BufferType + + Defines how the type of buffer required to contain a cache. + + \value OpenGLTexture The buffer will be allocated in graphics memory, and an OpenGL texture + for a buffer belonging to the cache can be requested using + textureIdForBuffer(). +*/ + +/*! + \enum PixelFormat + + Defines the pixel format of a cache. + + \value Alpha8 The cache will use 8 bits to represent the alpha value of each pixel. If an + OpenGL texture is created for a buffer belong to the cache, it will have the + pixel format GL_ALPHA. +*/ + +/*! + \fn void ensureCacheInitialized(const QByteArray &cacheId, BufferType bufferType, PixelFormat pixelFormat) + + Initializes a cache named \a cacheId if it has not yet been initialized. The \a bufferType and + \a pixelFormat gives the format of the buffers that will be used to contain the items in the + cache. If a cache with the same \a cacheId has previously been initialized, the call will be + ignored. The cache will keep its previously set buffer type and pixel format. +*/ + +/*! + \fn void QPlatformSharedGraphicsCache::requestItems(const QByteArray &cacheId, const QVector<quint32> &itemIds) + + Requests all the items in \a itemIds from the cache with the name \a cacheId. + + If any or all of the items are available in the cache, one or more itemsAvailable() signals will be + emitted corresponding to the items. If the cache does not contain all of the items in question, + then an itemsMissing() signal will be emitted corresponding to the missing items. The user + is at this point expected to call insertItems() to insert the missing items into the cache. If + the inserted items have previously been requested by the user, at which point an itemsAvailable() + signal will be emitted corresponding to the items. + + Before requesting items from a cache, the user must call ensureCacheInitialized() with the + correct parameters for the cache. +*/ + +/*! + \fn void QPlatformSharedGraphicsCache::insertItems(const QByteArray &cacheId, const QVector<quint32> &itemIds, const QVector<QImage> &items) + + Inserts the items in \a itemIds into the cache named \a cacheId. The appearance of + each item is stored in \a items. The format of the QImage objects is expected to match the + pixel format of the cache as it was initialized in ensureCacheInitialized(). + + When the items have been successfully entered into the cache, one or more itemsAvailable() signals + will be emitted for the items. + + If the cache already contains the items, the behavior is implementation-specific. The + implementation may choose to ignore the items or it may overwrite the existing instances in + the cache. Either way, itemsAvailable() signals corresponding to the inserted items will be + emitted. +*/ + +/*! + \fn void QPlatformSharedGraphicsCache::releaseItems(const QByteArray &cacheId, const QVector<quint32> &itemIds) + + Releases the reference to the items in \a itemIds from the cache named \a cacheId. This should + only be called when all references to the items have been released by the user, and they are no + longer needed. +*/ + +/*! + \fn void itemsMissing(const QByteArray &cacheId, const QVector<quint32> *itemIds) + + This signal is emitted when requestItems() has been called for one or more items in the + cache named \a cacheId which are not yet available in the cache. The user is then expected to + call insertItems() to update the cache with the respective items, at which point they will + become available to all clients of the shared cache. + + The vector \a itemIds contains the IDs of the items that need to be inserted into the cache. + + \sa itemsAvailable(), insertItems(), requestItems() +*/ + +/*! + \fn void itemsAvailable(const QByteArray &cacheId, void *bufferId, const QSize &bufferSize, const QVector<quint32> &itemIds, const QVector<QPoint> &positionsInBuffer) + + This signal can be emitted at any time when either requestItems() or insertItems() has been + called by the application for one or more items in the cache named \a cacheId, as long as + releaseItems() has not subsequently been called for the same items. It instructs the application + on where to find the items that have been entered into the cache. When the application receives + a buffer, it is expected to reference it using referenceBuffer() on it if it keeps a reference + to the buffer. + + The \a bufferId is an ID for the buffer that contains the items. The \a bufferId can be + converted to a format usable by the application depending on which format it was given at + initialization. If it is a OpenGLTexture, its texture ID can be requested using the + textureIdForBuffer() function. The dimensions of the buffer are given by \a bufferSize. + + The items provided by the cache are identified in the \a itemIds vector. The + \a positionsInBuffer vector contains the locations inside the buffer of each item. Each entry in + \a positionsInBuffer corresponds to an item in \a itemIds. + + The buffer and the items' locations within the buffer can be considered valid until an + itemsInvalidated() signal has been emitted for the items, or until releaseItems() is called + for the items. + + \sa itemsMissing(), requestItems(), bufferType() +*/ + +/*! + \fn void itemsUpdated(const QByteArray &cacheId, void *bufferId, const QSize &bufferSize, const QVector<quint32> &itemIds, const QVector<QPoint> &positionsInBuffer) + + This signal is similar in usage to the itemsAvailable() signal, but will be emitted when + the location of a previously requested or inserted item has been updated. The application + must update its data for the respective items and release any references to old buffers held + by the items. + + If the application no longer holds any references to previously referenced items in a given + cache, it should call releaseItems() for these items, at which point it will no longer receive + any itemsUpdated() signal for these items. + + \sa requestItems(), insertItems(), itemsAvailable() +*/ + +/*! + \fn void itemsInvalidated(const QByteArray &cacheId, const QVector<quint32> &itemIds) + + This signal is emitted when the items given by \a itemIds in the cache named \a cacheId have + been removed from the cache and the previously reported information about them is considered + invalid. It will only be emitted for items for which a buffer has previously been identified + through the itemsAvailable() signal (either as response to a requestItems() call or an + insertItems() call.) + + The application is expected to throw away information about the items in the \a itemIds array + and drop any references it might have to the memory held by the buffer. If the items are still + required by the application, it can re-commit them to the cache using the insertItems() function. + + If the application no longer holds any references to previously referenced items in a given + cache, it should call releaseItems() for these items, at which point it will no longer receive + any itemsInvalidated() signal for these items. +*/ + +QT_END_NAMESPACE |