CopperSpice API  1.7.2
QPlatformSharedGraphicsCache Class Referenceabstract

Abstraction of a cross-process graphics cache. More...

Inheritance diagram for QPlatformSharedGraphicsCache:
QObject

Public Types

enum  BufferType
 
enum  PixelFormat
 

Public Signals

void itemsAvailable (const QByteArray &cacheId, void *bufferId, const QVector< quint32 > &itemIds, const QVector< QPoint > &positionsInBuffer)
 
void itemsInvalidated (const QByteArray &cacheId, const QVector< quint32 > &itemIds)
 
void itemsMissing (const QByteArray &cacheId, const QVector< quint32 > &itemIds)
 
void itemsUpdated (const QByteArray &cacheId, void *bufferId, const QVector< quint32 > &itemIds, const QVector< QPoint > &positionsInBuffer)
 
- Public Signals inherited from QObject
void destroyed (QObject *obj=nullptr)
 
void objectNameChanged (const QString &objectName)
 

Public Methods

virtual void beginRequestBatch () = 0
 
virtual bool dereferenceBuffer (void *bufferId) = 0
 
virtual void * eglImageForBuffer (void *bufferId) = 0
 
virtual void endRequestBatch () = 0
 
virtual void ensureCacheInitialized (const QByteArray &cacheId, BufferType bufferType, PixelFormat pixelFormat) = 0
 
virtual void insertItems (const QByteArray &cacheId, const QVector< quint32 > &itemIds, const QVector< QImage > &items) = 0
 
virtual void referenceBuffer (void *bufferId) = 0
 
virtual void releaseItems (const QByteArray &cacheId, const QVector< quint32 > &itemIds) = 0
 
virtual bool requestBatchStarted () const = 0
 
virtual void requestItems (const QByteArray &cacheId, const QVector< quint32 > &itemIds) = 0
 
virtual QSize sizeOfBuffer (void *bufferId) = 0
 
virtual uint textureIdForBuffer (void *bufferId) = 0
 
- Public Methods inherited from QObject
 QObject (QObject *parent=nullptr)
 
 ~QObject ()
 
bool blockSignals (bool block)
 
const QList< QObject * > & children () const
 
bool connect (const QObject *sender, const QString &signalMethod, const QString &location, const QString &slotMethod, Qt::ConnectionType type=Qt::AutoConnection)
 
bool connect (const QObject *sender, const QString &signalMethod, const QString &slotMethod, Qt::ConnectionType type=Qt::AutoConnection)
 
bool disconnect (const QObject *receiver, const QString &slotMethod=QString ()) const
 
bool disconnect (const QString &signalMethod, const QString &location, const QObject *receiver=nullptr, const QString &slotMethod=QString ()) const
 
bool disconnect (const QString &signalMethod=QString (), const QObject *receiver=nullptr, const QString &slotMethod=QString ()) const
 
void dumpObjectInfo ()
 
void dumpObjectTree ()
 
QList< QStringdynamicPropertyNames () const
 
virtual bool event (QEvent *event)
 
virtual bool eventFilter (QObject *watched, QEvent *event)
 
template<typename T >
findChild (const QString &childName=QString ()) const
 
template<class T >
QList< T > findChildren (const QRegularExpression &regExp, Qt::FindChildOptions options=Qt::FindChildrenRecursively) const
 
template<class T >
QList< T > findChildren (const QString &objName=QString (), Qt::FindChildOptions options=Qt::FindChildrenRecursively) const
 
bool inherits (const QString &className) const
 
void installEventFilter (QObject *filterObj)
 
bool isWidgetType () const
 
bool isWindowType () const
 
void killTimer (int id)
 
const QMetaObjectmetaObject () const
 
void moveToThread (QThread *targetThread)
 
QString objectName () const
 
QObject * parent () const
 
template<class T = QVariant>
property (const QString &name) const
 
void removeEventFilter (QObject *obj)
 
void setObjectName (const QString &name)
 
void setParent (QObject *parent)
 
bool setProperty (const QString &name, const QVariant &value)
 
bool signalsBlocked () const
 
int startTimer (int interval, Qt::TimerType timerType=Qt::CoarseTimer)
 
QThreadthread () const
 

Additional Inherited Members

- Public Slots inherited from QObject
void deleteLater ()
 
- Static Public Methods inherited from QObject
static bool connect (const QObject *sender, const QMetaMethod &signalMethod, const QObject *receiver, const QMetaMethod &slotMethod, Qt::ConnectionType type=Qt::AutoConnection)
 
static bool connect (const QObject *sender, const QString &signalMethod, const QObject *receiver, const QString &slotMethod, Qt::ConnectionType type=Qt::AutoConnection, const QString &location=QString ())
 
static bool connect (const QObject *sender, const QString &signalMethod, const QString &location, const QObject *receiver, const QString &slotMethod, Qt::ConnectionType type=Qt::AutoConnection)
 
template<class Sender , class SignalClass , class... SignalArgs, class Receiver , class SlotClass , class... SlotArgs, class SlotReturn >
static bool connect (const Sender *sender, void (SignalClass::*signalMethod)(SignalArgs...), const Receiver *receiver, SlotReturn (SlotClass::*slotMethod)(SlotArgs...), Qt::ConnectionType type=Qt::AutoConnection)
 
template<class Sender , class SignalClass , class... SignalArgs, class Receiver , class T >
static bool connect (const Sender *sender, void (SignalClass::*signalMethod)(SignalArgs...), const Receiver *receiver, T slotLambda, Qt::ConnectionType type=Qt::AutoConnection)
 
static bool disconnect (const QObject *sender, const QMetaMethod &signalMethod, const QObject *receiver, const QMetaMethod &slotMethod)
 
static bool disconnect (const QObject *sender, const QString &signalMethod, const QObject *receiver, const QString &slotMethod)
 
static bool disconnect (const QObject *sender, const QString &signalMethod, const QString &location, const QObject *receiver, const QString &slotMethod)
 
template<class Sender , class SignalClass , class... SignalArgs, class Receiver , class SlotClass , class... SlotArgs, class SlotReturn >
static bool disconnect (const Sender *sender, void (SignalClass::*signalMethod)(SignalArgs...), const Receiver *receiver, SlotReturn (SlotClass::*slotMethod)(SlotArgs...))
 
template<class Sender , class SignalClass , class... SignalArgs, class Receiver >
static bool disconnect (const Sender *sender, void (SignalClass::*signalMethod)(SignalArgs...), const Receiver *receiver, std::nullptr_t slotMethod=nullptr)
 
template<class Sender , class SignalClass , class... SignalArgs, class Receiver , class T >
static bool disconnect (const Sender *sender, void (SignalClass::*signalMethod)(SignalArgs...), const Receiver *receiver, T slotMethod)
 
static QMetaObjectstaticMetaObject ()
 
static QString tr (const char *text, const char *comment=nullptr, std::optional< int > numArg=std::optional< int >())
 
- Protected Methods inherited from QObject
virtual void childEvent (QChildEvent *event)
 
virtual void connectNotify (const QMetaMethod &signalMethod) const
 
virtual void customEvent (QEvent *event)
 
virtual void disconnectNotify (const QMetaMethod &signalMethod) const
 
bool isSignalConnected (const QMetaMethod &signalMethod) const
 
int receivers (const QString &signal) const
 
QObject * sender () const
 
int senderSignalIndex () const
 
virtual void timerEvent (QTimerEvent *event)
 
- Properties inherited from QObject
 objectName
 

Detailed Description

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.

Using beginRequestBatch() and endRequestBatch(), it's possible to batch glyph requests, which could improve performance in cases where you have a sequence of requests pending, and you do not need the results during this sequence.

Member Enumeration Documentation

Defines how the type of buffer required to contain a cache.

ConstantValueDescription
OpenGLTexture 0 Buffer will be allocated in graphics memory and an OpenGL texture for a buffer belonging to the cache can be requested using textureIdForBuffer()

Defines the pixel format of a cache.

ConstantValueDescription
Alpha8< 0 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.

Method Documentation

void QPlatformSharedGraphicsCache::beginRequestBatch ( )
pure virtual

This is a hint to the cache that a burst of requests is pending. In some implementations, this will improve performance, as the cache can focus on handling the requests and wait with the results until it is done. It should typically be called prior to a sequence of calls to requestItems() and releaseItems().

Any call to beginRequestBatch() must be followed at some point by a call to endRequestBatch(). Failing to do this may lead to the results of requests never being emitted.

Note
beginRequestBatch() and endRequestBatch() have no stacking logic. Calling beginRequestBatch() twice in a row has no effect, and the single existing batch will be ended by the earliest call to endRequestBatch().
See also
endRequestBatch(), requestBatchStarted()
bool QPlatformSharedGraphicsCache::dereferenceBuffer ( void *  bufferId)
pure virtual

Removed a previously registered reference to the buffer bufferId. Returns true if there are still more references to the buffer in question, or false if this was the last reference (in which case the buffer may have been deleted in the cache.)

See also
dereferenceBuffer()
void * QPlatformSharedGraphicsCache::eglImageForBuffer ( void *  bufferId)
pure virtual

Returns an EGLImageKHR image corresponding to the buffer bufferId.

See also
textureIdForBuffer(), sizeOfBuffer()
void QPlatformSharedGraphicsCache::endRequestBatch ( )
pure virtual

Signals to the cache that the request sequence which has previously been commenced using beginRequestBatch() has now finished.

See also
beginRequestBatch(), requestBatchStarted()
void QPlatformSharedGraphicsCache::ensureCacheInitialized ( const QByteArray cacheId,
BufferType  bufferType,
PixelFormat  pixelFormat 
)
pure virtual

Initializes a cache named cacheId if it has not yet been initialized. The bufferType and pixelFormat gives the format of the buffers that will be used to contain the items in the cache. If a cache with the same cacheId has previously been initialized, the call will be ignored. The cache will keep its previously set buffer type and pixel format.

void QPlatformSharedGraphicsCache::insertItems ( const QByteArray cacheId,
const QVector< quint32 > &  itemIds,
const QVector< QImage > &  items 
)
pure virtual

Inserts the items in itemIds into the cache named cacheId. The appearance of each item is stored in 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.

void QPlatformSharedGraphicsCache::itemsAvailable ( const QByteArray cacheId,
void *  bufferId,
const QVector< quint32 > &  itemIds,
const QVector< QPoint > &  positionsInBuffer 
)
signal

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 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 bufferId is an ID for the buffer that contains the items. The 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 bufferSize.

The items provided by the cache are identified in the itemIds vector. The positionsInBuffer vector contains the locations inside the buffer of each item. Each entry in positionsInBuffer corresponds to an item in 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.

See also
itemsMissing(), requestItems(), bufferType()
void QPlatformSharedGraphicsCache::itemsInvalidated ( const QByteArray cacheId,
const QVector< quint32 > &  itemIds 
)
signal

This signal is emitted when the items given by itemIds in the cache named 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 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.

void QPlatformSharedGraphicsCache::itemsMissing ( const QByteArray cacheId,
const QVector< quint32 > &  itemIds 
)
signal

This signal is emitted when requestItems() has been called for one or more items in the cache named 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 itemIds contains the IDs of the items that need to be inserted into the cache.

See also
itemsAvailable(), insertItems(), requestItems()
void QPlatformSharedGraphicsCache::itemsUpdated ( const QByteArray cacheId,
void *  bufferId,
const QVector< quint32 > &  itemIds,
const QVector< QPoint > &  positionsInBuffer 
)
signal

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.

See also
requestItems(), insertItems(), itemsAvailable()
void QPlatformSharedGraphicsCache::referenceBuffer ( void *  bufferId)
pure virtual

Registers a reference to the buffer bufferId.

See also
dereferenceBuffer()
void QPlatformSharedGraphicsCache::releaseItems ( const QByteArray cacheId,
const QVector< quint32 > &  itemIds 
)
pure virtual

Releases the reference to the items in itemIds from the cache named cacheId. This should only be called when all references to the items have been released by the user, and they are no longer needed.

bool QPlatformSharedGraphicsCache::requestBatchStarted ( ) const
pure virtual

Returns true if a request batch has previously been started using beginRequestBatch() and not yet stopped using endRequestBatch().

See also
beginRequestBatch(), endRequestBatch()
void QPlatformSharedGraphicsCache::requestItems ( const QByteArray cacheId,
const QVector< quint32 > &  itemIds 
)
pure virtual

Requests all the items in itemIds from the cache with the name 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.

QSize QPlatformSharedGraphicsCache::sizeOfBuffer ( void *  bufferId)
pure virtual

Returns the size of the buffer bufferId.

See also
textureIdForBuffer(), eglImageForBuffer()
uint QPlatformSharedGraphicsCache::textureIdForBuffer ( void *  bufferId)
pure virtual

Returns an OpenGL texture ID corresponding to the buffer bufferId, which has previously been passed through signals itemsAvailable() or itemsUpdated(). The relevant OpenGL context should be current when calling this function.

See also
eglImageForBuffer(), sizeOfBuffer()