static GLFWbool createSurface(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig)
{
window->wl.surface = wl_compositor_create_surface(_glfw.wl.compositor);
if (!window->wl.surface)
return GLFW_FALSE;
wl_surface_add_listener(window->wl.surface,
&surfaceListener,
window);
wl_surface_set_user_data(window->wl.surface, window);
window->wl.native = wl_egl_window_create(window->wl.surface,
wndconfig->width,
wndconfig->height);
if (!window->wl.native)
return GLFW_FALSE;
window->wl.width = wndconfig->width;
window->wl.height = wndconfig->height;
window->wl.scale = 1;
// TODO: make this optional once issue #197 is fixed.
setOpaqueRegion(window);
return GLFW_TRUE;
}
void WaylandCore::createWindow( int width, int height, const char* title )
{
if( mDisplay == NULL || mCompositor == NULL ) {
return;
}
mWidth = width;
mHeight = height;
static wl_shell_surface_listener shell_surf_listeners = {
shell_surface_handler_ping,
shell_surface_handler_configure,
shell_surface_handler_popup_done,
};
wl_surface* surface = wl_compositor_create_surface( mCompositor );
wl_shell_surface* shell_surface = wl_shell_get_shell_surface( mShell, surface );
wl_shell_surface_set_toplevel( shell_surface );
wl_shell_surface_set_title( shell_surface, title );
wl_shell_surface_add_listener( shell_surface, &shell_surf_listeners, this );
mShellSurface = shell_surface;
mSurface.surface = surface;
mEglWindow = wl_egl_window_create( surface, mWidth, mHeight );
mSurface.eglSurface = eglCreateWindowSurface( mEglDisplay, mEglConfig, mEglWindow, NULL );
if( !eglMakeCurrent( mEglDisplay, mSurface.eglSurface, mSurface.eglSurface, mEglContext ) ) {
fprintf( stderr, "MakeCurrent failed.\n" );
}
}
void create_surface(struct display *display)
{
EGLBoolean ret;
display->surface = wl_compositor_create_surface(display->compositor);
display->shell_surface = wl_shell_get_shell_surface(display->shell,
display->surface);
wl_shell_surface_add_listener(display->shell_surface,
&shell_surface_listener, display);
display->native = wl_egl_window_create(display->surface, 1, 1);
display->egl_surface =
eglCreateWindowSurface((EGLDisplay) display->egl.dpy, display->egl.conf, (EGLNativeWindowType) display->native, NULL);
wl_shell_surface_set_title(display->shell_surface, "projection");
ret = eglMakeCurrent(display->egl.dpy, display->egl_surface,
display->egl_surface, display->egl.ctx);
assert(ret == EGL_TRUE);
struct wl_callback *callback;
display->configured = 0;
wl_shell_surface_set_fullscreen(display->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
callback = wl_display_sync(display->display);
wl_callback_add_listener(callback, &configure_callback_listener, display);
}
static void egl_create_window(struct vo_wayland_state *wl)
{
wl->egl_context.egl_window = wl_egl_window_create(wl->window.video_surface,
wl->window.width,
wl->window.height);
wl->egl_context.egl_surface = eglCreateWindowSurface(wl->egl_context.egl.dpy,
wl->egl_context.egl.conf,
wl->egl_context.egl_window,
NULL);
eglMakeCurrent(wl->egl_context.egl.dpy,
wl->egl_context.egl_surface,
wl->egl_context.egl_surface,
wl->egl_context.egl.ctx);
wl_display_dispatch_pending(wl->display.display);
/**
* <http://lists.freedesktop.org/archives/wayland-devel/2013-November/012019.html>
*
* The main change is that if the swap interval is 0 then Mesa won't install a
* frame callback so that eglSwapBuffers can be executed as often as necessary.
* Instead it will do a sync request after the swap buffers. It will block for
* sync complete event in get_back_bo instead of the frame callback. The
* compositor is likely to send a release event while processing the new buffer
* attach and this makes sure we will receive that before deciding whether to
* allocate a new buffer.
*/
eglSwapInterval(wl->egl_context.egl.dpy, 0);
}
std::unique_ptr<WaylandSurface> PlatformDisplayWayland::createSurface(const IntSize& size)
{
struct wl_surface* wlSurface = wl_compositor_create_surface(m_compositor);
// We keep the minimum size at 1x1px since Mesa returns null values in wl_egl_window_create() for zero width or height.
EGLNativeWindowType nativeWindow = wl_egl_window_create(wlSurface, std::max(1, size.width()), std::max(1, size.height()));
return std::make_unique<WaylandSurface>(wlSurface, nativeWindow);
}
static GLFWbool createSurface(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig)
{
window->wl.surface = wl_compositor_create_surface(_glfw.wl.compositor);
if (!window->wl.surface)
return GLFW_FALSE;
wl_surface_set_user_data(window->wl.surface, window);
window->wl.native = wl_egl_window_create(window->wl.surface,
wndconfig->width,
wndconfig->height);
if (!window->wl.native)
return GLFW_FALSE;
window->wl.shell_surface = wl_shell_get_shell_surface(_glfw.wl.shell,
window->wl.surface);
if (!window->wl.shell_surface)
return GLFW_FALSE;
wl_shell_surface_add_listener(window->wl.shell_surface,
&shellSurfaceListener,
window);
window->wl.width = wndconfig->width;
window->wl.height = wndconfig->height;
return GLFW_TRUE;
}
static void
create_surface(struct window *window)
{
struct display *display = window->display;
EGLBoolean ret;
window->surface = wl_compositor_create_surface(display->compositor);
window->shell_surface = wl_shell_get_shell_surface(display->shell,
window->surface);
wl_shell_surface_add_listener(window->shell_surface,
&shell_surface_listener, window);
window->native =
wl_egl_window_create(window->surface,
window->window_size.width,
window->window_size.height);
window->egl_surface =
eglCreateWindowSurface(display->egl.dpy,
display->egl.conf,
window->native, NULL);
wl_shell_surface_set_title(window->shell_surface, "simple-egl");
ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
window->egl_surface, window->display->egl.ctx);
assert(ret == EGL_TRUE);
if (!window->frame_sync)
eglSwapInterval(display->egl.dpy, 0);
set_fullscreen(window, window->fullscreen);
}
static gboolean
create_surface (GstGLWindowWaylandEGL * window_egl)
{
window_egl->window.surface =
wl_compositor_create_surface (window_egl->display.compositor);
window_egl->window.shell_surface =
wl_shell_get_shell_surface (window_egl->display.shell,
window_egl->window.surface);
wl_shell_surface_add_listener (window_egl->window.shell_surface,
&shell_surface_listener, window_egl);
if (window_egl->window.window_width <= 0)
window_egl->window.window_width = 320;
if (window_egl->window.window_height <= 0)
window_egl->window.window_height = 240;
window_egl->window.native =
wl_egl_window_create (window_egl->window.surface,
window_egl->window.window_width, window_egl->window.window_height);
wl_shell_surface_set_title (window_egl->window.shell_surface,
"OpenGL Renderer");
wl_shell_surface_set_toplevel (window_egl->window.shell_surface);
return TRUE;
}
void WaylandWindow::init()
{
// mClient = WaylandClient::getInstance();
// mSurface = AndroidRuntime::getWaylandClient()->surface();//wl_compositor_create_surface(mClient->getCompositor());
mSurface = wl_compositor_create_surface(WaylandClient::getInstance().getCompositor());
// mShellSurface = AndroidRuntime::getWaylandClient()->shellSurface();// wl_shell_get_shell_surface(mClient->getShell(), mSurface);
mShellSurface = wl_shell_get_shell_surface(WaylandClient::getInstance().getShell(), mSurface);
if (mShellSurface) {
wl_shell_surface_add_listener(mShellSurface, &mShellSurfaceListener, this);
wl_shell_surface_set_toplevel(mShellSurface);
} else {
ALOGW("wl_shell_get_shell_surface FAILED \n");
return;
}
wl_surface_set_user_data(mSurface, this);
wl_shell_surface_set_title(mShellSurface, "android");
wl_surface_commit(mSurface);
mNative = wl_egl_window_create(mSurface, mWidth, mHeight);
if (mNative == NULL) {
ALOGW("wl_egl_window_create FAILED \n");
return;
} else {
ALOGW("wl_egl_window_create succeded, resulting in %p \n", mNative);
}
}
static void create_window()
{
egl_window = wl_egl_window_create(surface, 800, 600);
if (egl_window == EGL_NO_SURFACE) {
fprintf(stderr, "Can't create egl window\n");
exit(1);
} else {
fprintf(stderr, "Created egl window\n");
}
egl_surface = eglCreateWindowSurface(egl_display, egl_conf, egl_window, NULL);
if (eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context)) {
fprintf(stderr, "Made current\n");
} else {
fprintf(stderr, "Made current failed\n");
}
// begin to draw
// draw();
// if (eglSwapBuffers(egl_display, egl_surface)) {
// fprintf(stderr, "Swapped buffers\n");
// } else {
// fprintf(stderr, "Swapped buffers failed\n");
// }
}
bool WaylandEGLContext::create_context ()
{
int scale = gdk_window_get_scale_factor (gdk_window);
gdk_window_get_geometry (gdk_window, &x, &y, &width, &height);
EGLint surface_attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
EGL_RED_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_NONE
};
EGLint context_attribs[] = {
EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT,
EGL_NONE
};
EGLint num_configs = 0;
if (!subsurface)
return false;
egl_display = eglGetDisplay ((EGLNativeDisplayType) display);
eglInitialize (egl_display, NULL, NULL);
if (!eglChooseConfig (egl_display, surface_attribs, &egl_config, 1, &num_configs))
{
printf ("Couldn't find matching config.\n");
return false;
}
eglBindAPI (EGL_OPENGL_API);
egl_window = wl_egl_window_create (child, width * scale, height * scale);
if (!egl_window)
{
printf ("Couldn't create window.\n");
return false;
}
egl_surface = eglCreateWindowSurface (egl_display, egl_config, (EGLNativeWindowType) egl_window, NULL);
if (!egl_surface)
{
printf ("Couldn't create surface.\n");
return false;
}
egl_context = eglCreateContext (egl_display, egl_config, EGL_NO_CONTEXT, context_attribs);
if (!egl_context)
{
printf ("Couldn't create context.\n");
return false;
}
wl_surface_set_buffer_scale (child, scale);
gdk_window_invalidate_rect (gdk_window, NULL, FALSE);
return true;
}
static CoglBool
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
CoglError **error)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen;
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland_onscreen = g_slice_new0 (CoglOnscreenWayland);
egl_onscreen->platform = wayland_onscreen;
_cogl_list_init (&wayland_onscreen->frame_callbacks);
if (onscreen->foreign_surface)
wayland_onscreen->wayland_surface = onscreen->foreign_surface;
else
wayland_onscreen->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_onscreen->wayland_surface)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland surface for CoglOnscreen");
return FALSE;
}
wayland_onscreen->wayland_egl_native_window =
wl_egl_window_create (wayland_onscreen->wayland_surface,
cogl_framebuffer_get_width (framebuffer),
cogl_framebuffer_get_height (framebuffer));
if (!wayland_onscreen->wayland_egl_native_window)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland egl native window "
"for CoglOnscreen");
return FALSE;
}
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_config,
(EGLNativeWindowType)
wayland_onscreen->wayland_egl_native_window,
NULL);
if (!onscreen->foreign_surface)
wayland_onscreen->wayland_shell_surface =
wl_shell_get_shell_surface (wayland_renderer->wayland_shell,
wayland_onscreen->wayland_surface);
return TRUE;
}
static gboolean
_cogl_winsys_egl_context_created (CoglDisplay *display,
GError **error)
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display = egl_display->platform;
const char *error_message;
wayland_display->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_display->wayland_surface)
{
error_message= "Failed to create a dummy wayland surface";
goto fail;
}
wayland_display->wayland_egl_native_window =
wl_egl_window_create (wayland_display->wayland_surface,
1,
1);
if (!wayland_display->wayland_egl_native_window)
{
error_message= "Failed to create a dummy wayland native egl surface";
goto fail;
}
egl_display->dummy_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(EGLNativeWindowType)
wayland_display->wayland_egl_native_window,
NULL);
if (egl_display->dummy_surface == EGL_NO_SURFACE)
{
error_message= "Unable to eglMakeCurrent with dummy surface";
goto fail;
}
if (!eglMakeCurrent (egl_renderer->edpy,
egl_display->dummy_surface,
egl_display->dummy_surface,
egl_display->egl_context))
{
error_message = "Unable to eglMakeCurrent with dummy surface";
goto fail;
}
return TRUE;
fail:
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"%s", error_message);
return FALSE;
}
bool EglWaylandBackend::initRenderingContext()
{
initBufferConfigs();
#ifdef KWIN_HAVE_OPENGLES
const EGLint context_attribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
m_context = eglCreateContext(m_display, m_config, EGL_NO_CONTEXT, context_attribs);
#else
const EGLint context_attribs_31_core[] = {
EGL_CONTEXT_MAJOR_VERSION_KHR, 3,
EGL_CONTEXT_MINOR_VERSION_KHR, 1,
EGL_CONTEXT_FLAGS_KHR, EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR,
EGL_NONE
};
const EGLint context_attribs_legacy[] = {
EGL_NONE
};
const QByteArray eglExtensions = eglQueryString(m_display, EGL_EXTENSIONS);
const QList<QByteArray> extensions = eglExtensions.split(' ');
// Try to create a 3.1 core context
if (options->glCoreProfile() && extensions.contains("EGL_KHR_create_context"))
m_context = eglCreateContext(m_display, m_config, EGL_NO_CONTEXT, context_attribs_31_core);
if (m_context == EGL_NO_CONTEXT)
m_context = eglCreateContext(m_display, m_config, EGL_NO_CONTEXT, context_attribs_legacy);
#endif
if (m_context == EGL_NO_CONTEXT) {
qCritical() << "Create Context failed";
return false;
}
if (!m_wayland->surface()) {
return false;
}
const QSize &size = m_wayland->shellSurfaceSize();
m_overlay = wl_egl_window_create(m_wayland->surface(), size.width(), size.height());
if (!m_overlay) {
qCritical() << "Creating Wayland Egl window failed";
return false;
}
m_surface = eglCreateWindowSurface(m_display, m_config, m_overlay, NULL);
if (m_surface == EGL_NO_SURFACE) {
qCritical() << "Create Window Surface failed";
return false;
}
return makeContextCurrent();
}
bool
NativeStateWayland::create_window(WindowProperties const& properties)
{
struct my_output *output = 0;
if (!display_->outputs.empty()) output = display_->outputs.at(0);
window_ = new struct my_window();
window_->properties = properties;
window_->surface = wl_compositor_create_surface(display_->compositor);
if (window_->properties.fullscreen && output) {
window_->native = wl_egl_window_create(window_->surface,
output->width, output->height);
window_->properties.width = output->width;
window_->properties.height = output->height;
} else {
window_->native = wl_egl_window_create(window_->surface,
properties.width, properties.height);
}
window_->opaque_reqion = wl_compositor_create_region(display_->compositor);
wl_region_add(window_->opaque_reqion, 0, 0,
window_->properties.width,
window_->properties.height);
wl_surface_set_opaque_region(window_->surface, window_->opaque_reqion);
window_->shell_surface = wl_shell_get_shell_surface(display_->shell,
window_->surface);
if (window_->shell_surface) {
wl_shell_surface_add_listener(window_->shell_surface,
&shell_surface_listener_, this);
}
wl_shell_surface_set_title(window_->shell_surface, "glmark2");
if (window_->properties.fullscreen) {
wl_shell_surface_set_fullscreen(window_->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DRIVER,
output->refresh, output->output);
} else {
wl_shell_surface_set_toplevel(window_->shell_surface);
}
return true;
}
void GLESV2API::OnSetup(ViewSurface *surface) {
Destroy();
Display *display = Application::GetInstance()->GetDisplay();
p_->wl_egl_window = wl_egl_window_create(Proxy::GetWaylandSurface(surface), 400, 300);
p_->egl_surface = eglCreatePlatformWindowSurface(Display::Proxy::egl_display(display),
Display::Proxy::egl_config(display),
p_->wl_egl_window,
nullptr);
}
void Window::createEglSurface(EGLDisplay dpy, EGLConfig config)
{
#if HAVE_WAYLAND_EGL
const QSize size = window()->size();
m_eglWaylandWindow = wl_egl_window_create(*m_surface, size.width(), size.height());
if (!m_eglWaylandWindow) {
return;
}
m_eglSurface = eglCreateWindowSurface(dpy, config, m_eglWaylandWindow, nullptr);
#endif
}
void QWaylandEglWindow::newSurfaceCreated()
{
if (mWaylandEglWindow) {
wl_egl_window_destroy(mWaylandEglWindow);
}
wl_visual *visual = QWaylandScreen::waylandScreenFromWidget(widget())->visual();
QSize size = geometry().size();
if (!size.isValid())
size = QSize(0,0);
mWaylandEglWindow = wl_egl_window_create(mSurface,size.width(),size.height(),visual);
if (mGLContext) {
EGLNativeWindowType window(reinterpret_cast<EGLNativeWindowType>(mWaylandEglWindow));
EGLSurface surface = eglCreateWindowSurface(mEglIntegration->eglDisplay(),mGLContext->eglConfig(),window,NULL);
mGLContext->setEglSurface(surface);
}
}
static bool gfx_ctx_wl_set_video_mode(void *data,
unsigned width, unsigned height,
bool fullscreen)
{
EGLint egl_attribs[16];
EGLint *attr = NULL;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
egl_install_sighandlers();
attr = egl_fill_attribs(wl, egl_attribs);
wl->width = width ? width : DEFAULT_WINDOWED_WIDTH;
wl->height = height ? height : DEFAULT_WINDOWED_HEIGHT;
wl->surface = wl_compositor_create_surface(wl->compositor);
wl->win = wl_egl_window_create(wl->surface, wl->width, wl->height);
wl->shell_surf = wl_shell_get_shell_surface(wl->shell, wl->surface);
wl_shell_surface_add_listener(wl->shell_surf, &shell_surface_listener, NULL);
wl_shell_surface_set_toplevel(wl->shell_surf);
wl_shell_surface_set_class(wl->shell_surf, "RetroArch");
wl_shell_surface_set_title(wl->shell_surf, "RetroArch");
if (!egl_create_context(wl, (attr != egl_attribs) ? egl_attribs : NULL))
{
egl_report_error();
goto error;
}
if (!egl_create_surface(wl, (EGLNativeWindowType)wl->win))
goto error;
egl_set_swap_interval(wl, wl->egl.interval);
if (fullscreen)
wl_shell_surface_set_fullscreen(wl->shell_surf, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
flush_wayland_fd(wl);
return true;
error:
gfx_ctx_wl_destroy(data);
return false;
}
bool
WindowEGLImpl::CreateSurface()
{
struct wl_callback *callback;
EGLBoolean ret;
m_native = wl_egl_window_create(m_window->GetWlSurface(), m_window->GetWidth(), m_window->GetHeight());
m_eglSurface = eglCreateWindowSurface(m_egl.dpy, m_egl.cfg, m_native, NULL);
ret = eglMakeCurrent(m_egl.dpy, m_eglSurface, m_eglSurface, m_egl.ctx);
if (ret != EGL_TRUE)
return false;
callback = wl_display_sync(m_window->GetDisplay()->GetWlDisplay());
wl_callback_add_listener(callback, &configureListener, this);
return true;
}
static void
triangle_create_egl_surface(struct triangle *tri, int width, int height)
{
EGLBoolean ret;
tri->wl_surface = widget_get_wl_surface(tri->widget);
tri->egl_window = wl_egl_window_create(tri->wl_surface, width, height);
tri->egl_surface = eglCreateWindowSurface(tri->egl->dpy,
tri->egl->conf,
tri->egl_window, NULL);
ret = eglMakeCurrent(tri->egl->dpy, tri->egl_surface,
tri->egl_surface, tri->egl->ctx);
assert(ret == EGL_TRUE);
egl_make_swapbuffers_nonblock(tri->egl);
triangle_init_gl(&tri->gl);
}
static void egl_create_window(struct vo_wayland_state *wl)
{
wl->egl_context.egl_window = wl_egl_window_create(wl->window.video_surface,
wl->window.width,
wl->window.height);
wl->egl_context.egl_surface = eglCreateWindowSurface(wl->egl_context.egl.dpy,
wl->egl_context.egl.conf,
wl->egl_context.egl_window,
NULL);
eglMakeCurrent(wl->egl_context.egl.dpy,
wl->egl_context.egl_surface,
wl->egl_context.egl_surface,
wl->egl_context.egl.ctx);
wl_display_dispatch_pending(wl->display.display);
}
static void *
evgl_eng_native_window_create(void *data)
{
Render_Engine *re;
Outbuf *ob;
struct wl_egl_window *win;
if (!(re = (Render_Engine *)data)) return NULL;
if (!(ob = eng_get_ob(re))) return NULL;
if (!(win = wl_egl_window_create(ob->info->info.surface, 1, 1)))
{
ERR("Could not create wl_egl window: %m");
return NULL;
}
return (void *)win;
}
void *cWaylandInterface::CreateWindow(void)
{
GLWin.window_size.width = 640;
GLWin.window_size.height = 480;
GLWin.fullscreen = true;
GLWin.wl_surface = wl_compositor_create_surface(GLWin.wl_compositor);
GLWin.wl_shell_surface = wl_shell_get_shell_surface(GLWin.wl_shell,
GLWin.wl_surface);
wl_shell_surface_add_listener(GLWin.wl_shell_surface,
&shell_surface_listener, 0);
GLWin.wl_egl_native = wl_egl_window_create(GLWin.wl_surface,
GLWin.window_size.width,
GLWin.window_size.height);
return GLWin.wl_egl_native;
}
EGLSurface QWaylandEglWindow::eglSurface() const
{
if (!m_waylandEglWindow) {
const_cast<QWaylandEglWindow *>(this)->createDecoration();
QMargins margins = frameMargins();
QSize sizeWithMargins = geometry().size() + QSize(margins.left() + margins.right(), margins.top() + margins.bottom());
m_waylandEglWindow = wl_egl_window_create(mSurface, sizeWithMargins.width(), sizeWithMargins.height());
}
if (!m_eglSurface) {
m_eglConfig = q_configFromGLFormat(m_eglIntegration->eglDisplay(), window()->format(), true);
const_cast<QWaylandEglWindow *>(this)->m_format = q_glFormatFromConfig(m_eglIntegration->eglDisplay(),m_eglConfig);
EGLNativeWindowType window = (EGLNativeWindowType) m_waylandEglWindow;
m_eglSurface = eglCreateWindowSurface(m_eglIntegration->eglDisplay(), m_eglConfig, window, 0);
}
return m_eglSurface;
}
static void create_window (struct window *window, int32_t width, int32_t height) {
eglBindAPI (EGL_OPENGL_API);
EGLint attributes[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_NONE};
EGLConfig config;
EGLint num_config;
eglChooseConfig (egl_display, attributes, &config, 1, &num_config);
window->egl_context = eglCreateContext (egl_display, config, EGL_NO_CONTEXT, NULL);
window->surface = wl_compositor_create_surface (compositor);
window->shell_surface = wl_shell_get_shell_surface (shell, window->surface);
wl_shell_surface_add_listener (window->shell_surface, &shell_surface_listener, window);
wl_shell_surface_set_toplevel (window->shell_surface);
window->egl_window = wl_egl_window_create (window->surface, width, height);
window->egl_surface = eglCreateWindowSurface (egl_display, config, window->egl_window, NULL);
eglMakeCurrent (egl_display, window->egl_surface, window->egl_surface, window->egl_context);
}
void QWaylandEglWindow::redraw()
{
createDecoration();
QMargins margins = frameMargins();
QSize sizeWithMargins = geometry().size() + QSize(margins.left() + margins.right(), margins.top() + margins.bottom());
if (m_waylandEglWindow) {
int current_width, current_height;
wl_egl_window_get_attached_size(m_waylandEglWindow,¤t_width,¤t_height);
if (current_width != sizeWithMargins.width() || current_height != sizeWithMargins.height()) {
waitForFrameSync();
wl_egl_window_resize(m_waylandEglWindow, sizeWithMargins.width(), sizeWithMargins.height(), mOffset.x(), mOffset.y());
mOffset = QPoint();
m_resize = true;
}
} else {
m_waylandEglWindow = wl_egl_window_create(mSurface, sizeWithMargins.width(), sizeWithMargins.height());
}
}
std::unique_ptr<GLContextEGL> PlatformDisplayWayland::createOffscreenContext(GLContext* sharingContext)
{
class OffscreenContextData : public GLContext::Data {
public:
virtual ~OffscreenContextData()
{
wl_egl_window_destroy(nativeWindow);
wl_surface_destroy(surface);
}
struct wl_surface* surface;
EGLNativeWindowType nativeWindow;
};
auto contextData = std::make_unique<OffscreenContextData>();
contextData->surface = wl_compositor_create_surface(m_compositor);
contextData->nativeWindow = wl_egl_window_create(contextData->surface, 1, 1);
auto nativeWindow = contextData->nativeWindow;
return GLContextEGL::createWindowContext(nativeWindow, nullptr, WTF::move(contextData));
}
static void egl_create_window(struct vo_wayland_state *wl,
struct egl_context *egl_ctx,
uint32_t width,
uint32_t height)
{
egl_ctx->egl_window = wl_egl_window_create(wl->window->surface,
wl->window->width,
wl->window->height);
egl_ctx->egl_surface = eglCreateWindowSurface(egl_ctx->egl.dpy,
egl_ctx->egl.conf,
egl_ctx->egl_window,
NULL);
eglMakeCurrent(egl_ctx->egl.dpy,
egl_ctx->egl_surface,
egl_ctx->egl_surface,
egl_ctx->egl.ctx);
wl_display_dispatch_pending(wl->display->display);
}
EGLNativeWindowType createSubWindow(FBNativeWindowType p_window,
EGLNativeDisplayType display,
int x, int y,int width, int height) {
/* krnlyng */
printf("creating sub window\n");
#ifndef X11
if(get_server_references(display) < 0) return NULL;
surface = wl_compositor_create_surface(compositor);
if(surface == NULL)
{
fprintf(stderr, "Cannot create wl surface\n");
return NULL;
}
shell_surface = wl_shell_get_shell_surface(shell, surface);
wl_shell_surface_set_toplevel(shell_surface);
create_opaque_region(width, height);
EGLNativeWindowType win = wl_egl_window_create(surface, width, height);
if(win == EGL_NO_SURFACE || win == NULL)
{
fprintf(stderr, "wl_egl_window_create failed\n");
}
printf("created sub window\n");
return win;
#else
XSetWindowAttributes wa;
wa.event_mask = StructureNotifyMask;
Window win = XCreateWindow(display,p_window,x,y, width,height,0,CopyFromParent,CopyFromParent,CopyFromParent,CWEventMask,&wa);
XMapWindow(display,win);
XEvent e;
XIfEvent(display, &e, WaitForMapNotify, (char *)win);
return win;
#endif
}
