wxPaletteRefData::~wxPaletteRefData() { Display *display = (Display*) NULL; wxList::compatibility_iterator node, next; for (node = m_palettes.GetFirst(); node; node = next) { wxXPalette *c = (wxXPalette *)node->GetData(); unsigned long *pix_array = c->m_pix_array; Colormap cmap = (Colormap) c->m_cmap; bool destroyable = c->m_destroyable; int pix_array_n = c->m_pix_array_n; display = (Display*) c->m_display; if (pix_array_n > 0) { // XFreeColors(display, cmap, pix_array, pix_array_n, 0); // Be careful not to free '0' pixels... int i, j; for(i=j=0; i<pix_array_n; i=j) { while(j<pix_array_n && pix_array[j]!=0) j++; if(j > i) XFreeColors(display, cmap, &pix_array[i], j-i, 0); while(j<pix_array_n && pix_array[j]==0) j++; } delete [] pix_array; } if (destroyable) XFreeColormap(display, cmap); next = node->GetNext(); m_palettes.Erase(node); delete c; } }
void XmuDeleteStandardColormap(Display *dpy, int screen, Atom property) /* dpy; - specifies the X server to connect to * screen - specifies the screen of the display * property - specifies the standard colormap property */ { XStandardColormap *stdcmaps, *s; int count = 0; if (XGetRGBColormaps(dpy, RootWindow(dpy, screen), &stdcmaps, &count, property)) { for (s=stdcmaps; count > 0; count--, s++) { if ((s->killid == ReleaseByFreeingColormap) && (s->colormap != None) && (s->colormap != DefaultColormap(dpy, screen))) XFreeColormap(dpy, s->colormap); else if (s->killid != None) XKillClient(dpy, s->killid); } XDeleteProperty(dpy, RootWindow(dpy, screen), property); XFree((char *) stdcmaps); XSync(dpy, False); } }
MyWindow::~MyWindow() { #ifdef WIN32 // CURSORINFO cursorInfo; cursorInfo.cbSize=sizeof(CURSORINFO); if(GetCursorInfo(&cursorInfo) && cursorInfo.flags==0) { ShowCursor(TRUE); } // wglMakeCurrent(NULL,NULL); wglDeleteContext(hglrc); CloseWindow(hWnd); HINSTANCE hInstance=GetModuleHandle(0); #ifdef UNICODE UnregisterClass(L"win32app",hInstance); #else UnregisterClass("win32app",hInstance); #endif #endif #ifdef LINUX glXMakeCurrent(display,0,0); glXDestroyContext(display,ctx); XDestroyWindow(display,win); XFreeColormap(display,cmap); XCloseDisplay(display); #endif }
void OpenGLGraphicDeviceLinux::Close( ) { // Destroy the OpenGL context if( m_pRenderOutput && m_DeviceContext ) { // Release the context from this thread if( !glXMakeCurrent( XOpenDisplay( NULL ), 0, 0 ) ) { std::cout << "[OpenGLGraphicDeviceLinux::Close] Can release the OpenGL context.\n"; return; } glXDestroyContext( XOpenDisplay( NULL ), m_DeviceContext ); m_DeviceContext = NULL; } // Free the color map if( m_Colormap ) { XFreeColormap( XOpenDisplay( NULL ), m_Colormap ); } m_Open = false; m_Version = Version( 0, 0, 0 ); m_DeviceContext = NULL; }
void xf86_dga2_close_display(void) { if(xf86ctx.device) { XFree(xf86ctx.device); xf86ctx.device = 0; } if(xf86ctx.modes) { XFree(xf86ctx.modes); xf86ctx.modes = 0; } if(xf86ctx.cmap) { XFreeColormap(display,xf86ctx.cmap); xf86ctx.cmap = 0; } sysdep_display_effect_close(); xinput_close(); if(xf86ctx.current_mode != -1) { /* HDG: is this really nescesarry ? */ XDGASync(display,xf86ctx.screen); #ifdef TDFX_DGA_WORKAROUND /* Restore the right video mode before leaving DGA */ /* The tdfx driver would have to do it, but it doesn't work ...*/ XDGASetMode(display, xf86ctx.screen, xf86ctx.current_X11_mode); #endif XDGASetMode(display, xf86ctx.screen, 0); xf86ctx.current_mode = -1; } XSync(display, True); }
/* * Class: jogamp_nativewindow_x11_X11Lib * Method: DestroyWindow * Signature: (JJ)V */ JNIEXPORT void JNICALL Java_jogamp_nativewindow_x11_X11Lib_DestroyWindow (JNIEnv *env, jclass unused, jlong display, jlong window) { Display * dpy = (Display *)(intptr_t)display; Window w = (Window) window; XWindowAttributes xwa; if(NULL==dpy) { NativewindowCommon_throwNewRuntimeException(env, "invalid display connection.."); return; } NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 1, errorHandlerQuiet, 0); XSync(dpy, False); memset(&xwa, 0, sizeof(XWindowAttributes)); XGetWindowAttributes(dpy, w, &xwa); // prefetch colormap to be destroyed after window destruction XSelectInput(dpy, w, 0); XUnmapWindow(dpy, w); XSync(dpy, False); XDestroyWindow(dpy, w); if( None != xwa.colormap ) { XFreeColormap(dpy, xwa.colormap); } // NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 0, errorHandlerQuiet, 1); }
void clean_x() { glXMakeCurrent(display, None, NULL); glXDestroyContext(display, ctx); XDestroyWindow(display, win); XFreeColormap(display, cmap); XCloseDisplay(display); }
void GLcleanup() { CleanupTextureStore(); // bye textures #ifdef _WINDOWS wglMakeCurrent(NULL, NULL); // bye context if(GLCONTEXT) wglDeleteContext(GLCONTEXT); if(!bWindowMode && dcGlobal) ReleaseDC(hWWindow,dcGlobal); #endif eglMakeCurrent( display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT ); eglDestroySurface( display, surface ); eglDestroyContext( display, context ); eglTerminate( display ); #if defined(USE_X11) if (pandora_driver_mode == MODE_X11) { if (x11Window) XDestroyWindow(x11Display, x11Window); if (x11Colormap) XFreeColormap( x11Display, x11Colormap ); if (x11Display) XCloseDisplay(x11Display); } #endif }
WindowDevice::~WindowDevice() { numWindowDevice--; #ifdef _UNIX if (winOpen == 0) { // we must close the old window XFreeGC(theDisplay, theGC); XDestroyWindow(theDisplay, theWindow); } if (numWindowDevice == 0) { if (colorFlag == 0 ) XFreeColors(theDisplay, cmap, pixels, 256, 0); else if (colorFlag == 1) XFreeColors(theDisplay, cmap, pixels, 192, 0); else if (colorFlag == 2) XFreeColors(theDisplay, cmap, pixels, 64, 0); XFreeColormap(theDisplay, cmap); XCloseDisplay(theDisplay); } #else if (winOpen == 0) { // we must close the window oglDestroyWindow(title,theWND, theHRC, theHDC); } #endif }
void _glfwPlatformDestroyWindow(_GLFWwindow* window) { if (window->monitor) leaveFullscreenMode(window); _glfwDestroyContext(window); if (window->x11.handle) { if (window->x11.handle == XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD)) { _glfwPushSelectionToManager(window); } XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context); XUnmapWindow(_glfw.x11.display, window->x11.handle); XDestroyWindow(_glfw.x11.display, window->x11.handle); window->x11.handle = (Window) 0; } if (window->x11.colormap) { XFreeColormap(_glfw.x11.display, window->x11.colormap); window->x11.colormap = (Colormap) 0; } }
void wireframeDelete (WireFrame *wireframe) { ScreenInfo *screen_info; g_return_if_fail (wireframe != None); TRACE ("entering"); screen_info = wireframe->screen_info; XUnmapWindow (myScreenGetXDisplay (screen_info), wireframe->xwindow); if (wireframe->cr) { cairo_destroy (wireframe->cr); } if (wireframe->surface) { cairo_surface_destroy (wireframe->surface); } if (wireframe->xcolormap != screen_info->cmap) { XFreeColormap (myScreenGetXDisplay (screen_info), wireframe->xcolormap); } XDestroyWindow (myScreenGetXDisplay (screen_info), wireframe->xwindow); g_free (wireframe); }
void printAndReleaseResources(Display *display, GLXFBConfig *fbConfigList, XVisualInfo *visualInfo, Window win, GLXContext ctx, Colormap cmap, const char *message) { if (message != NULL) { fprintf(stderr, "%s\n", message); } if (display == NULL) { return; } glXMakeCurrent(display, None, NULL); if (fbConfigList != NULL) { XFree(fbConfigList); } if (visualInfo != NULL) { XFree(visualInfo); } if (ctx != NULL) { glXDestroyContext(display, ctx); } if (win != None) { XDestroyWindow(display, win); } if (cmap != None) { XFreeColormap(display, cmap); } }
XWindow::~XWindow() { this->m_pGraphicsContext.reset(); XDestroyWindow(display, window); XFreeColormap(display, cmap); XCloseDisplay(display); }
X11Win::~X11Win(void) { glXDestroyWindow(_d, _glxWin); glXMakeCurrent(_d, 0, 0); glXDestroyContext(_d, _ctx); XDestroyWindow(_d, _w); XFreeColormap(_d, _cmap); XCloseDisplay(_d); }
void cXInterface::DestroyWindow(void) { XDestroyWindow(GLWin.evdpy, GLWin.win); GLWin.win = 0; if (GLWin.xEventThread.joinable()) GLWin.xEventThread.join(); XFreeColormap(GLWin.evdpy, GLWin.attr.colormap); }
void cX11Window::DestroyXWindow(void) { XUnmapWindow(dpy, win); win = 0; if (xEventThread.joinable()) xEventThread.join(); XFreeColormap(dpy, colormap); }
void x11_colormap_destroy(void) { if (!g_x11_cmap) return; XFreeColormap(g_x11_dpy, g_x11_cmap); g_x11_cmap = None; }
Window::~Window() noexcept { auto display = application_->display_; XDeleteContext(display, id_, application_->context_); glXDestroyContext(display, context_); XDestroyWindow(display, id_); XFreeColormap(display, colormap_); }
static void DestroyContext(GLContext* ctx) { if (NULL != ctx->dpy && NULL != ctx->ctx) glXDestroyContext(ctx->dpy, ctx->ctx); if (NULL != ctx->dpy && 0 != ctx->wnd) XDestroyWindow(ctx->dpy, ctx->wnd); if (NULL != ctx->dpy && 0 != ctx->cmap) XFreeColormap(ctx->dpy, ctx->cmap); if (NULL != ctx->vi) XFree(ctx->vi); if (NULL != ctx->dpy) XCloseDisplay(ctx->dpy); }
void cX11Window::DestroyXWindow(void) { XUnmapWindow(GLWin.evdpy, GLWin.win); GLWin.win = 0; if (GLWin.xEventThread.joinable()) GLWin.xEventThread.join(); XFreeColormap(GLWin.evdpy, GLWin.attr.colormap); }
static void destroyWindow(JNIEnv *env, Display *disp, Window window) { if (glx_window != None) { lwjgl_glXDestroyWindow(disp, glx_window); glx_window = None; } XDestroyWindow(disp, window); XFreeColormap(disp, cmap); }
void deleteGLContext() { glXMakeCurrent(display, 0, 0); glXDestroyContext(display, ctx); XDestroyWindow(display, win); XFreeColormap(display, cmap); XCloseDisplay(display); }
static Window createWindow(JNIEnv* env, Display *disp, int screen, jint window_mode, X11PeerInfo *peer_info, int x, int y, int width, int height, jboolean undecorated, long parent_handle, jboolean resizable) { Window parent = (Window)parent_handle; Window win; XSetWindowAttributes attribs; unsigned int attribmask; XVisualInfo vis_info; if ( !XMatchVisualInfo(disp, screen, DefaultDepth(disp, screen), TrueColor, &vis_info) ) { throwException(env, "Failed to acquire X visual."); return false; } cmap = XCreateColormap(disp, parent, vis_info.visual, AllocNone); if (!checkXError(env, disp)) { return false; } attribs.colormap = cmap; attribs.border_pixel = 0; attribs.event_mask = ExposureMask | FocusChangeMask | VisibilityChangeMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask; attribmask = CWColormap | CWEventMask | CWBorderPixel | CWBackPixel; if (isLegacyFullscreen(window_mode)) { attribmask |= CWOverrideRedirect; attribs.override_redirect = True; } win = XCreateWindow(disp, parent, x, y, width, height, 0, vis_info.depth, InputOutput, vis_info.visual, attribmask, &attribs); current_depth = vis_info.depth; current_visual = vis_info.visual; if (!checkXError(env, disp)) { XFreeColormap(disp, cmap); return false; } if (undecorated) { // Use Motif decoration hint property and hope the window manager respects them setDecorations(disp, win, 0); } if (RootWindow(disp, screen) == parent_handle) { // only set hints when Display.setParent isn't used updateWindowBounds(disp, win, x, y, width, height, JNI_TRUE, resizable); updateWindowHints(env, disp, win); } #define NUM_ATOMS 1 Atom protocol_atoms[NUM_ATOMS] = {XInternAtom(disp, "WM_DELETE_WINDOW", False)/*, XInternAtom(disp, "WM_TAKE_FOCUS", False)*/}; XSetWMProtocols(disp, win, protocol_atoms, NUM_ATOMS); if (window_mode == org_lwjgl_opengl_LinuxDisplay_FULLSCREEN_NETWM) { Atom fullscreen_atom = XInternAtom(disp, "_NET_WM_STATE_FULLSCREEN", False); XChangeProperty(disp, win, XInternAtom(disp, "_NET_WM_STATE", False), XInternAtom(disp, "ATOM", False), 32, PropModeReplace, (const unsigned char*)&fullscreen_atom, 1); } if (!checkXError(env, disp)) { destroyWindow(env, disp, win); return 0; } return win; }
void X11Terminate() { glXMakeCurrent( display, 0, 0 ); glXDestroyContext( display, ctx ); XDestroyWindow( display, win ); XFreeColormap( display, cmap ); XCloseDisplay( display ); }
void deInitX11(void) { if (x11Window) XDestroyWindow(x11Display, x11Window); if (x11Colormap) XFreeColormap(x11Display, x11Colormap); if (x11Display) XCloseDisplay(x11Display); }
void OglDestroyWindow(void){ if (gameStates.ogl.bInitialized){ glXDestroyContext(dpy,glxcontext); XDestroyWindow(dpy,win); XFreeColormap(dpy,swa.colormap); gameStates.ogl.bInitialized=0; } return; }
static void gfx_ctx_destroy(void) { if (g_dpy && g_ctx) { glXMakeContextCurrent(g_dpy, None, None, NULL); glXDestroyContext(g_dpy, g_ctx); g_ctx = NULL; } if (g_win) { glXDestroyWindow(g_dpy, g_glx_win); g_glx_win = 0; // Save last used monitor for later. #ifdef HAVE_XINERAMA XWindowAttributes target; Window child; int x = 0, y = 0; XGetWindowAttributes(g_dpy, g_win, &target); XTranslateCoordinates(g_dpy, g_win, DefaultRootWindow(g_dpy), target.x, target.y, &x, &y, &child); g_screen = x11_get_xinerama_monitor(g_dpy, x, y, target.width, target.height); RARCH_LOG("[GLX]: Saved monitor #%u.\n", g_screen); #endif XUnmapWindow(g_dpy, g_win); XDestroyWindow(g_dpy, g_win); g_win = None; } if (g_cmap) { XFreeColormap(g_dpy, g_cmap); g_cmap = None; } if (g_should_reset_mode) { x11_exit_fullscreen(g_dpy, &g_desktop_mode); g_should_reset_mode = false; } if (g_dpy) { XCloseDisplay(g_dpy); g_dpy = NULL; } g_inited = false; g_pglSwapInterval = NULL; }
///////////////////////////////////////////////////////// // destroy window // ///////////////////////////////////////////////////////// void gemglxwindow :: destroy(void) { /* both glXMakeCurrent() and XCloseDisplay() will crash the application * if the handler of the display (m_pimpl->dpy) is invalid, e.g. because * somebody closed the Gem-window with xkill or by clicking on the "x" of the window */ if (m_pimpl->dpy) { int err=0; #ifdef HAVE_LIBXXF86VM if (m_pimpl->fs) { XF86VidModeSwitchToMode(m_pimpl->dpy, m_pimpl->screen, &m_pimpl->deskMode); XF86VidModeSetViewPort(m_pimpl->dpy, m_pimpl->screen, 0, 0); m_pimpl->fs=0; } #endif /* patch by cesare marilungo to prevent the crash "on my laptop" */ glXMakeCurrent(m_pimpl->dpy, None, NULL); /* this crashes if no window is there! */ if (m_pimpl->glxcontext) { // this crashes sometimes on my laptop: glXDestroyContext(m_pimpl->dpy, m_pimpl->glxcontext); } if (m_pimpl->win) { XUnmapWindow (m_pimpl->dpy, m_pimpl->win); err=XDestroyWindow(m_pimpl->dpy, m_pimpl->win); if(err) { verbose(1, "XDestroyWindow returned %d", err); } } if (m_pimpl->cmap) { err=XFreeColormap(m_pimpl->dpy, m_pimpl->cmap); if(err) { verbose(1, "XFreeColormap returned %d", err); } } XFlush( m_pimpl->dpy ); err=XCloseDisplay(m_pimpl->dpy); /* this crashes if no window is there */ if(err) { verbose(1, "XCloseDisplay returned %d", err); } } m_pimpl->dpy = NULL; m_pimpl->win = 0; m_pimpl->cmap = 0; m_pimpl->glxcontext = NULL; if(m_pimpl->delete_atom) { m_pimpl->delete_atom=None; /* not very sophisticated destruction...*/ } destroyGemWindow(); }
void window_destroy() { glXMakeCurrent(windowData.display,0,0); glXDestroyContext(windowData.display,windowData.ctx); //todo destroy blank cursor //todo destroy xi XDestroyWindow(windowData.display,windowData.win); XFreeColormap(windowData.display,windowData.cmap); XCloseDisplay(windowData.display); }
void glewDestroyContext () { if (NULL != dpy && NULL != ctx) glXDestroyContext(dpy, ctx); if (NULL != dpy && 0 != wnd) XDestroyWindow(dpy, wnd); if (NULL != dpy && 0 != cmap) XFreeColormap(dpy, cmap); if (NULL != vis) XFree(vis); else if (NULL != vi) XFree(vi); if (NULL != dpy) XCloseDisplay(dpy); }