void QQnxWindow::gainedFocus()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Got focus
QWindowSystemInterface::handleWindowActivated(window());
}
void QQnxWindow::setGeometryHelper(const QRect &rect)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window()
<< ", (" << rect.x() << "," << rect.y()
<< "," << rect.width() << "," << rect.height() << ")";
// Call base class method
QPlatformWindow::setGeometry(rect);
// Set window geometry equal to widget geometry
int val[2];
val[0] = rect.x();
val[1] = rect.y();
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_POSITION, val),
"Failed to set window position");
val[0] = rect.width();
val[1] = rect.height();
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SIZE, val),
"Failed to set window size");
// Set viewport size equal to window size
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SOURCE_SIZE, val),
"Failed to set window source size");
screen_flush_context(m_screenContext, 0);
QWindowSystemInterface::handleGeometryChange(window(), rect);
}
QRect QQnxWindow::setGeometryHelper(const QRect &rect)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window()
<< ", (" << rect.x() << "," << rect.y()
<< "," << rect.width() << "," << rect.height() << ")";
// Call base class method
QRect oldGeometry = QPlatformWindow::geometry();
QPlatformWindow::setGeometry(rect);
// Set window geometry equal to widget geometry
errno = 0;
int val[2];
val[0] = rect.x();
val[1] = rect.y();
int result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_POSITION, val);
if (result != 0)
qFatal("QQnxWindow: failed to set window position, errno=%d", errno);
errno = 0;
val[0] = rect.width();
val[1] = rect.height();
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SIZE, val);
if (result != 0)
qFatal("QQnxWindow: failed to set window size, errno=%d", errno);
// Set viewport size equal to window size
errno = 0;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SOURCE_SIZE, val);
if (result != 0)
qFatal("QQnxWindow: failed to set window source size, errno=%d", errno);
return oldGeometry;
}
QQnxBuffer &QQnxWindow::renderBuffer()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Check if render buffer is invalid
if (m_currentBufferIndex == -1) {
// Get all buffers available for rendering
errno = 0;
screen_buffer_t buffers[MAX_BUFFER_COUNT];
const int result = screen_get_window_property_pv(m_window, SCREEN_PROPERTY_RENDER_BUFFERS, (void **)buffers);
if (result != 0)
qFatal("QQnxWindow: failed to query window buffers, errno=%d", errno);
// Wrap each buffer
for (int i = 0; i < MAX_BUFFER_COUNT; ++i) {
m_buffers[i] = QQnxBuffer(buffers[i]);
}
// Use the first available render buffer
m_currentBufferIndex = 0;
m_previousBufferIndex = -1;
}
return m_buffers[m_currentBufferIndex];
}
void QQnxWindow::setParent(const QPlatformWindow *window)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << this->window() << "platformWindow =" << window;
// Cast away the const, we need to modify the hierarchy.
QQnxWindow* const newParent = static_cast<QQnxWindow*>(const_cast<QPlatformWindow*>(window));
if (newParent == m_parentWindow)
return;
removeFromParent();
m_parentWindow = newParent;
// Add to new hierarchy position.
if (m_parentWindow) {
if (m_parentWindow->m_screen != m_screen)
setScreen(m_parentWindow->m_screen);
m_parentWindow->m_childWindows.push_back(this);
// we don't need any buffers, since
// Qt will draw to the parent TLW
// backing store.
setBufferSize(QSize(1, 1));
} else {
m_screen->addWindow(this);
// recreate buffers, in case the
// window has been reparented and
// becomes a TLW
adjustBufferSize();
}
m_screen->updateHierarchy();
}
void QQnxWindow::setVisible(bool visible)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "visible =" << visible;
if (m_visible == visible || window()->type() == Qt::Desktop)
return;
// The first time through we join a window group if appropriate.
if (m_parentGroupName.isNull() && !m_isTopLevel) {
joinWindowGroup(parent() ? static_cast<QQnxWindow*>(parent())->groupName()
: QByteArray(m_screen->windowGroupName()));
}
m_visible = visible;
QQnxWindow *root = this;
while (root->m_parentWindow)
root = root->m_parentWindow;
root->updateVisibility(root->m_visible);
QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(0, 0), window()->geometry().size()));
if (visible) {
applyWindowState();
} else {
// Flush the context, otherwise it won't disappear immediately
screen_flush_context(m_screenContext, 0);
}
}
void QQnxWindow::setBufferSize(const QSize &size)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "size =" << size;
// Set window buffer size
errno = 0;
// libscreen fails when creating empty buffers
const QSize nonEmptySize = size.isEmpty() ? QSize(1, 1) : size;
int val[2] = { nonEmptySize.width(), nonEmptySize.height() };
int result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_BUFFER_SIZE, val);
if (result != 0)
qFatal("QQnxWindow: failed to set window buffer size, errno=%d", errno);
// Create window buffers if they do not exist
if (m_bufferSize.isEmpty()) {
val[0] = m_screen->nativeFormat();
#if !defined(QT_NO_OPENGL)
// Get pixel format from EGL config if using OpenGL;
// otherwise inherit pixel format of window's screen
if (m_platformOpenGLContext != 0)
val[0] = platformWindowFormatToNativeFormat(m_platformOpenGLContext->format());
#endif
errno = 0;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_FORMAT, val);
if (result != 0)
qFatal("QQnxWindow: failed to set window pixel format, errno=%d", errno);
errno = 0;
result = screen_create_window_buffers(m_window, MAX_BUFFER_COUNT);
if (result != 0)
qWarning() << "QQnxWindow: Buffer size was" << size;
qFatal("QQnxWindow: failed to create window buffers, errno=%d", errno);
// check if there are any buffers available
int bufferCount = 0;
result = screen_get_window_property_iv(m_window, SCREEN_PROPERTY_RENDER_BUFFER_COUNT, &bufferCount);
if (result != 0)
qFatal("QQnxWindow: failed to query window buffer count, errno=%d", errno);
if (bufferCount != MAX_BUFFER_COUNT) {
qFatal("QQnxWindow: invalid buffer count. Expected = %d, got = %d. You might experience problems.",
MAX_BUFFER_COUNT, bufferCount);
}
}
// Cache new buffer size
m_bufferSize = nonEmptySize;
// Buffers were destroyed; reacquire them
m_currentBufferIndex = -1;
m_previousDirty = QRegion();
m_scrolled = QRegion();
const QMutexLocker locker(&m_mutex);
m_requestedBufferSize = QSize();
}
void QQnxWindow::post(const QRegion &dirty)
{
// How double-buffering works
// --------------------------
//
// The are two buffers, the previous one and the current one.
// The previous buffer always contains the complete, full image of the whole window when it
// was last posted.
// The current buffer starts with the complete, full image of the second to last posting
// of the window.
//
// During painting, Qt paints on the current buffer. Thus, when Qt has finished painting, the
// current buffer contains the second to last image plus the newly painted regions.
// Since the second to last image is too old, we copy over the image from the previous buffer, but
// only for those regions that Qt didn't paint (because that would overwrite what Qt has just
// painted). This is the copyPreviousToCurrent() call below.
//
// After the call to copyPreviousToCurrent(), the current buffer contains the complete, full image of the
// whole window in its current state, and we call screen_post_window() to make the new buffer
// available to libscreen (called "posting"). There, only the regions that Qt painted on are
// posted, as nothing else has changed.
//
// After that, the previous and the current buffers are swapped, and the whole cycle starts anew.
// Check if render buffer exists and something was rendered
if (m_currentBufferIndex != -1 && !dirty.isEmpty()) {
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
QQnxBuffer ¤tBuffer = m_buffers[m_currentBufferIndex];
// Copy unmodified region from old render buffer to new render buffer;
// required to allow partial updates
QRegion preserve = m_previousDirty - dirty - m_scrolled;
blitPreviousToCurrent(preserve, 0, 0);
// Calculate region that changed
QRegion modified = preserve + dirty + m_scrolled;
QRect rect = modified.boundingRect();
int dirtyRect[4] = { rect.x(), rect.y(), rect.x() + rect.width(), rect.y() + rect.height() };
// Update the display with contents of render buffer
errno = 0;
int result = screen_post_window(m_window, currentBuffer.nativeBuffer(), 1, dirtyRect, 0);
if (result != 0)
qFatal("QQnxWindow: failed to post window buffer, errno=%d", errno);
// Advance to next nender buffer
m_previousBufferIndex = m_currentBufferIndex++;
if (m_currentBufferIndex >= MAX_BUFFER_COUNT)
m_currentBufferIndex = 0;
// Save modified region and clear scrolled region
m_previousDirty = dirty;
m_scrolled = QRegion();
// Notify screen that window posted
if (m_screen != 0)
m_screen->onWindowPost(this);
}
}
void QQnxWindow::setScreen(QQnxScreen *platformScreen)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "platformScreen =" << platformScreen;
if (platformScreen == 0) { // The screen has been destroyed
m_screen = 0;
Q_FOREACH (QQnxWindow *childWindow, m_childWindows) {
childWindow->setScreen(0);
}
void QQnxWindow::requestActivateWindow()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// TODO: Tell screen to set keyboard focus to this window.
// Notify that we gained focus.
gainedFocus();
}
void QQnxWindow::setExposed(bool exposed)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "expose =" << exposed;
if (m_exposed != exposed) {
m_exposed = exposed;
QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(0, 0), window()->geometry().size()));
}
}
void QQnxWindow::setOpacity(qreal level)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "opacity =" << level;
// Set window global alpha
int val = (int)(level * 255);
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_GLOBAL_ALPHA, &val),
"Failed to set global alpha");
screen_flush_context(m_screenContext, 0);
}
void QQnxWindow::updateVisibility(bool parentVisible)
{
qWindowDebug() << Q_FUNC_INFO << "parentVisible =" << parentVisible << "window =" << window();
// Set window visibility
int val = (m_visible && parentVisible) ? 1 : 0;
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &val),
"Failed to set window visibility");
Q_FOREACH (QQnxWindow *childWindow, m_childWindows)
childWindow->updateVisibility(m_visible && parentVisible);
}
void QQnxWindow::updateVisibility(bool parentVisible)
{
qWindowDebug() << Q_FUNC_INFO << "parentVisible =" << parentVisible << "window =" << window();
// Set window visibility
errno = 0;
int val = (m_visible && parentVisible) ? 1 : 0;
int result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_VISIBLE, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window visibility, errno=%d", errno);
Q_FOREACH (QQnxWindow *childWindow, m_childWindows)
childWindow->updateVisibility(m_visible && parentVisible);
}
void QQnxWindow::setOpacity(qreal level)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "opacity =" << level;
// Set window global alpha
errno = 0;
int val = (int)(level * 255);
int result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_GLOBAL_ALPHA, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window global alpha, errno=%d", errno);
// TODO: How to handle children of this window? If we change all the visibilities, then
// the transparency will look wrong...
}
void QQnxWindow::lower()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
if (m_parentWindow) {
m_parentWindow->m_childWindows.removeAll(this);
m_parentWindow->m_childWindows.push_front(this);
} else {
m_screen->lowerWindow(this);
}
m_screen->updateHierarchy();
}
void QQnxWindow::removeFromParent()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Remove from old Hierarchy position
if (m_parentWindow) {
if (m_parentWindow->m_childWindows.removeAll(this))
m_parentWindow = 0;
else
qFatal("QQnxWindow: Window Hierarchy broken; window has parent, but parent hasn't got child.");
} else if (m_screen) {
m_screen->removeWindow(this);
}
}
QQnxWindow::~QQnxWindow()
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Qt should have already deleted the children before deleting the parent.
Q_ASSERT(m_childWindows.size() == 0);
// Remove from plugin's window mapper
QQnxIntegration::removeWindow(m_window);
// Remove from parent's Hierarchy.
removeFromParent();
if (m_screen)
m_screen->updateHierarchy();
// Cleanup QNX window and its buffers
screen_destroy_window(m_window);
}
void QQnxWindow::setScreen(QQnxScreen *platformScreen)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "platformScreen =" << platformScreen;
if (platformScreen == 0) { // The screen has been destroyed
m_screen = 0;
return;
}
if (m_screen == platformScreen)
return;
if (m_screen)
m_screen->removeWindow(this);
platformScreen->addWindow(this);
m_screen = platformScreen;
// Move window to proper screen/display
errno = 0;
screen_display_t display = platformScreen->nativeDisplay();
int result = screen_set_window_property_pv(m_window, SCREEN_PROPERTY_DISPLAY, (void **)&display);
if (result != 0)
qFatal("QQnxWindow: failed to set window display, errno=%d", errno);
// Add window to display's window group
errno = 0;
result = screen_join_window_group(m_window, platformScreen->windowGroupName());
if (result != 0)
qFatal("QQnxWindow: failed to join window group, errno=%d", errno);
Q_FOREACH (QQnxWindow *childWindow, m_childWindows) {
// Only subwindows and tooltips need necessarily be moved to another display with the window.
if ((window()->type() & Qt::WindowType_Mask) == Qt::SubWindow ||
(window()->type() & Qt::WindowType_Mask) == Qt::ToolTip)
childWindow->setScreen(platformScreen);
}
m_screen->updateHierarchy();
}
void QQnxWindow::setOffset(const QPoint &offset)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
// Move self and then children.
QRect newGeometry = geometry();
newGeometry.translate(offset);
// Call the base class
QPlatformWindow::setGeometry(newGeometry);
int val[2];
errno = 0;
val[0] = newGeometry.x();
val[1] = newGeometry.y();
int result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_POSITION, val);
if (result != 0)
qFatal("QQnxWindow: failed to set window position, errno=%d", errno);
Q_FOREACH (QQnxWindow *childWindow, m_childWindows)
childWindow->setOffset(offset);
}
void QQnxWindow::setWindowState(Qt::WindowState state)
{
qWindowDebug() << Q_FUNC_INFO << "state =" << state;
// Prevent two calls with Qt::WindowFullScreen from changing m_unmaximizedGeometry
if (m_windowState == state)
return;
switch (state) {
// WindowActive is not an accepted parameter according to the docs
case Qt::WindowActive:
return;
case Qt::WindowMinimized:
minimize();
if (m_unmaximizedGeometry.isValid())
setGeometry(m_unmaximizedGeometry);
else
setGeometry(m_screen->geometry());
break;
case Qt::WindowMaximized:
case Qt::WindowFullScreen:
m_unmaximizedGeometry = geometry();
setGeometry(state == Qt::WindowMaximized ? m_screen->availableGeometry() : m_screen->geometry());
break;
case Qt::WindowNoState:
if (m_unmaximizedGeometry.isValid())
setGeometry(m_unmaximizedGeometry);
break;
}
m_windowState = state;
}
void QQnxWindow::setVisible(bool visible)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "visible =" << visible;
m_visible = visible;
QQnxWindow *root = this;
while (root->m_parentWindow)
root = root->m_parentWindow;
root->updateVisibility(root->m_visible);
window()->requestActivate();
if (window()->isTopLevel()) {
QWindowSystemInterface::handleExposeEvent(window(), window()->geometry());
if (!visible) {
// Flush the context, otherwise it won't disappear immediately
screen_flush_context(m_screenContext, 0);
}
}
}
QT_BEGIN_NAMESPACE
QQnxWindow::QQnxWindow(QWindow *window, screen_context_t context)
: QPlatformWindow(window),
m_screenContext(context),
m_window(0),
m_currentBufferIndex(-1),
m_previousBufferIndex(-1),
#if !defined(QT_NO_OPENGL)
m_platformOpenGLContext(0),
#endif
m_screen(0),
m_parentWindow(0),
m_visible(true),
m_windowState(Qt::WindowNoState),
m_requestedBufferSize(window->geometry().size())
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window << ", size =" << window->size();
int result;
// Create child QNX window
errno = 0;
result = screen_create_window_type(&m_window, m_screenContext, SCREEN_CHILD_WINDOW);
if (result != 0)
qFatal("QQnxWindow: failed to create window, errno=%d", errno);
// Set window buffer usage based on rendering API
int val;
QSurface::SurfaceType surfaceType = window->surfaceType();
switch (surfaceType) {
case QSurface::RasterSurface:
val = SCREEN_USAGE_NATIVE | SCREEN_USAGE_READ | SCREEN_USAGE_WRITE;
break;
case QSurface::OpenGLSurface:
val = SCREEN_USAGE_OPENGL_ES2;
break;
default:
qFatal("QQnxWindow: unsupported window API");
break;
}
errno = 0;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_USAGE, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window buffer usage, errno=%d", errno);
// Alpha channel is always pre-multiplied if present
errno = 0;
val = SCREEN_PRE_MULTIPLIED_ALPHA;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_ALPHA_MODE, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window alpha mode, errno=%d", errno);
// Make the window opaque
errno = 0;
val = SCREEN_TRANSPARENCY_NONE;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_TRANSPARENCY, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window transparency, errno=%d", errno);
// Set the window swap interval
errno = 0;
val = 1;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SWAP_INTERVAL, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window swap interval, errno=%d", errno);
if (window->flags() && Qt::WindowDoesNotAcceptFocus) {
errno = 0;
val = SCREEN_SENSITIVITY_NO_FOCUS;
result = screen_set_window_property_iv(m_window, SCREEN_PROPERTY_SENSITIVITY, &val);
if (result != 0)
qFatal("QQnxWindow: failed to set window sensitivity, errno=%d", errno);
}
setScreen(static_cast<QQnxScreen *>(window->screen()->handle()));
// Add window to plugin's window mapper
QQnxIntegration::addWindow(m_window, window);
// Qt never calls these setters after creating the window, so we need to do that ourselves here
setWindowState(window->windowState());
if (window->parent() && window->parent()->handle())
setParent(window->parent()->handle());
setGeometryHelper(window->geometry());
setVisible(window->isVisible());
}
void QQnxWindow::setBufferSize(const QSize &size)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window() << "size =" << size;
// libscreen fails when creating empty buffers
const QSize nonEmptySize = size.isEmpty() ? QSize(1, 1) : size;
int format = pixelFormat();
if (nonEmptySize == m_bufferSize || format == -1)
return;
Q_SCREEN_CRITICALERROR(
screen_set_window_property_iv(m_window, SCREEN_PROPERTY_FORMAT, &format),
"Failed to set window format");
if (m_bufferSize.isValid()) {
// destroy buffers first, if resized
Q_SCREEN_CRITICALERROR(screen_destroy_window_buffers(m_window),
"Failed to destroy window buffers");
}
int val[2] = { nonEmptySize.width(), nonEmptySize.height() };
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_BUFFER_SIZE, val),
"Failed to set window buffer size");
Q_SCREEN_CRITICALERROR(screen_create_window_buffers(m_window, MAX_BUFFER_COUNT),
"Failed to create window buffers");
// check if there are any buffers available
int bufferCount = 0;
Q_SCREEN_CRITICALERROR(
screen_get_window_property_iv(m_window, SCREEN_PROPERTY_RENDER_BUFFER_COUNT, &bufferCount),
"Failed to query render buffer count");
if (bufferCount != MAX_BUFFER_COUNT) {
qFatal("QQnxWindow: invalid buffer count. Expected = %d, got = %d.",
MAX_BUFFER_COUNT, bufferCount);
}
// Set the transparency. According to QNX technical support, setting the window
// transparency property should always be done *after* creating the window
// buffers in order to guarantee the property is paid attention to.
if (window()->requestedFormat().alphaBufferSize() == 0) {
// To avoid overhead in the composition manager, disable blending
// when the underlying window buffer doesn't have an alpha channel.
val[0] = SCREEN_TRANSPARENCY_NONE;
} else {
// Normal alpha blending. This doesn't commit us to translucency; the
// normal backfill during the painting will contain a fully opaque
// alpha channel unless the user explicitly intervenes to make something
// transparent.
val[0] = SCREEN_TRANSPARENCY_SOURCE_OVER;
}
Q_SCREEN_CHECKERROR(screen_set_window_property_iv(m_window, SCREEN_PROPERTY_TRANSPARENCY, val),
"Failed to set window transparency");
// Cache new buffer size
m_bufferSize = nonEmptySize;
resetBuffers();
}
QT_BEGIN_NAMESPACE
/*!
\class QQnxWindow
\brief The QQnxWindow is the base class of the various classes used as instances of
QPlatformWindow in the QNX QPA plugin.
The standard properties and methods available in Qt are not a perfect match for the
features provided by the QNX screen service. While for the majority of applications
the default behavior suffices, some circumstances require greater control over the
interaction with screen.
\section1 Window Types
The QNX QPA plugin can operate in two modes, with or without a root window. The
selection of mode is made via the \e rootwindow and \e no-rootwindow options to the
plugin. The default mode is rootwindow for BlackBerry builds and no-rootwindow for
non-BlackBerry builds.
Windows with parents are always created as child windows, the difference in the modes
is in the treatment of parentless windows. In no-rootwindow mode, these windows are
created as application windows while in rootwindow mode, the first window on a screen
is created as an application window while subsequent windows are created as child
windows. The only exception to this is any window of type Qt::Desktop or Qt::CoverWindow;
these are created as application windows, but will never become the root window,
even if they are the first window created.
It is also possible to create a parentless child window. These may be useful to
create windows that are parented by windows from other processes. To do this, you
attach a dynamic property \e qnxInitialWindowGroup to the QWindow though this must be done
prior to the platform window class (this class) being created which typically happens
when the window is made visible. When the window is created in QML, it is acceptable
to have the \e visible property hardcoded to true so long as the qnxInitialWindowGroup
is also set.
\section1 Joining Window Groups
Window groups may be joined in a number of ways, some are automatic based on
predefined rules though an application is also able to provide explicit control.
A QWindow that has a parent will join its parent's window group. When rootwindow mode
is in effect, all but the first parentless window on a screen will be child windows
and join the window group of the first parentless window, the root window.
If a QWindow has a valid dynamic property called \e qnxInitialWindowGroup at the time the
QQnxWindow is created, the window will be created as a child window and, if the
qnxInitialWindowGroup property is a non-empty string, an attempt will be made to join that
window group. This has an effect only when the QQnxWindow is created, subsequent
changes to this property are ignored. Setting the property to an empty string
provides a means to create 'top level' child windows without automatically joining
any group. Typically when this property is used \e qnxWindowId should be used as well
so that the process that owns the window group being joined has some means to
identify the window.
At any point following the creation of the QQnxWindow object, an application can
change the window group it has joined. This is done by using the \e
setWindowProperty function of the native interface to set the \e qnxWindowGroup property
to the desired value, for example:
\code
QQuickView *view = new QQuickView(parent);
view->create();
QGuiApplication::platformNativeInterface()->setWindowProperty(view->handle(), "qnxWindowGroup",
group);
\endcode
To leave the current window group, one passes a null value for the property value,
for example:
\code
QQuickView *view = new QQuickView(parent);
view->create();
QGuiApplication::platformNativeInterface()->setWindowProperty(view->handle(), "qnxWindowGroup",
QVariant());
\endcode
\section1 Window Id
The screen window id string property can be set on a window by assigning the desired
value to a dynamic property \e qnxWindowId on the QWindow prior to the QQnxWindow having
been created. This is often wanted when one joins a window group belonging to a
different process.
*/
QQnxWindow::QQnxWindow(QWindow *window, screen_context_t context, bool needRootWindow)
: QPlatformWindow(window),
m_screenContext(context),
m_window(0),
m_screen(0),
m_parentWindow(0),
m_visible(false),
m_exposed(true),
m_windowState(Qt::WindowNoState),
m_mmRendererWindow(0)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window << ", size =" << window->size();
QQnxScreen *platformScreen = static_cast<QQnxScreen *>(window->screen()->handle());
// If a qnxInitialWindowGroup property is set on the window we'll take this as an
// indication that we want to create a child window and join that window group.
const QVariant windowGroup = window->property("qnxInitialWindowGroup");
if (window->type() == Qt::CoverWindow) {
// Cover windows have to be top level to be accessible to window delegate (i.e. navigator)
// Desktop windows also need to be toplevel because they are not
// supposed to be part of the window hierarchy tree
m_isTopLevel = true;
} else if (parent() || windowGroup.isValid()) {
// If we have a parent we are a child window. Sometimes we have to be a child even if we
// don't have a parent e.g. our parent might be in a different process.
m_isTopLevel = false;
} else {
// We're parentless. If we're not using a root window, we'll always be a top-level window
// otherwise only the first window is.
m_isTopLevel = !needRootWindow || !platformScreen->rootWindow();
}
if (window->type() == Qt::Desktop) // A desktop widget does not need a libscreen window
return;
if (m_isTopLevel) {
Q_SCREEN_CRITICALERROR(screen_create_window(&m_window, m_screenContext),
"Could not create top level window"); // Creates an application window
if (window->type() != Qt::CoverWindow) {
if (needRootWindow)
platformScreen->setRootWindow(this);
}
} else {
Q_SCREEN_CHECKERROR(
screen_create_window_type(&m_window, m_screenContext, SCREEN_CHILD_WINDOW),
"Could not create child window");
}
createWindowGroup();
// If the window has a qnxWindowId property, set this as the string id property. This generally
// needs to be done prior to joining any group as it might be used by the owner of the
// group to identify the window.
const QVariant windowId = window->property("qnxWindowId");
if (windowId.isValid() && windowId.canConvert<QByteArray>()) {
QByteArray id = windowId.toByteArray();
Q_SCREEN_CHECKERROR(screen_set_window_property_cv(m_window, SCREEN_PROPERTY_ID_STRING,
id.size(), id), "Failed to set id");
}
// If a window group has been provided join it now. If it's an empty string that's OK too,
// it'll cause us not to join a group (the app will presumably join at some future time).
if (windowGroup.isValid() && windowGroup.canConvert<QByteArray>())
joinWindowGroup(windowGroup.toByteArray());
}
void QQnxWindow::scroll(const QRegion ®ion, int dx, int dy, bool flush)
{
qWindowDebug() << Q_FUNC_INFO << "window =" << window();
blitPreviousToCurrent(region, dx, dy, flush);
m_scrolled += region;
}
