void GVRInterface::enterVRMode() { #if defined(ANDROID) && defined(HAVE_LIBOVR) // Default vrModeParms ovrModeParms vrModeParms; vrModeParms.AsynchronousTimeWarp = true; vrModeParms.AllowPowerSave = true; vrModeParms.DistortionFileName = NULL; vrModeParms.EnableImageServer = false; vrModeParms.CpuLevel = 2; vrModeParms.GpuLevel = 2; vrModeParms.GameThreadTid = 0; QAndroidJniEnvironment jniEnv; QPlatformNativeInterface* interface = QApplication::platformNativeInterface(); jobject activity = (jobject) interface->nativeResourceForIntegration("QtActivity"); vrModeParms.ActivityObject = activity; ovrHmdInfo hmdInfo; _ovr = ovr_EnterVrMode(vrModeParms, &hmdInfo); _inVRMode = true; #endif }
void XCompositeGLXClientBufferIntegration::initializeHardware(QtWayland::Display *) { qDebug() << "Initializing GLX integration"; QPlatformNativeInterface *nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); if (nativeInterface) { mDisplay = static_cast<Display *>(nativeInterface->nativeResourceForWindow("Display",m_compositor->window())); if (!mDisplay) qFatal("could not retireve Display from platform integration"); } else { qFatal("Platform integration doesn't have native interface"); } mScreen = XDefaultScreen(mDisplay); mHandler = new XCompositeHandler(m_compositor->handle(), mDisplay); QOpenGLContext *glContext = new QOpenGLContext(); glContext->create(); m_glxBindTexImageEXT = reinterpret_cast<PFNGLXBINDTEXIMAGEEXTPROC>(glContext->getProcAddress("glXBindTexImageEXT")); if (!m_glxBindTexImageEXT) { qDebug() << "Did not find glxBindTexImageExt, everything will FAIL!"; } m_glxReleaseTexImageEXT = reinterpret_cast<PFNGLXRELEASETEXIMAGEEXTPROC>(glContext->getProcAddress("glXReleaseTexImageEXT")); if (!m_glxReleaseTexImageEXT) { qDebug() << "Did not find glxReleaseTexImageExt"; } delete glContext; }
VibroWorker::VibroWorker () : last_is_alarm (false), last_vibration_looped (false), mCancel (NULL), mVibrate (NULL), mVibratePattern (NULL), objVibrator (NULL) { QPlatformNativeInterface *interface = QApplication::platformNativeInterface (); jobject objActivity = (jobject) interface->nativeResourceForIntegration ("QtActivity"); jclass classActivity = jni_env->FindClass ("android/app/Activity"); if (objActivity && classActivity) { jmethodID mSystemService = jni_env->GetMethodID (classActivity, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;"); jstring strMethod = jni_env->NewStringUTF ("vibrator"); if (mSystemService && strMethod) objVibrator = jni_env->CallObjectMethod (objActivity, mSystemService, strMethod); if (objVibrator) { jclass classVibrator = jni_env->GetObjectClass (objVibrator); if (classVibrator) { mCancel = jni_env->GetMethodID (classVibrator, "cancel", "()V"); mVibrate = jni_env->GetMethodID (classVibrator, "vibrate", "(J)V"); mVibratePattern = jni_env->GetMethodID (classVibrator, "vibrate", "([JI)V"); } } } cancel_vibration_timer.setSingleShot (true); connect (&cancel_vibration_timer, SIGNAL (timeout ()), this, SLOT (cancelLoopedVibration ())); }
static JavaVM *getJavaVM() { if (!g_javaVM){ QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface(); g_javaVM = static_cast<JavaVM*>(nativeInterface->nativeResourceForIntegration("JavaVM")); } return g_javaVM; }
static void enableMacToolBar(QToolBar *toolbar, bool enable) { QPlatformNativeInterface *nativeInterface = QApplication::platformNativeInterface(); QPlatformNativeInterface::NativeResourceForIntegrationFunction function = nativeInterface->nativeResourceFunctionForIntegration("setContentBorderAreaEnabled"); if (!function) return; // Not Cocoa platform plugin. typedef void (*SetContentBorderAreaEnabledFunction)(QWindow *window, void *identifier, bool enabled); (reinterpret_cast<SetContentBorderAreaEnabledFunction>(function))(toolbar->window()->windowHandle(), toolbar, enable); }
void InputRegionPrivate::update() { Q_Q(InputRegion); q->killTimer(updateTimerId); updateTimerId = 0; if (window && window->handle()) { QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface(); native->setWindowProperty(window->handle(), QLatin1String("MOUSE_REGION"), QVariant(QRegion(x, y, width, height))); } }
inline static Display* x11Display() { // Qt 5 does not support QX11Info. #if QT_VERSION >= 0x050000 // references: https://github.com/hawaii-desktop/libkdeqt5staging/blob/master/src/qt5only/qx11info.cpp QPlatformNativeInterface* native = qApp->platformNativeInterface(); void* display = native->nativeResourceForScreen(QByteArray("display"), QGuiApplication::primaryScreen()); return reinterpret_cast<Display*>(display); #else return QX11Info::display(); #endif }
/*------------------------------------------------------------------------------ | get_egl_display +-----------------------------------------------------------------------------*/ EGLDisplay get_egl_display() { QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); Q_ASSERT(nativeInterface); EGLDisplay d = nativeInterface->nativeResourceForIntegration("egldisplay"); if (!d) log_warn("Couldn't get EGL display handle."); return d; }
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext = 0) : m_display(0) , m_xPixmap(0) , m_glxPixmap(0) , m_glContext(0) , m_detachedContext(0) , m_detachedSurface(0) , m_textureIsYInverted(false) , m_hasAlpha(false) { GLXContext shareContextObject = 0; m_display = XOpenDisplay(0); #if PLATFORM(QT) if (shareContext) { #if 0 // This code path requires QXcbNativeInterface::nativeResourceForContext() which is not availble in Qt5 on the build bots yet. QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface(); shareContextObject = static_cast<GLXContext>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("glxcontext"), shareContext)); if (!shareContextObject) return; #else // This code path should be removed as soon as QXcbNativeInterface::nativeResourceForContext() can provide the GLXContext. QOpenGLContext* previousContext = QOpenGLContext::currentContext(); QSurface* previousSurface = previousContext->surface(); QSurface* currentSurface = shareContext->surface(); shareContext->makeCurrent(currentSurface); shareContextObject = glXGetCurrentContext(); previousContext->makeCurrent(previousSurface); #endif } #endif m_display = m_offScreenWindow.display(); int attributes[] = { GLX_LEVEL, 0, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, GLX_DOUBLEBUFFER, True, None }; int numReturned; m_fbConfigs = glXChooseFBConfig(m_display, DefaultScreen(m_display), attributes, &numReturned); // Create a GLX context for OpenGL rendering m_glContext = glXCreateNewContext(m_display, m_fbConfigs[0], GLX_RGBA_TYPE, shareContextObject, true); }
void GLWidget::makeObject() { static const int coords[6][4][3] = { { { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } }, { { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } }, { { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } }, { { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } }, { { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } }, { { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } } }; QElapsedTimer timer; timer.start(); #ifndef DISABLED_OPENMAX //loadWithOmx(); QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); Q_ASSERT(nativeInterface); EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay"); EGLContext eglContext = nativeInterface->nativeResourceForContext("eglcontext", QOpenGLContext::currentContext()); #if 0 eglImageVideo = getEGLImage(1920, 1080, eglDisplay, eglContext, textures[0]); #endif for (int i = 0; i < 5; i++) textures[i] = 0; //QtConcurrent::run(video_decode_test, videoPath, eglImageVideo, eglDisplay); m_videoProc = new OMX_VideoProcessor(eglDisplay, eglContext, m_provider); connect(m_videoProc, SIGNAL(textureReady(uint)), this, SLOT(onTextureChanged(uint))); m_videoProc->setVideoPath("/home/pi/out.h264"); m_videoProc->play(); #else for (int i = 0; i < 6; i++) { QPixmap pixmap(QString("%1%2.jpg").arg(prefix).arg(i)); if (pixmap.isNull()) LOG_ERROR(LOG_TAG, "Failed to load image!"); textures[i] = bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA); } #endif LOG_INFORMATION(LOG_TAG, "Elapsed: %lld.", timer.elapsed()); for (int i = 0; i < 6; ++i) { for (int j = 0; j < 4; ++j) { texCoords.append (QVector2D(j == 0 || j == 3, j == 0 || j == 1)); vertices.append (QVector3D(0.2 * coords[i][j][0], 0.2 * coords[i][j][1], 0.2 * coords[i][j][2])); } } }
HRESULT STDMETHODCALLTYPE QWindowsAccessible::GetWindow(HWND *phwnd) { *phwnd = 0; if (!accessible->isValid()) return E_UNEXPECTED; QWindow *window = window_helper(accessible); if (!window) return E_FAIL; QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface(); Q_ASSERT(platform); *phwnd = (HWND)platform->nativeResourceForWindow("handle", window); return S_OK; }
OMX_TextureData* OMX_TextureProviderQGLWidget::instantiateTexture(QSize size) { // TODO: Reimplement. #if 0 m_parent->makeCurrent(); QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); Q_ASSERT(nativeInterface); EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay"); EGLContext eglContext = nativeInterface->nativeResourceForContext("eglcontext", QOpenGLContext::currentContext()); GLuint texture; eglImageVideo = getEGLImage(size.width(), size.height(), eglDisplay, eglContext, texture); return texture; #endif return 0; }
QHimePlatformInputContext::QHimePlatformInputContext() { dbg("QHimePlatformInputContext::QHimePlatformInputContext() \n"); QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface(); if(!native) return; Display *display = static_cast<Display *>(native->nativeResourceForWindow("display", NULL)); if (!(hime_ch = hime_im_client_open(display))) { perror("cannot open hime_ch"); dbg("hime_im_client_open error\n"); return; } dbg("QHimePlatformInputContext succ\n"); }
void XCompositeEglClientBufferIntegration::initializeHardware(QtWayland::Display *) { QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface(); if (nativeInterface) { mDisplay = static_cast<Display *>(nativeInterface->nativeResourceForIntegration("Display")); if (!mDisplay) qFatal("could not retrieve Display from platform integration"); mEglDisplay = static_cast<EGLDisplay>(nativeInterface->nativeResourceForIntegration("EGLDisplay")); if (!mEglDisplay) qFatal("could not retrieve EGLDisplay from platform integration"); } else { qFatal("Platform integration doesn't have native interface"); } mScreen = XDefaultScreen(mDisplay); new XCompositeHandler(m_compositor->handle(), mDisplay); }
/*------------------------------------------------------------------------------ | get_egl_context +-----------------------------------------------------------------------------*/ EGLContext get_global_egl_context() { QOpenGLContext* c = QOpenGLContext::globalShareContext(); if (!c) return (void*)log_warn("Cannot get an OpenGL context."); QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); Q_ASSERT(nativeInterface); EGLContext eglc = nativeInterface->nativeResourceForContext("eglcontext", c); if (!eglc) log_warn("Couldn't get EGL context from currrent OpenGL context."); return eglc; }
Compositor *Compositor::fromApplication(QObject *parent) { if (!QGuiApplication::platformName().contains(QStringLiteral("wayland"), Qt::CaseInsensitive)) { return nullptr; } QPlatformNativeInterface *native = qApp->platformNativeInterface(); if (!native) { return nullptr; } wl_compositor *compositor = reinterpret_cast<wl_compositor*>(native->nativeResourceForIntegration(QByteArrayLiteral("compositor"))); if (!compositor) { return nullptr; } Compositor *c = new Compositor(parent); c->d->compositor.setup(compositor, true); return c; }
/**************************************************************\ * IOleWindow * **************************************************************/ HRESULT STDMETHODCALLTYPE QWindowsMsaaAccessible::GetWindow(HWND *phwnd) { *phwnd = 0; QAccessibleInterface *accessible = accessibleInterface(); accessibleDebugClientCalls(accessible); if (!accessible) return E_FAIL; QWindow *window = QWindowsAccessibility::windowHelper(accessible); if (!window) return E_FAIL; QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface(); Q_ASSERT(platform); *phwnd = (HWND)platform->nativeResourceForWindow("handle", window); accessibleDebug("QWindowsAccessible::GetWindow(): %p", *phwnd); return S_OK; }
Surface *Surface::fromQt(QWindow *window, QObject *parent) { if (!QGuiApplication::platformName().startsWith(QLatin1String("wayland"))) return Q_NULLPTR; QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface(); if (!native) return Q_NULLPTR; wl_surface *surface = reinterpret_cast<wl_surface *>( native->nativeResourceForWindow(QByteArrayLiteral("surface"), window)); if (!surface) return Q_NULLPTR; Surface *s = new Surface(parent); SurfacePrivate::get(s)->init(surface); return s; }
void GLWidget::loadWithOmx() { LOG_VERBOSE(LOG_TAG, "Loading with OMX."); QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); Q_ASSERT(nativeInterface); EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay"); EGLContext eglContext = nativeInterface->nativeResourceForContext("eglcontext", QOpenGLContext::currentContext()); for (int i = 5; i < 6; i++) { QString fileAbsPath = QString("%1%2.jpg").arg(prefix).arg(i); OpenMAXILTextureLoader* omTextureLoader = OpenMAXILTextureLoader::intance(); if (!omTextureLoader->loadTextureFromImage(fileAbsPath, eglDisplay, eglContext, textures[i])) { LOG_ERROR(LOG_TAG, "Failed to load image."); } else { LOG_INFORMATION(LOG_TAG, "Image %s successfully decoded and loaded.", qPrintable(fileAbsPath)); } } }
void MouseTouchAdaptor::fetchXInput2Info() { QPlatformNativeInterface *nativeInterface = qGuiApp->platformNativeInterface(); Display *xDisplay = static_cast<Display*>(nativeInterface->nativeResourceForIntegration("Display")); if (xDisplay && XQueryExtension(xDisplay, "XInputExtension", &m_xiOpCode, &m_xiEventBase, &m_xiErrorBase)) { int xiMajor = 2; m_xi2Minor = 2; // try 2.2 first, needed for TouchBegin/Update/End if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) { m_xi2Minor = 1; // for smooth scrolling 2.1 is enough if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) { m_xi2Minor = 0; // for tablet support 2.0 is enough m_xi2Enabled = XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) != BadRequest; } else m_xi2Enabled = true; } else { m_xi2Enabled = true; } } }
GVRInterface::GVRInterface(int argc, char* argv[]) : QApplication(argc, argv), _mainWindow(NULL), _inVRMode(false) { setApplicationName("gvr-interface"); setOrganizationName("highfidelity"); setOrganizationDomain("io"); if (!launchURLString.isEmpty()) { // did we get launched with a lookup URL? If so it is time to give that to the AddressManager qDebug() << "We were opened via a hifi URL -" << launchURLString; } _client = new RenderingClient(this, launchURLString); launchURLString = QString(); connect(this, &QGuiApplication::applicationStateChanged, this, &GVRInterface::handleApplicationStateChange); #if defined(ANDROID) && defined(HAVE_LIBOVR) QAndroidJniEnvironment jniEnv; QPlatformNativeInterface* interface = QApplication::platformNativeInterface(); jobject activity = (jobject) interface->nativeResourceForIntegration("QtActivity"); ovr_RegisterHmtReceivers(&*jniEnv, activity); // PLATFORMACTIVITY_REMOVAL: Temp workaround for PlatformActivity being // stripped from UnityPlugin. Alternate is to use LOCAL_WHOLE_STATIC_LIBRARIES // but that increases the size of the plugin by ~1MiB OVR::linkerPlatformActivity++; #endif // call our idle function whenever we can QTimer* idleTimer = new QTimer(this); connect(idleTimer, &QTimer::timeout, this, &GVRInterface::idle); idleTimer->start(0); // call our quit handler before we go down connect(this, &QCoreApplication::aboutToQuit, this, &GVRInterface::handleApplicationQuit); }
int main(int argc, char *argv[]) { QScopedPointer<QGuiApplication> app (SailfishApp::application(argc, argv)); QScopedPointer<QQuickView> view (SailfishApp::createView()); MGConfItem partnerSpaceQml (PARTNERSPACEMANAGER_QML_DCONF); QString qmlFile = partnerSpaceQml.value(QString()).toString(); if (qmlFile.isEmpty()) { return 1; } qDebug() << "Running partner-space launcher with" << qmlFile; view->setSource(QUrl(qmlFile)); // The view is a partner window view->create(); QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface(); native->setWindowProperty(view->handle(), QLatin1String("CATEGORY"), QString(QLatin1String("partner"))); view->show(); return app->exec(); }
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext = 0) : m_display(m_offScreenWindow.display()) , m_xPixmap(0) , m_glxPixmap(0) , m_surface(0) , m_glxSurface(0) , m_glContext(0) , m_detachedContext(0) , m_detachedSurface(0) , m_fbConfig(0) , m_textureIsYInverted(false) , m_hasAlpha(false) , m_isReceiver(false) { GLXContext shareContextObject = 0; #if PLATFORM(QT) if (shareContext) { QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface(); shareContextObject = static_cast<GLXContext>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("glxcontext"), shareContext)); if (!shareContextObject) return; } #else UNUSED_PARAM(shareContext); #endif int numReturned; GLXFBConfig* fbConfigs = glXChooseFBConfig(m_display, DefaultScreen(m_display), attributes, &numReturned); // Make sure that we choose a configuration that supports an alpha mask. m_fbConfig = findFBConfigWithAlpha(fbConfigs, numReturned); XFree(fbConfigs); // Create a GLX context for OpenGL rendering m_glContext = glXCreateNewContext(m_display, m_fbConfig, GLX_RGBA_TYPE, shareContextObject, true); }
QSGNode* OMX_MediaProcessorElement::updatePaintNode(QSGNode*, UpdatePaintNodeData*) { if (!m_texProvider) { m_texProvider = new OMX_TextureProviderQQuickItem(this); m_mediaProc = new OMX_MediaProcessor(m_texProvider); connect(m_mediaProc, SIGNAL(playbackCompleted()), this, SIGNAL(playbackCompleted())); connect(m_mediaProc, SIGNAL(playbackStarted()), this, SIGNAL(playbackStarted())); // Open if filepath is set. // TODO: Handle errors. if (!m_source.isNull()) { //if (QFile(m_source).exists()) { if (openMedia(m_source)) m_mediaProc->play(); //} //else { LOG_WARNING(LOG_TAG, "File does not exist."); //} } } return NULL; #if 0 QSGGeometryNode* node = 0; QSGGeometry* geometry = 0; if (!oldNode) { // Create the node. node = new QSGGeometryNode; geometry = new QSGGeometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 4); geometry->setDrawingMode(GL_TRIANGLE_STRIP); node->setGeometry(geometry); node->setFlag(QSGNode::OwnsGeometry); // TODO: Who is freeing this? // TODO: I cannot know the texture size here. QSGOpaqueTextureMaterial* material = new QSGOpaqueTextureMaterial; m_sgtexture = new OMX_SGTexture(m_texture, QSize(1920, 1080)); material->setTexture(m_sgtexture); node->setMaterial(material); node->setFlag(QSGNode::OwnsMaterial); #ifdef ENABLE_VIDEO_PROCESSOR QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface(); Q_ASSERT(nativeInterface); EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay"); EGLContext eglContext = nativeInterface->nativeResourceForContext( "eglcontext", QOpenGLContext::currentContext() ); #endif // Provider MUST be built in this thread. m_provider = new OMX_TextureProviderQQuickItem(this); #ifdef ENABLE_VIDEO_PROCESSOR m_videoProc = new OMX_VideoProcessor(eglDisplay, eglContext, m_provider); connect(m_videoProc, SIGNAL(textureReady(uint)), this, SLOT(onTextureChanged(uint))); if (!m_source.isNull()) m_videoProc->setVideoPath(m_source); if (m_playScheduled) { m_timer->start(30); m_videoProc->play(); } #elif ENABLE_MEDIA_PROCESSOR LOG_VERBOSE(LOG_TAG, "Starting video using media processor..."); m_mediaProc = new OMX_MediaProcessor(m_provider); m_mediaProc->setFilename("/home/pi/usb/Cars2.mkv", m_texture); //if (m_playScheduled) { m_timer->start(40); m_mediaProc->play(); //} #else LOG_VERBOSE(LOG_TAG, "Starting video..."); QtConcurrent::run(&startVideo, m_provider, this); m_timer->start(30); #endif } else { node = static_cast<QSGGeometryNode*>(oldNode); geometry = node->geometry(); geometry->allocate(4); // Update texture in the node if needed. QSGOpaqueTextureMaterial* material = (QSGOpaqueTextureMaterial*)node->material(); if (m_texture != (GLuint)material->texture()->textureId()) { // TODO: Does setTextureId frees the prev texture? // TODO: I should the given the texture size. LOG_ERROR(LOG_TAG, "Updating texture to %u!", m_texture); material = new QSGOpaqueTextureMaterial; m_sgtexture->setTexture(m_texture, QSize(1920, 1080)); } } // Create the vertices and map to texture. QRectF bounds = boundingRect(); QSGGeometry::TexturedPoint2D* vertices = geometry->vertexDataAsTexturedPoint2D(); vertices[0].set(bounds.x(), bounds.y() + bounds.height(), 0.0f, 0.0f); vertices[1].set(bounds.x() + bounds.width(), bounds.y() + bounds.height(), 1.0f, 0.0f); vertices[2].set(bounds.x(), bounds.y(), 0.0f, 1.0f); vertices[3].set(bounds.x() + bounds.width(), bounds.y(), 1.0f, 1.0f); return node; #endif }
void WaylandEglClientBufferIntegration::initializeHardware(QtWayland::Display *waylandDisplay) { Q_D(WaylandEglClientBufferIntegration); const bool ignoreBindDisplay = !qgetenv("QT_WAYLAND_IGNORE_BIND_DISPLAY").isEmpty(); QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface(); if (!nativeInterface) { qWarning("QtCompositor: Failed to initialize EGL display. No native platform interface available."); return; } d->egl_display = nativeInterface->nativeResourceForWindow("EglDisplay", m_compositor->window()); if (!d->egl_display) { qWarning("QtCompositor: Failed to initialize EGL display. Could not get EglDisplay for window."); return; } const char *extensionString = eglQueryString(d->egl_display, EGL_EXTENSIONS); if ((!extensionString || !strstr(extensionString, "EGL_WL_bind_wayland_display")) && !ignoreBindDisplay) { qWarning("QtCompositor: Failed to initialize EGL display. There is no EGL_WL_bind_wayland_display extension."); return; } d->egl_bind_wayland_display = reinterpret_cast<PFNEGLBINDWAYLANDDISPLAYWL>(eglGetProcAddress("eglBindWaylandDisplayWL")); d->egl_unbind_wayland_display = reinterpret_cast<PFNEGLUNBINDWAYLANDDISPLAYWL>(eglGetProcAddress("eglUnbindWaylandDisplayWL")); if ((!d->egl_bind_wayland_display || !d->egl_unbind_wayland_display) && !ignoreBindDisplay) { qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglBindWaylandDisplayWL and eglUnbindWaylandDisplayWL."); return; } d->egl_query_wayland_buffer = reinterpret_cast<PFNEGLQUERYWAYLANDBUFFERWL_compat>(eglGetProcAddress("eglQueryWaylandBufferWL")); if (!d->egl_query_wayland_buffer) { qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglQueryWaylandBufferWL."); return; } d->egl_create_image = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(eglGetProcAddress("eglCreateImageKHR")); d->egl_destroy_image = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(eglGetProcAddress("eglDestroyImageKHR")); if (!d->egl_create_image || !d->egl_destroy_image) { qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglCreateImageKHR and eglDestroyImageKHR."); return; } d->gl_egl_image_target_texture_2d = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(eglGetProcAddress("glEGLImageTargetTexture2DOES")); if (!d->gl_egl_image_target_texture_2d) { qWarning("QtCompositor: Failed to initialize EGL display. Could not find glEGLImageTargetTexture2DOES."); return; } if (d->egl_bind_wayland_display && d->egl_unbind_wayland_display) { d->display_bound = d->egl_bind_wayland_display(d->egl_display, waylandDisplay->handle()); if (!d->display_bound) { if (!ignoreBindDisplay) { qWarning("QtCompositor: Failed to initialize EGL display. Could not bind Wayland display."); return; } else { qWarning("QtCompositor: Could not bind Wayland display. Ignoring."); } } } d->valid = true; }
void QWindowsAccessibility::notifyAccessibilityUpdate(QObject *o, int who, QAccessible::Event reason) { QString soundName; switch (reason) { case QAccessible::PopupMenuStart: soundName = QLatin1String("MenuPopup"); break; case QAccessible::MenuCommand: soundName = QLatin1String("MenuCommand"); break; case QAccessible::Alert: { /* ### FIXME #ifndef QT_NO_MESSAGEBOX QMessageBox *mb = qobject_cast<QMessageBox*>(o); if (mb) { switch (mb->icon()) { case QMessageBox::Warning: soundName = QLatin1String("SystemExclamation"); break; case QMessageBox::Critical: soundName = QLatin1String("SystemHand"); break; case QMessageBox::Information: soundName = QLatin1String("SystemAsterisk"); break; default: break; } } else #endif // QT_NO_MESSAGEBOX */ { soundName = QLatin1String("SystemAsterisk"); } } break; default: break; } if (!soundName.isEmpty()) { #ifndef QT_NO_SETTINGS QSettings settings(QLatin1String("HKEY_CURRENT_USER\\AppEvents\\Schemes\\Apps\\.Default\\") + soundName, QSettings::NativeFormat); QString file = settings.value(QLatin1String(".Current/.")).toString(); #else QString file; #endif if (!file.isEmpty()) { PlaySound(reinterpret_cast<const wchar_t *>(soundName.utf16()), 0, SND_ALIAS | SND_ASYNC | SND_NODEFAULT | SND_NOWAIT); } } typedef void (WINAPI *PtrNotifyWinEvent)(DWORD, HWND, LONG, LONG); #if defined(Q_WS_WINCE) // ### TODO: check for NotifyWinEvent in CE 6.0 // There is no user32.lib nor NotifyWinEvent for CE return; #else static PtrNotifyWinEvent ptrNotifyWinEvent = 0; static bool resolvedNWE = false; if (!resolvedNWE) { resolvedNWE = true; ptrNotifyWinEvent = (PtrNotifyWinEvent)QSystemLibrary::resolve(QLatin1String("user32"), "NotifyWinEvent"); } if (!ptrNotifyWinEvent) return; // An event has to be associated with a window, // so find the first parent that is a widget and that has a WId QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(o); QWindow *window = iface ? window_helper(iface) : 0; if (!window) { window = QGuiApplication::activeWindow(); if (!window) return; } QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface(); HWND hWnd = (HWND)platform->nativeResourceForWindow("handle", window); if (reason != QAccessible::MenuCommand) { // MenuCommand is faked // See comment "SENDING EVENTS TO OBJECTS WITH NO WINDOW HANDLE" eventNum %= 50; //[0..49] int eventId = - eventNum - 1; qAccessibleRecentSentEvents()->insert(eventId, qMakePair(o, who)); ptrNotifyWinEvent(reason, hWnd, OBJID_CLIENT, eventId ); ++eventNum; } #endif // Q_WS_WINCE }
/** * Request the video to avoid the conflicts **/ bool VideoWidget::request( struct vout_window_t *p_wnd ) { if( stable ) { msg_Dbg( p_intf, "embedded video already in use" ); return false; } assert( !p_window ); /* The owner of the video window needs a stable handle (WinId). Reparenting * in Qt4-X11 changes the WinId of the widget, so we need to create another * dummy widget that stays within the reparentable widget. */ stable = new QWidget(); QPalette plt = palette(); plt.setColor( QPalette::Window, Qt::black ); stable->setPalette( plt ); stable->setAutoFillBackground(true); /* Force the widget to be native so that it gets a winId() */ stable->setAttribute( Qt::WA_NativeWindow, true ); /* Indicates that the widget wants to draw directly onto the screen. Widgets with this attribute set do not participate in composition management */ /* This is currently disabled on X11 as it does not seem to improve * performance, but causes the video widget to be transparent... */ #if !defined (QT5_HAS_X11) stable->setAttribute( Qt::WA_PaintOnScreen, true ); #else stable->setMouseTracking( true ); setMouseTracking( true ); #endif layout->addWidget( stable ); sync(); p_window = p_wnd; p_wnd->type = p_intf->p_sys->voutWindowType; switch( p_wnd->type ) { case VOUT_WINDOW_TYPE_XID: p_wnd->handle.xid = stable->winId(); p_wnd->display.x11 = NULL; break; case VOUT_WINDOW_TYPE_HWND: p_wnd->handle.hwnd = (void *)stable->winId(); break; case VOUT_WINDOW_TYPE_NSOBJECT: p_wnd->handle.nsobject = (void *)stable->winId(); break; #ifdef QT5_HAS_WAYLAND case VOUT_WINDOW_TYPE_WAYLAND: { QWindow *window = stable->windowHandle(); assert(window != NULL); window->create(); QPlatformNativeInterface *qni = qApp->platformNativeInterface(); assert(qni != NULL); p_wnd->handle.wl = static_cast<wl_surface*>( qni->nativeResourceForWindow(QByteArrayLiteral("surface"), window)); p_wnd->display.wl = static_cast<wl_display*>( qni->nativeResourceForIntegration(QByteArrayLiteral("wl_display"))); break; } #endif default: vlc_assert_unreachable(); } return true; }
void QWindowsAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event) { QString soundName; switch (event->type()) { case QAccessible::PopupMenuStart: soundName = QLatin1String("MenuPopup"); break; case QAccessible::MenuCommand: soundName = QLatin1String("MenuCommand"); break; case QAccessible::Alert: soundName = event->object()->inherits("QMessageBox") ? messageBoxAlertSound(event->object()) : QStringLiteral("SystemAsterisk"); break; default: break; } if (!soundName.isEmpty()) { #ifndef QT_NO_SETTINGS QSettings settings(QLatin1String("HKEY_CURRENT_USER\\AppEvents\\Schemes\\Apps\\.Default\\") + soundName, QSettings::NativeFormat); QString file = settings.value(QLatin1String(".Current/.")).toString(); #else QString file; #endif if (!file.isEmpty()) { PlaySound(reinterpret_cast<const wchar_t *>(soundName.utf16()), 0, SND_ALIAS | SND_ASYNC | SND_NODEFAULT | SND_NOWAIT); } } #if defined(Q_OS_WINCE) // ### TODO: check for NotifyWinEvent in CE 6.0 // There is no user32.lib nor NotifyWinEvent for CE return; #else // An event has to be associated with a window, // so find the first parent that is a widget and that has a WId QAccessibleInterface *iface = event->accessibleInterface(); if (!isActive() || !iface || !iface->isValid()) return; QWindow *window = QWindowsAccessibility::windowHelper(iface); if (!window) { window = QGuiApplication::focusWindow(); if (!window) return; } QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface(); if (!window->handle()) // Called before show(), no native window yet. return; HWND hWnd = (HWND)platform->nativeResourceForWindow("handle", window); if (event->type() != QAccessible::MenuCommand && // MenuCommand is faked event->type() != QAccessible::ObjectDestroyed) { ::NotifyWinEvent(event->type(), hWnd, OBJID_CLIENT, QAccessible::uniqueId(iface)); } #endif // Q_OS_WINCE }
void D3DPresentEngine::createOffscreenTexture() { // First, check if we have a context on this thread QOpenGLContext *currentContext = QOpenGLContext::currentContext(); if (!currentContext) { //Create OpenGL context and set share context from surface QOpenGLContext *shareContext = qobject_cast<QOpenGLContext*>(m_surface->property("GLContext").value<QObject*>()); if (!shareContext) return; m_offscreenSurface = new QWindow; m_offscreenSurface->setSurfaceType(QWindow::OpenGLSurface); //Needs geometry to be a valid surface, but size is not important m_offscreenSurface->setGeometry(-1, -1, 1, 1); m_offscreenSurface->create(); m_glContext = new QOpenGLContext; m_glContext->setFormat(m_offscreenSurface->requestedFormat()); m_glContext->setShareContext(shareContext); if (!m_glContext->create()) { delete m_glContext; delete m_offscreenSurface; m_glContext = 0; m_offscreenSurface = 0; return; } currentContext = m_glContext; } if (m_glContext) m_glContext->makeCurrent(m_offscreenSurface); if (!m_egl) m_egl = new EGLWrapper; QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface(); m_eglDisplay = static_cast<EGLDisplay*>( nativeInterface->nativeResourceForContext("eglDisplay", currentContext)); m_eglConfig = static_cast<EGLConfig*>( nativeInterface->nativeResourceForContext("eglConfig", currentContext)); currentContext->functions()->glGenTextures(1, &m_glTexture); int w = m_surfaceFormat.frameWidth(); int h = m_surfaceFormat.frameHeight(); bool hasAlpha = currentContext->format().hasAlpha(); EGLint attribs[] = { EGL_WIDTH, w, EGL_HEIGHT, h, EGL_TEXTURE_FORMAT, hasAlpha ? EGL_TEXTURE_RGBA : EGL_TEXTURE_RGB, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D, EGL_NONE }; EGLSurface pbuffer = m_egl->createPbufferSurface(m_eglDisplay, m_eglConfig, attribs); HANDLE share_handle = 0; PFNEGLQUERYSURFACEPOINTERANGLEPROC eglQuerySurfacePointerANGLE = reinterpret_cast<PFNEGLQUERYSURFACEPOINTERANGLEPROC>(m_egl->getProcAddress("eglQuerySurfacePointerANGLE")); Q_ASSERT(eglQuerySurfacePointerANGLE); eglQuerySurfacePointerANGLE( m_eglDisplay, pbuffer, EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE, &share_handle); m_device->CreateTexture(w, h, 1, D3DUSAGE_RENDERTARGET, hasAlpha ? D3DFMT_A8R8G8B8 : D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &m_texture, &share_handle); m_eglSurface = pbuffer; if (m_glContext) m_glContext->doneCurrent(); }
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext, const IntSize& size, GraphicsSurface::Flags flags) : m_context(0) , m_size(size) , m_frontBufferTexture(0) , m_frontBufferReadTexture(0) , m_backBufferTexture(0) , m_backBufferReadTexture(0) , m_readFbo(0) , m_drawFbo(0) { #if PLATFORM(QT) QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface(); CGLContextObj shareContextObject = static_cast<CGLContextObj>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("cglContextObj"), shareContext)); if (!shareContextObject) return; CGLPixelFormatObj pixelFormatObject = CGLGetPixelFormat(shareContextObject); if (kCGLNoError != CGLCreateContext(pixelFormatObject, shareContextObject, &m_context)) return; CGLRetainContext(m_context); #endif unsigned pixelFormat = 'BGRA'; unsigned bytesPerElement = 4; int width = m_size.width(); int height = m_size.height(); unsigned long bytesPerRow = IOSurfaceAlignProperty(kIOSurfaceBytesPerRow, width * bytesPerElement); if (!bytesPerRow) return; unsigned long allocSize = IOSurfaceAlignProperty(kIOSurfaceAllocSize, height * bytesPerRow); if (!allocSize) return; const void *keys[6]; const void *values[6]; keys[0] = kIOSurfaceWidth; values[0] = CFNumberCreate(0, kCFNumberIntType, &width); keys[1] = kIOSurfaceHeight; values[1] = CFNumberCreate(0, kCFNumberIntType, &height); keys[2] = kIOSurfacePixelFormat; values[2] = CFNumberCreate(0, kCFNumberIntType, &pixelFormat); keys[3] = kIOSurfaceBytesPerElement; values[3] = CFNumberCreate(0, kCFNumberIntType, &bytesPerElement); keys[4] = kIOSurfaceBytesPerRow; values[4] = CFNumberCreate(0, kCFNumberLongType, &bytesPerRow); keys[5] = kIOSurfaceAllocSize; values[5] = CFNumberCreate(0, kCFNumberLongType, &allocSize); CFDictionaryRef dict = CFDictionaryCreate(0, keys, values, 6, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); for (unsigned i = 0; i < 6; i++) CFRelease(values[i]); m_frontBuffer = IOSurfaceCreate(dict); m_backBuffer = IOSurfaceCreate(dict); if (!(flags & GraphicsSurface::SupportsSharing)) return; m_token = GraphicsSurfaceToken(IOSurfaceCreateMachPort(m_frontBuffer), IOSurfaceCreateMachPort(m_backBuffer)); }