void TopWindow::GuiPlatformConstruct() { size_hints = XAllocSizeHints(); wm_hints = XAllocWMHints(); class_hint = XAllocClassHint(); topmost = false; }
/* Returns a pointer to the profile of the currently selected * window, or defaultProfile if there is no specific profile for it or the window is invalid. */ char* getWindowClass(Window w) { char * result = NULL; if (w != None) { XClassHint* classHint = XAllocClassHint(); /* Read WM_CLASS member */ if (XGetClassHint(display, w, classHint)) { if(classHint->res_class != NULL) { result = malloc((strlen(classHint->res_name) + 1) * sizeof(char)); if(result != NULL) { strcpy(result, classHint->res_name); } XFree(classHint->res_class); } if(classHint->res_name != NULL) XFree(classHint->res_name); XFree(classHint); } } return result; }
/** * @brief Set basic properties on a window. */ void wm_wid_set_info(session_t *ps, Window wid, const char *name, Atom window_type) { // Set window name { char *textcpy = mstrjoin("skippy-xd ", name); { XTextProperty text_prop = { }; if (Success == XmbTextListToTextProperty(ps->dpy, &textcpy, 1, XStdICCTextStyle, &text_prop)) XSetWMName(ps->dpy, wid, &text_prop); sxfree(text_prop.value); } wm_wid_set_prop_utf8(ps, wid, _NET_WM_NAME, textcpy); free(textcpy); } // Set window class { XClassHint *classh = allocchk(XAllocClassHint()); classh->res_name = "skippy-xd"; classh->res_class = "skippy-xd"; XSetClassHint(ps->dpy, wid, classh); XFree(classh); } // Set window type { if (!window_type) window_type = _NET_WM_WINDOW_TYPE_NORMAL; long val = window_type; XChangeProperty(ps->dpy, wid, _NET_WM_WINDOW_TYPE, XA_ATOM, 32, PropModeReplace, (unsigned char *) &val, 1); } }
static void xdpy_set_window_title_default(ALLEGRO_DISPLAY *display, const char *title) { ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)display; { Atom WM_NAME = XInternAtom(system->x11display, "WM_NAME", False); Atom _NET_WM_NAME = XInternAtom(system->x11display, "_NET_WM_NAME", False); char *list[1] = { (char *) title }; XTextProperty property; Xutf8TextListToTextProperty(system->x11display, list, 1, XUTF8StringStyle, &property); XSetTextProperty(system->x11display, glx->window, &property, WM_NAME); XSetTextProperty(system->x11display, glx->window, &property, _NET_WM_NAME); XSetTextProperty(system->x11display, glx->window, &property, XA_WM_NAME); XFree(property.value); } { XClassHint *hint = XAllocClassHint(); if (hint) { ALLEGRO_PATH *exepath = al_get_standard_path(ALLEGRO_EXENAME_PATH); // hint doesn't use a const char*, so we use strdup to create a non const string hint->res_name = strdup(al_get_path_basename(exepath)); hint->res_class = strdup(al_get_path_basename(exepath)); XSetClassHint(system->x11display, glx->window, hint); free(hint->res_name); free(hint->res_class); XFree(hint); al_destroy_path(exepath); } } }
static void InternalLinkScreenAndGo( const char * WindowName ) { XGetWindowAttributes( CNFGDisplay, CNFGWindow, &CNFGWinAtt ); XGetClassHint( CNFGDisplay, CNFGWindow, CNFGClassHint ); if (!CNFGClassHint) { CNFGClassHint = XAllocClassHint(); if (CNFGClassHint) { CNFGClassHint->res_name = "cnping"; CNFGClassHint->res_class = "cnping"; XSetClassHint( CNFGDisplay, CNFGWindow, CNFGClassHint ); } else { fprintf( stderr, "Failed to allocate XClassHint!\n" ); } } else { fprintf( stderr, "Pre-existing XClassHint\n" ); } XSelectInput (CNFGDisplay, CNFGWindow, KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | PointerMotionMask ); XSetStandardProperties( CNFGDisplay, CNFGWindow, WindowName, WindowName, None, NULL, 0, NULL ); CNFGWindowGC = XCreateGC(CNFGDisplay, CNFGWindow, 0, 0); CNFGPixmap = XCreatePixmap( CNFGDisplay, CNFGWindow, CNFGWinAtt.width, CNFGWinAtt.height, CNFGWinAtt.depth ); CNFGGC = XCreateGC(CNFGDisplay, CNFGPixmap, 0, 0); }
QString GestureHandler::getAppClass(Window window) const { XClassHint *classHint = XAllocClassHint(); XGetClassHint(QX11Info::display(), window, classHint); QString ret = classHint->res_class; XFree(classHint->res_class); XFree(classHint->res_name); return ret; }
static void set_wm_class(void) { XClassHint *classhint = XAllocClassHint(); classhint->res_name = (char *)"jgmenu"; classhint->res_class = (char *)"jgmenu"; XSetClassHint(ui->dpy, ui->w[ui->cur].win, classhint); XFree(classhint); }
XClassHint * count_xallocclasshint(const char *fname, int line) { XClassHint *wmclass ; wmclass = XAllocClassHint(); if( wmclass != NULL ) count_alloc (fname, line, (void *)wmclass, sizeof(XClassHint), C_XMEM | C_XALLOCCLASSHINT ); return wmclass; }
bool X11Helper::MakeWindow( Window &win, int screenNum, int depth, Visual *visual, int width, int height, bool overrideRedirect ) { if( !Dpy ) return false; XSetWindowAttributes winAttribs; winAttribs.border_pixel = 0; winAttribs.event_mask = 0L; if( win ) { // Preserve the event mask. XWindowAttributes attribs; XGetWindowAttributes( Dpy, win, &attribs ); winAttribs.event_mask = attribs.your_event_mask; XDestroyWindow( Dpy, win ); } // XXX: Error catching/handling? winAttribs.colormap = XCreateColormap( Dpy, RootWindow(Dpy, screenNum), visual, AllocNone ); unsigned long mask = CWBorderPixel | CWColormap | CWEventMask; if( overrideRedirect ) { winAttribs.override_redirect = True; mask |= CWOverrideRedirect; } win = XCreateWindow( Dpy, RootWindow(Dpy, screenNum), 0, 0, width, height, 0, depth, InputOutput, visual, mask, &winAttribs ); if( win == None ) return false; XClassHint *hint = XAllocClassHint(); if ( hint == nullptr ) { LOG->Warn("Could not set class hint for X11 Window"); } else { hint->res_name = (char*)g_XWMName.Get().c_str(); hint->res_class = (char*)PRODUCT_FAMILY; XSetClassHint(Dpy, win, hint); XFree(hint); } // Hide the mouse cursor in certain situations. if( !PREFSMAN->m_bShowMouseCursor ) { const char pBlank[] = { 0,0,0,0,0,0,0,0 }; Pixmap BlankBitmap = XCreateBitmapFromData( Dpy, win, pBlank, 8, 8 ); XColor black = { 0, 0, 0, 0, 0, 0 }; Cursor pBlankPointer = XCreatePixmapCursor( Dpy, BlankBitmap, BlankBitmap, &black, &black, 0, 0 ); XFreePixmap( Dpy, BlankBitmap ); XDefineCursor( Dpy, win, pBlankPointer ); XFreeCursor( Dpy, pBlankPointer ); } return true; }
static void setClassHint(Display *disp, Window window, jlong wm_name, jlong wm_class) { XClassHint* hint = XAllocClassHint(); hint->res_name = (char *)(intptr_t)wm_name; hint->res_class = (char *)(intptr_t)wm_class; XSetClassHint(disp, window, hint); XFree(hint); }
static void set_class_hint(Display *p_display, Window p_window) { XClassHint *classHint; /* set the name and class hints for the window manager to use */ classHint = XAllocClassHint(); if (classHint) { classHint->res_name = (char *)"Godot_Engine"; classHint->res_class = (char *)"Godot"; } XSetClassHint(p_display, p_window, classHint); XFree(classHint); }
void x_window_rep::set_hints (int min_w, int min_h, int max_w, int max_h) { XSizeHints* size_hints; XWMHints* wm_hints; XClassHint* class_hints; ASSERT (size_hints= XAllocSizeHints (), "out of memory (X server)"); ASSERT (wm_hints= XAllocWMHints (), "out of memory (X server)"); ASSERT (class_hints= XAllocClassHint (), "out of memory (X server)"); XTextProperty Window_Name; XTextProperty Icon_Name; ASSERT (XStringListToTextProperty (&name, 1, &Window_Name) != 0, "out of memory (X server)"); ASSERT (XStringListToTextProperty (&name, 1, &Icon_Name) != 0, "out of memory (X server)"); // time_t start_1= texmacs_time (); Pixmap pm= retrieve_pixmap (load_xpm ("TeXmacs.xpm")); // cout << "Getting pixmap required " << (texmacs_time ()-start_1) << " ms\n"; // time_t start_2= texmacs_time (); size_hints->flags = PPosition | PSize | PMinSize | PMaxSize; size_hints->min_width = min_w; size_hints->min_height = min_h; size_hints->max_width = max_w; size_hints->max_height = max_h; wm_hints->initial_state = NormalState; wm_hints->input = true; wm_hints->icon_pixmap = pm; wm_hints->flags = StateHint | IconPixmapHint | InputHint; class_hints->res_name = name; class_hints->res_class = name; XSetWMProperties ( dpy, win, &Window_Name, &Icon_Name, gui->argv, gui->argc, size_hints, wm_hints, class_hints ); XFree(size_hints); XFree(wm_hints); XFree(class_hints); XFree(Window_Name.value); XFree(Icon_Name.value); // cout << "Setting hints required " << (texmacs_time ()-start_2) << " ms\n"; }
void init_client(WM* wm, Window w, Client* c) { char* name; XClassHint* ch = XAllocClassHint(); memset(c,0,sizeof(Client)); c->win = w; c->manager = wm; c->x =c->y = 0; c->w = c->h = 10; if (XGetClassHint(wm->dpy, w, ch)) { sprintf(c->class,"%s",ch->res_class); if (ch->res_class) XFree(ch->res_class); if (ch->res_name) XFree(ch->res_name); }
xfWindow* xf_CreateDesktopWindow(xfInfo* xfi, char* name, int width, int height, boolean decorations) { xfWindow* window; window = (xfWindow*) xzalloc(sizeof(xfWindow)); if (window != NULL) { int input_mask; XClassHint* class_hints; window->width = width; window->height = height; window->fullscreen = False; window->decorations = decorations; window->handle = XCreateWindow(xfi->display, RootWindowOfScreen(xfi->screen), xfi->workArea.x, xfi->workArea.y, xfi->width, xfi->height, 0, xfi->depth, InputOutput, xfi->visual, CWBackPixel | CWBackingStore | CWOverrideRedirect | CWColormap | CWBorderPixel, &xfi->attribs); class_hints = XAllocClassHint(); if (class_hints != NULL) { class_hints->res_name = "xfreerdp"; class_hints->res_class = "xfreerdp"; XSetClassHint(xfi->display, window->handle, class_hints); XFree(class_hints); } xf_ResizeDesktopWindow(xfi, window, width, height); xf_SetWindowDecorations(xfi, window, decorations); input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | VisibilityChangeMask | FocusChangeMask | StructureNotifyMask | PointerMotionMask | ExposureMask | PropertyChangeMask; if (xfi->grab_keyboard) input_mask |= EnterWindowMask | LeaveWindowMask; XSelectInput(xfi->display, window->handle, input_mask); XMapWindow(xfi->display, window->handle); } XStoreName(xfi->display, window->handle, name); return window; }
void hook_init() { g_event_window = XCreateSimpleWindow(g_display, g_root, 42, 42, 42, 42, 0, 0, 0); // set wm_class for window XClassHint *hint = XAllocClassHint(); hint->res_name = (char*)HERBST_HOOK_CLASS; hint->res_class = (char*)HERBST_HOOK_CLASS; XSetClassHint(g_display, g_event_window, hint); XFree(hint); // ignore all events for this window XSelectInput(g_display, g_event_window, 0l); // set its window id in root window XChangeProperty(g_display, g_root, ATOM(HERBST_HOOK_WIN_ID_ATOM), XA_ATOM, 32, PropModeReplace, (unsigned char*)&g_event_window, 1); }
xfWindow* xf_CreateWindow(xfInfo* xfi, rdpWindow* wnd, int x, int y, int width, int height, uint32 id) { xfWindow* window; window = (xfWindow*) xzalloc(sizeof(xfWindow)); if ((width * height) < 1) return NULL; xf_FixWindowCoordinates(xfi, &x, &y, &width, &height); window->left = x; window->top = y; window->right = x + width - 1; window->bottom = y + height - 1; window->width = width; window->height = height; if (window != NULL) { XGCValues gcv; int input_mask; XClassHint* class_hints; window->decorations = False; window->fullscreen = False; window->window = wnd; window->localMoveSize = False; window->handle = XCreateWindow(xfi->display, RootWindowOfScreen(xfi->screen), x, y, window->width, window->height, 0, xfi->depth, InputOutput, xfi->visual, CWBackPixel | CWBackingStore | CWOverrideRedirect | CWColormap | CWBorderPixel, &xfi->attribs); xf_SetWindowDecorations(xfi, window, window->decorations); class_hints = XAllocClassHint(); if (class_hints != NULL) { char* class; class = xmalloc(sizeof(rail_window_class)); snprintf(class, sizeof(rail_window_class), "RAIL:%08X", id); class_hints->res_name = "RAIL"; class_hints->res_class = class; XSetClassHint(xfi->display, window->handle, class_hints); XFree(class_hints); xfree(class); }
void OS_X11::set_context(int p_context) { XClassHint* classHint = NULL; classHint = XAllocClassHint(); if (classHint) { if (p_context == CONTEXT_EDITOR) classHint->res_name = (char *)"Godot_Editor"; if (p_context == CONTEXT_PROJECTMAN) classHint->res_name = (char *)"Godot_ProjectList"; classHint->res_class = (char *)"Godot"; XSetClassHint(x11_display, x11_window, classHint); XFree(classHint); } }
void setXorgClassHint(const video::SExposedVideoData &video_data, const std::string &name) { #ifdef XORG_USED if (video_data.OpenGLLinux.X11Display == NULL) return; XClassHint *classhint = XAllocClassHint(); classhint->res_name = (char *)name.c_str(); classhint->res_class = (char *)name.c_str(); XSetClassHint((Display *)video_data.OpenGLLinux.X11Display, video_data.OpenGLLinux.X11Window, classhint); XFree(classhint); #endif }
void set_wm_class(window *win, wm_class_context *ctx) { XClassHint *hint = XAllocClassHint(); if (hint == NULL) { print_error("system error: XAllocClassHint"); exit(EXIT_FAILURE); } hint->res_name = ctx->name; hint->res_class = ctx->class; XSetClassHint(win->display, win->window, hint); *(ctx->done) += 1; XFree(hint); }
/** * Set a window name & class. * @param win The window * @param n The name string * @param c The class string * * Set a window name * class */ EAPI void ecore_x_icccm_name_class_set(Ecore_X_Window win, const char *n, const char *c) { XClassHint *xch; xch = XAllocClassHint(); if (!xch) return; LOGFN(__FILE__, __LINE__, __FUNCTION__); xch->res_name = (char *)n; xch->res_class = (char *)c; XSetClassHint(_ecore_x_disp, win, xch); if (_ecore_xlib_sync) ecore_x_sync(); XFree(xch); }
XClassHint* xobj_get_wm_class(struct _xobj *p) { Window window = p->find_win_byatom(p, "WM_CLASS"); if (window == None) window = p->xWindow; XClassHint *wm_class = XAllocClassHint(); if (!XGetClassHint(p->xDisplay, window, wm_class)) { log_message(ERROR, "Can't get WM_CLASS"); XFree(wm_class->res_class); XFree(wm_class->res_name); XFree(wm_class); return NULL; } return wm_class; }
char* get_wm_class_name(Window window) { if (window == None) return NULL; Window named_window = find_window_with_atom(window, XInternAtom(main_window->display, "WM_CLASS", True)); if (named_window == None) { named_window = find_window_with_atom(window, XInternAtom(main_window->display, "WM_NAME", True)); if (named_window == None) return NULL; Atom type; int size; long nitems; Atom request = XInternAtom(main_window->display, "WM_NAME", False); unsigned char *data = get_win_prop(named_window, request, &nitems, &type, &size); if (nitems > 0) return (char *)data; return NULL; } XClassHint *wm_class = XAllocClassHint(); if (!XGetClassHint(main_window->display, named_window, wm_class)) { XFree(wm_class); return NULL; } char *string = strdup(wm_class->res_class); XFree(wm_class->res_class); XFree(wm_class->res_name); XFree(wm_class); return string; }
bool RotationDaemon::checkApplicationBlacklistToForceLandscape() { // Find active window Window activeWindow = activeWindowId(); // Now find what it is called XClassHint *xh = XAllocClassHint(); //Status s = XGetClassHint(QX11Info::display(), activeWindow, xh); qDebug() << "Active window is " << xh->res_name << xh->res_class; // clean up XFree(xh->res_name); XFree(xh->res_class); XFree(xh); return false; }
int PropGetWMClass(Window window, char **wm_class, char **wm_instance) { XClassHint *class_hint; class_hint = XAllocClassHint(); if (XGetClassHint(dpy, window, class_hint) == 0) { *wm_class = strdup("default"); *wm_instance = strdup("default"); XFree(class_hint); return False; } *wm_instance = strdup(class_hint->res_name); *wm_class = strdup(class_hint->res_class); XFree(class_hint->res_name); XFree(class_hint->res_class); XFree(class_hint); return True; }
void aosd_set_name(Aosd* aosd, XClassHint* name) { Bool flag = False; if (aosd == NULL) return; if (name == NULL) { name = XAllocClassHint(); name->res_name = "libaosd"; name->res_class = "Atheme"; flag = True; } XSetClassHint(aosd->display, aosd->win, name); if (flag) XFree(name); }
void XLibWindowManagerAdapterPrivate::handleCreatedWindow(Window window) { QString targetName; if (window != XDefaultRootWindow(m_display)) { XClassHint *classHint = XAllocClassHint(); XGetClassHint(m_display, window, classHint); targetName = QString(classHint->res_class); XFree(classHint->res_name); XFree(classHint->res_class); XFree(classHint); } if (q_ptr->m_listener) { bool grabTouches = true; qDebug() << "Created: " << window << " " << targetName; q_ptr->m_listener->onWindowCreated(window, targetName, &grabTouches); if (grabTouches) { XIGrabTouchBegin(m_display, XIAllMasterDevices, window, 0, &m_mask, 1, &m_mods); } } }
bool hc_create_client_window(HCConnection* con) { if (con->client_window) { return true; } /* ensure that classhint and the command is set when the hlwm-server * receives the XCreateWindowEvent */ XGrabServer(con->display); // create window con->client_window = XCreateSimpleWindow(con->display, con->root, 42, 42, 42, 42, 0, 0, 0); // set wm_class for window XClassHint *hint = XAllocClassHint(); hint->res_name = HERBST_IPC_CLASS; hint->res_class = HERBST_IPC_CLASS; XSetClassHint(con->display, con->client_window, hint); XFree(hint); XSelectInput(con->display, con->client_window, PropertyChangeMask); /* the window has been initialized properly, now allow the server to * receive the event for it */ XUngrabServer(con->display); return true; }
void setup_window(void) { XSetWindowAttributes att; XClassHint *xch; att.background_pixmap = None; att.colormap = DefaultColormap(disp, DefaultScreen(disp)); att.border_pixel = 0; att.event_mask = ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ExposureMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask; win = XCreateWindow(disp, RootWindow(disp, DefaultScreen(disp)), 0, 0, win_w, win_h, 0, DefaultDepth(disp, DefaultScreen(disp)), InputOutput, DefaultVisual(disp, DefaultScreen(disp)), CWColormap | CWBorderPixel | CWEventMask | CWBackPixmap, &att); XStoreName(disp, win, "Render Test Program"); xch = XAllocClassHint(); xch->res_name = "Main"; xch->res_class = "Render_Demo"; XSetClassHint(disp, win, xch); XFree(xch); XMapWindow(disp, win); XSync(disp, False); usleep(200000); XSync(disp, False); }
EIF_BOOLEAN basic_gui_initialize(EIF_POINTER display_name, EIF_BOOLEAN sync, EIF_BOOLEAN no_xshm, EIF_POINTER name, EIF_POINTER progclass, EIF_POINTER gxid_host, EIF_INTEGER gxid_port) { /* Called only once at the very beginning to initialize the Window Manager. */ int synchronize = sync; XKeyboardState keyboard_state; XClassHint *class_hint; X_GETTIMEOFDAY (&start); gdk_display_name = display_name; XSetErrorHandler (gui_x_error); XSetIOErrorHandler (gui_x_io_error); g_get_prgname = name; gdk_display_name = display_name; if (no_xshm) gdk_use_xshm = FALSE; gdk_progclass = progclass; #ifdef XINPUT_GXI gdk_input_gxid_host = gxid_host; gdk_input_gxid_port = gxid_port; #endif gdk_display = XOpenDisplay (gdk_display_name); if (!gdk_display) return FALSE; if (synchronize) XSynchronize (gdk_display, True); gdk_screen = DefaultScreen (gdk_display); gdk_root_window = RootWindow (gdk_display, gdk_screen); gdk_leader_window = XCreateSimpleWindow(gdk_display, gdk_root_window, 10, 10, 10, 10, 0, 0 , 0); class_hint = XAllocClassHint(); class_hint->res_name = g_get_prgname; if (gdk_progclass == NULL) { gdk_progclass = g_get_prgname; } class_hint->res_class = gdk_progclass; XmbSetWMProperties (gdk_display, gdk_leader_window, NULL, NULL, se_argv, se_argc, NULL, NULL, class_hint); XFree (class_hint); gdk_wm_delete_window = XInternAtom (gdk_display, "WM_DELETE_WINDOW", False); gdk_wm_take_focus = XInternAtom (gdk_display, "WM_TAKE_FOCUS", False); gdk_wm_protocols = XInternAtom (gdk_display, "WM_PROTOCOLS", False); gdk_wm_window_protocols[0] = gdk_wm_delete_window; gdk_wm_window_protocols[1] = gdk_wm_take_focus; gdk_selection_property = XInternAtom (gdk_display, "GDK_SELECTION", False); XGetKeyboardControl (gdk_display, &keyboard_state); autorepeat = keyboard_state.global_auto_repeat; timer.tv_sec = 0; timer.tv_usec = 0; timerp = NULL; /* @@@ Keep This ?: gdk_events_init (); gdk_visual_init (); gdk_window_init (); gdk_image_init (); gdk_input_init (); gdk_dnd_init (); #ifdef USE_XIM gdk_im_open (); #endif */ return 1; }
/* Returns the active top-level window. A top-level window is one that has WM_CLASS set. * May also return None. */ Window getCurrentWindow() { /* First get the window that has the input focus */ Window currentWindow; int revert; XGetInputFocus(display, ¤tWindow, &revert); if (currentWindow == None) { //if(debugMode) printf("Leave getCurrentWindow\n"); return currentWindow; } /* Now go through parent windows until we find one with WM_CLASS set. */ XClassHint* classHint = XAllocClassHint(); if(classHint == NULL) { if(debugMode) printf("Couldn't allocate class hint!!\n"); return None; } int i = 0; while (1) { //if(debugMode) printf("in Loop\n"); i++; if(i >= 5) { if(debugMode) printf("Too many iterations in getCurrentWindow\n"); XFree(classHint); //if(debugMode) printf("Leave getCurrentWindow\n"); return None; } if (currentWindow == root || currentWindow == None) { //if(debugMode) printf("Reached root!\n"); /* No top-level window available. Should never happen. */ XFree(classHint); //if(debugMode) printf("Leave getCurrentWindow\n"); return currentWindow; } //if(debugMode) printf("Call XGetClassHint!\n"); if (XGetClassHint(display, currentWindow, classHint) == 0) { //if(debugMode) printf("Has no Class!\n"); /* Has no WM_CLASS, thus no top-level window */ Window parent = getParentWindow(currentWindow); if(parent == None || currentWindow == parent) { /* something wrong */ XFree(classHint); return currentWindow; } /* Continue with parent until we find WM_CLASS */ currentWindow = parent; } else { //if(debugMode) printf("Clean up class name!\n"); if(classHint->res_class != NULL) XFree(classHint->res_class); if(classHint->res_name != NULL) XFree(classHint->res_name); XFree(classHint); //if(debugMode) printf("Leave getCurrentWindow\n"); return currentWindow; } } }