/*!
\since 4.8
Returns a platform window format for the OpenGL format specified by \a format.
*/
QPlatformWindowFormat QGLFormat::toPlatformWindowFormat(const QGLFormat &format)
{
QPlatformWindowFormat retFormat;
retFormat.setAccum(format.accum());
if (format.accumBufferSize() >= 0)
retFormat.setAccumBufferSize(format.accumBufferSize());
retFormat.setAlpha(format.alpha());
if (format.alphaBufferSize() >= 0)
retFormat.setAlphaBufferSize(format.alphaBufferSize());
if (format.blueBufferSize() >= 0)
retFormat.setBlueBufferSize(format.blueBufferSize());
retFormat.setDepth(format.depth());
if (format.depthBufferSize() >= 0)
retFormat.setDepthBufferSize(format.depthBufferSize());
retFormat.setDirectRendering(format.directRendering());
retFormat.setDoubleBuffer(format.doubleBuffer());
if (format.greenBufferSize() >= 0)
retFormat.setGreenBufferSize(format.greenBufferSize());
if (format.redBufferSize() >= 0)
retFormat.setRedBufferSize(format.redBufferSize());
retFormat.setRgba(format.rgba());
retFormat.setSampleBuffers(format.sampleBuffers());
if (format.samples() >= 0)
retFormat.setSamples(format.samples());
retFormat.setStencil(format.stencil());
if (format.stencilBufferSize() >= 0)
retFormat.setStencilBufferSize(format.stencilBufferSize());
retFormat.setStereo(format.stereo());
retFormat.setSwapInterval(format.swapInterval());
return retFormat;
}
QPlatformWindowFormat qglx_platformWindowFromGLXFBConfig(Display *display, GLXFBConfig config, GLXContext ctx)
{
QPlatformWindowFormat format;
int redSize = 0;
int greenSize = 0;
int blueSize = 0;
int alphaSize = 0;
int depthSize = 0;
int stencilSize = 0;
int sampleBuffers = 0;
int sampleCount = 0;
int level = 0;
int rgba = 0;
int stereo = 0;
int accumSizeA = 0;
int accumSizeR = 0;
int accumSizeG = 0;
int accumSizeB = 0;
XVisualInfo *vi = glXGetVisualFromFBConfig(display,config);
glXGetConfig(display,vi,GLX_RGBA,&rgba);
XFree(vi);
glXGetFBConfigAttrib(display, config, GLX_RED_SIZE, &redSize);
glXGetFBConfigAttrib(display, config, GLX_GREEN_SIZE, &greenSize);
glXGetFBConfigAttrib(display, config, GLX_BLUE_SIZE, &blueSize);
glXGetFBConfigAttrib(display, config, GLX_ALPHA_SIZE, &alphaSize);
glXGetFBConfigAttrib(display, config, GLX_DEPTH_SIZE, &depthSize);
glXGetFBConfigAttrib(display, config, GLX_STENCIL_SIZE, &stencilSize);
glXGetFBConfigAttrib(display, config, GLX_SAMPLES, &sampleBuffers);
glXGetFBConfigAttrib(display, config, GLX_LEVEL, &level);
glXGetFBConfigAttrib(display, config, GLX_STEREO, &stereo);
glXGetFBConfigAttrib(display, config, GLX_ACCUM_ALPHA_SIZE, &accumSizeA);
glXGetFBConfigAttrib(display, config, GLX_ACCUM_RED_SIZE, &accumSizeR);
glXGetFBConfigAttrib(display, config, GLX_ACCUM_GREEN_SIZE, &accumSizeG);
glXGetFBConfigAttrib(display, config, GLX_ACCUM_BLUE_SIZE, &accumSizeB);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
format.setSampleBuffers(sampleBuffers);
if (format.sampleBuffers()) {
glXGetFBConfigAttrib(display, config, GLX_SAMPLES_ARB, &sampleCount);
format.setSamples(sampleCount);
}
format.setDirectRendering(glXIsDirect(display, ctx));
format.setRgba(rgba);
format.setStereo(stereo);
format.setAccumBufferSize(accumSizeB);
return format;
}
QPlatformWindowFormat QXlibWindow::correctColorBuffers(const QPlatformWindowFormat &platformWindowFormat) const
{
// I have only tested this setup on a dodgy intel setup, where I didn't use standard libs,
// so this might be not what we want to do :)
if ( !(platformWindowFormat.redBufferSize() == -1 &&
platformWindowFormat.greenBufferSize() == -1 &&
platformWindowFormat.blueBufferSize() == -1))
return platformWindowFormat;
QPlatformWindowFormat windowFormat = platformWindowFormat;
if (mScreen->depth() == 16) {
windowFormat.setRedBufferSize(5);
windowFormat.setGreenBufferSize(6);
windowFormat.setBlueBufferSize(5);
} else {
windowFormat.setRedBufferSize(8);
windowFormat.setGreenBufferSize(8);
windowFormat.setBlueBufferSize(8);
}
return windowFormat;
}
QPlatformWindowFormat qt_qPlatformWindowFormatFromConfig(EGLDisplay display, const EGLConfig config)
{
QPlatformWindowFormat format;
EGLint redSize = 0;
EGLint greenSize = 0;
EGLint blueSize = 0;
EGLint alphaSize = 0;
EGLint depthSize = 0;
EGLint stencilSize = 0;
EGLint sampleCount = 0;
EGLint level = 0;
eglGetConfigAttrib(display, config, EGL_RED_SIZE, &redSize);
eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &greenSize);
eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blueSize);
eglGetConfigAttrib(display, config, EGL_ALPHA_SIZE, &alphaSize);
eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depthSize);
eglGetConfigAttrib(display, config, EGL_STENCIL_SIZE, &stencilSize);
eglGetConfigAttrib(display, config, EGL_SAMPLES, &sampleCount);
eglGetConfigAttrib(display, config, EGL_LEVEL, &level);
format.setRedBufferSize(redSize);
format.setGreenBufferSize(greenSize);
format.setBlueBufferSize(blueSize);
format.setAlphaBufferSize(alphaSize);
format.setDepthBufferSize(depthSize);
format.setStencilBufferSize(stencilSize);
format.setSamples(sampleCount);
format.setDirectRendering(true); // All EGL contexts are direct-rendered
format.setRgba(true); // EGL doesn't support colour index rendering
format.setStereo(false); // EGL doesn't support stereo buffers
format.setAccumBufferSize(0); // EGL doesn't support accululation buffers
format.setDoubleBuffer(true);
// Clear the EGL error state because some of the above may
// have errored out because the attribute is not applicable
// to the surface type. Such errors don't matter.
eglGetError();
return format;
}
QOpenKODEWindow::QOpenKODEWindow(QWidget *tlw)
: QPlatformWindow(tlw), isFullScreen(false)
{
if (tlw->platformWindowFormat().windowApi() == QPlatformWindowFormat::OpenVG) {
m_eglApi = EGL_OPENVG_API;
} else {
m_eglContextAttrs.append(EGL_CONTEXT_CLIENT_VERSION);
m_eglContextAttrs.append(2);
m_eglApi = EGL_OPENGL_ES_API;
}
eglBindAPI(m_eglApi);
m_eglContextAttrs.append(EGL_NONE);
m_eglWindowAttrs.append(EGL_NONE);
QList<QPlatformScreen *> screens = QApplicationPrivate::platformIntegration()->screens();
//XXXX: jl figure out how to pick the correct screen.
// Q_ASSERT(screens.size() > tlw->d_func()->screenNumber);
// QOpenKODEScreen *screen = qobject_cast<QOpenKODEScreen *>(screens.at(tlw->d_func()->screenNumber));
QOpenKODEScreen *screen = qobject_cast<QOpenKODEScreen *>(screens.at(0));
if (!screen) {
qErrnoWarning("Could not make QOpenKODEWindow without a screen");
}
QPlatformWindowFormat format = tlw->platformWindowFormat();
format.setRedBufferSize(5);
format.setGreenBufferSize(6);
format.setBlueBufferSize(5);
m_eglConfig = q_configFromQPlatformWindowFormat(screen->eglDisplay(),format);
m_kdWindow = kdCreateWindow(screen->eglDisplay(),
m_eglConfig,
this);
kdInstallCallback(kdProcessMouseEvents,KD_EVENT_INPUT_POINTER,this);
#ifdef KD_ATX_keyboard
kdInstallCallback(kdProcessKeyEvents, KD_EVENT_INPUT_KEY_ATX,this);
#endif //KD_ATX_keyboard
if (!m_kdWindow) {
qErrnoWarning(kdGetError(), "Error creating native window");
return;
}
KDboolean exclusive(false);
if (kdSetWindowPropertybv(m_kdWindow,KD_WINDOWPROPERTY_DESKTOP_EXCLUSIVE_NV, &exclusive)) {
isFullScreen = true;
}
if (isFullScreen) {
tlw->setGeometry(screen->geometry());
screen->setFullScreen(isFullScreen);
}else {
const KDint windowSize[2] = { tlw->width(), tlw->height() };
if (kdSetWindowPropertyiv(m_kdWindow, KD_WINDOWPROPERTY_SIZE, windowSize)) {
qErrnoWarning(kdGetError(), "Could not set native window size");
}
KDboolean visibillity(false);
if (kdSetWindowPropertybv(m_kdWindow, KD_WINDOWPROPERTY_VISIBILITY, &visibillity)) {
qErrnoWarning(kdGetError(), "Could not set visibillity to false");
}
const KDint windowPos[2] = { tlw->x(), tlw->y() };
if (kdSetWindowPropertyiv(m_kdWindow, KD_WINDOWPROPERTY_DESKTOP_OFFSET_NV, windowPos)) {
qErrnoWarning(kdGetError(), "Could not set native window position");
return;
}
}
QOpenKODEIntegration *integration = static_cast<QOpenKODEIntegration *>(QApplicationPrivate::platformIntegration());
if (!isFullScreen || (isFullScreen && !integration->mainGLContext())) {
if (kdRealizeWindow(m_kdWindow, &m_eglWindow)) {
qErrnoWarning(kdGetError(), "Could not realize native window");
return;
}
EGLSurface surface = eglCreateWindowSurface(screen->eglDisplay(),m_eglConfig,m_eglWindow,m_eglWindowAttrs.constData());
m_platformGlContext = new QEGLPlatformContext(screen->eglDisplay(), m_eglConfig,
m_eglContextAttrs.data(), surface, m_eglApi);
integration->setMainGLContext(m_platformGLContext);
} else {
m_platformGlContext = integration->mainGLContext();
kdDestroyWindow(m_kdWindow);
m_kdWindow = 0;
}
}
void QEglFSScreen::createAndSetPlatformContext()
{
QPlatformWindowFormat platformFormat = QPlatformWindowFormat::defaultFormat();
platformFormat.setWindowApi(QPlatformWindowFormat::OpenGL);
QByteArray depthString = qgetenv("QT_QPA_EGLFS_DEPTH");
if (depthString.toInt() == 16) {
platformFormat.setDepth(16);
platformFormat.setRedBufferSize(5);
platformFormat.setGreenBufferSize(6);
platformFormat.setBlueBufferSize(5);
m_depth = 16;
m_format = QImage::Format_RGB16;
} else {
platformFormat.setDepth(32);
platformFormat.setRedBufferSize(8);
platformFormat.setGreenBufferSize(8);
platformFormat.setBlueBufferSize(8);
m_depth = 32;
m_format = QImage::Format_RGB32;
}
if (!qgetenv("QT_QPA_EGLFS_MULTISAMPLE").isEmpty()) {
platformFormat.setSampleBuffers(true);
}
EGLConfig config = q_configFromQPlatformWindowFormat(m_dpy, platformFormat);
EGLNativeWindowType eglWindow = 0;
#ifdef Q_OPENKODE
if (kdInitializeNV() == KD_ENOTINITIALIZED) {
qFatal("Did not manage to initialize openkode");
}
KDWindow *window = kdCreateWindow(m_dpy,config,0);
kdRealizeWindow(window,&eglWindow);
#endif
m_surface = eglCreateWindowSurface(m_dpy, config, eglWindow, NULL);
if (m_surface == EGL_NO_SURFACE) {
qWarning("Could not create the egl surface: error = 0x%x\n", eglGetError());
eglTerminate(m_dpy);
qFatal("EGL error");
}
// qWarning("Created surface %dx%d\n", w, h);
#ifdef QEGL_EXTRA_DEBUG
qWarning("Configuration %d matches requirements\n", (int)config);
for (index = 0; attrs[index].attr != -1; ++index) {
EGLint value;
if (eglGetConfigAttrib(m_dpy, config, attrs[index].attr, &value)) {
qWarning("\t%s: %d\n", attrs[index].name, (int)value);
}
}
qWarning("\n");
#endif
EGLint temp;
EGLint attribList[32];
temp = 0;
attribList[temp++] = EGL_CONTEXT_CLIENT_VERSION;
attribList[temp++] = 2; // GLES version 2
attribList[temp++] = EGL_NONE;
QEGLPlatformContext *platformContext = new QEGLPlatformContext(m_dpy,config,attribList,m_surface,EGL_OPENGL_ES_API);
m_platformContext = platformContext;
EGLint w,h; // screen size detection
eglQuerySurface(m_dpy, m_surface, EGL_WIDTH, &w);
eglQuerySurface(m_dpy, m_surface, EGL_HEIGHT, &h);
m_geometry = QRect(0,0,w,h);
}