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);
}
// Apply atoms to window.
static void
x_set_wm(Window win, Display *dsp)
{
Atom property[3]; // Change 2 things at once, (parent + 2 children).
// Set window's WM_NAME property.
// char *title = "yarn"; -- only used twice.
XStoreName(dsp, win, "yarn");
// No children.
property[2] = XInternAtom(dsp, "_NET_WM_NAME", false); // Get WM_NAME atom and store it in _net_wm_title.
XChangeProperty(dsp, win, property[2], XInternAtom(dsp, "UTF8_STRING", false), 8, PropModeReplace, (unsigned char *) "yarn", 4);
// Set window's class.
// char *class = "yarn"; -- only used once.
XClassHint classhint = { "yarn", "yarn" };
XSetClassHint(dsp, win, &classhint);
// Parent.
property[2] = XInternAtom(dsp, "_NET_WM_WINDOW_TYPE", false); // Let WM know type.
// Children.
property[0] = XInternAtom(dsp, "_NET_WM_WINDOW_TYPE_NOTIFICATION", false);
property[1] = XInternAtom(dsp, "_NET_WM_WINDOW_TYPE_UTILITY", false);
// Reach for 2 longs, (2L).
XChangeProperty(dsp, win, property[2], XA_ATOM, 32, PropModeReplace, (unsigned char *) property, 2L);
// Parent.
property[2] = XInternAtom(dsp, "_NET_WM_STATE", false); // Let WM know state.
// Child.
property[0] = XInternAtom(dsp, "_NET_WM_STATE_ABOVE", false);
// Reach for 1 long, (1L).
XChangeProperty(dsp, win, property[2], XA_ATOM, 32, PropModeReplace, (unsigned char *) property, 1L);
}
static void x11_set_window_class(Display *dpy, Window win)
{
XClassHint hint = {0};
hint.res_name = (char*)"retroarch"; // Broken header.
hint.res_class = (char*)"retroarch";
XSetClassHint(dpy, win, &hint);
}
static void
newwin(void *foo, int item, Time time)
{
Window win;
XClassHint classhint;
char title[100];
win = XCreateSimpleWindow(dpy, DefaultRootWindow(dpy),
0, 0, 200, 100, 0, 0, 0);
prots[0] = delete_win;
XSetWMProtocols(dpy, win, prots, 1);
sprintf(title, "Notify Test Window");
XStoreName(dpy, win, title);
/* set class hint */
classhint.res_name = "notest";
classhint.res_class = "Notest";
XSetClassHint(dpy, win, &classhint);
hints = XAllocWMHints();
/* set window group leader */
hints->window_group = leader;
hints->flags = WindowGroupHint;
XSetWMHints(dpy, win, hints);
WMAppAddWindow(app, win);
XMapWindow(dpy, win);
}
static void
set_name_and_icon(void)
{
char *icon_name = "HyperDoc";
char *s;
Pixmap icon_pixmap;
XWMHints wmhints;
XClassHint ch;
ch.res_name = "HyperDoc";
ch.res_class = gArgv[0];
for (s = gArgv[0] + strlen(gArgv[0]) - 1; s != gArgv[0]; s--) {
if (*s == '/') {
ch.res_class = s + 1;
break;
}
}
XSetClassHint(gXDisplay, gWindow->fMainWindow, &ch);
XStoreName(gXDisplay, gWindow->fMainWindow, "HyperDoc");
/* define and assign the pixmap for the icon */
icon_pixmap = XCreateBitmapFromData(gXDisplay, gWindow->fMainWindow,
ucharp_to_charp(ht_icon_bits),
ht_icon_width, ht_icon_height);
wmhints.icon_pixmap = icon_pixmap;
wmhints.flags = IconPixmapHint;
XSetWMHints(gXDisplay, gWindow->fMainWindow, &wmhints);
/* name the icon */
XSetIconName(gXDisplay, gWindow->fMainWindow, icon_name);
}
/**
* @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);
}
}
void CreateDock(int argc, char *argv[]) /* this part comes from http://www.linuxmag-france.org/ */
{
Window root;
XWMHints wmHints;
XSizeHints sizeHints;
XClassHint classHint;
Pixmap pixmask;
unsigned long p_blanc;
unsigned long p_noir;
unsigned int borderWidth = 2;
char *wname = argv[0] ;
dpy = XOpenDisplay(NULL) ;
if(dpy == NULL)
{
fprintf(stderr, "Can't open display\n") ;
exit(1) ;
}
root = RootWindow(dpy,screen);
p_blanc = WhitePixel(dpy,screen) ;
p_noir = BlackPixel(dpy,screen) ;
gc = XDefaultGC(dpy,screen) ;
XSetForeground(dpy, gc, p_noir);
XSetBackground(dpy, gc,p_noir);
sizeHints.x = 0 ;
sizeHints.y = 0 ;
sizeHints.width = 64 ;
sizeHints.height = 64 ;
win = XCreateSimpleWindow(dpy,root,sizeHints.x,sizeHints.y , sizeHints.width, sizeHints.height, borderWidth, p_noir,p_noir) ;
iconWin = XCreateSimpleWindow(dpy,root,sizeHints.x,sizeHints.y,sizeHints.width, sizeHints.height, borderWidth, p_noir,p_noir ) ;
sizeHints.flags = USSize | USPosition ;
XSetWMNormalHints(dpy,win,&sizeHints) ;
wmHints.initial_state = WithdrawnState ;
wmHints.icon_window = iconWin ;
wmHints.icon_x = sizeHints.x ;
wmHints.icon_y = sizeHints.y ;
wmHints.window_group = win ;
wmHints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint ;
XSetWMHints(dpy, win, &wmHints) ;
classHint.res_name = wname ;
classHint.res_class = wname ;
XSetClassHint(dpy, win, &classHint) ;
XSetCommand(dpy,win, argv, argc) ;
pixmask = XCreateBitmapFromData(dpy,win,fond_bits, fond_width, fond_height) ;
XShapeCombineMask(dpy,win,ShapeBounding,0,0,pixmask,ShapeSet) ;
XShapeCombineMask(dpy,iconWin,ShapeBounding, 0, 0, pixmask, ShapeSet) ;
XpmCreatePixmapFromData(dpy,root,wmAppKill_xpm, &XPM, NULL,NULL) ;
XSelectInput(dpy,win, ExposureMask | ButtonPressMask) ;
XSelectInput(dpy,iconWin, ExposureMask | ButtonPressMask) ;
XMapWindow(dpy,win) ;
}
void createWin(Window *win, int x, int y)
{
XClassHint classHint;
*win=XCreateSimpleWindow(d_display, w_root, x, y, winsize, winsize, 0, 0, 0);
classHint.res_name=NAME;
classHint.res_class=CLASS;
XSetClassHint(d_display, *win, &classHint);
}
/**
@brief Used to generate a default name for the case when the XClassHints are not set correctly.
@return void
**/
void
make_default_program_name(Display *display, Window window, char *name) {
XClassHint program_hint;
program_hint.res_name = name;
program_hint.res_class = name;
XSetClassHint(display, window, &program_hint);
XFlush(display);
}
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);
}
static void sendhints(Window w,struct hints *h)
{
if(h->flg&1) XSetWMName(dsp,w,&h->window_name);
if(h->flg&2) XSetWMIconName(dsp,w,&h->icon_name);
if(h->flg&4) XSetCommand(dsp,w,h->argv,h->argc);
if(h->flg&8) XSetClassHint(dsp,w,&h->class_hints);
if(h->normal_hints.flags) XSetWMNormalHints(dsp,w,&h->normal_hints);
if(h->wm_hints.flags) XSetWMHints(dsp,w,&h->wm_hints);
}
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;
}
void setWndClass(QWidget *w, const char *name)
{
Display *dsp = w->x11Display();
WId win = w->winId();
XClassHint classhint;
classhint.res_name = (char*)"sim";
classhint.res_class = (char*)name;
XSetClassHint(dsp, win, &classhint);
}
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);
}
TrayIconWharf(TrayIcon *object, const QPixmap &pm)
: TrayIconPrivate(object, 44)
{
// set the class hint
XClassHint classhint;
classhint.res_name = (char*)"psidock-wharf";
classhint.res_class = (char*)"Psi";
XSetClassHint(QX11Info::display(), winId(), &classhint);
setPixmap(pm);
}
void x11wmClass(Display *dsp, WId wid, QString resName)
{
char app_name[] = "jabbinchat";
//Display *dsp = x11Display(); // get the display
//WId win = winId(); // get the window
XClassHint classhint; // class hints
classhint.res_name = (char *)resName.latin1(); // res_name
classhint.res_class = app_name; // res_class
XSetClassHint(dsp, wid, &classhint); // set the class hints
}
void setX11Resource(QWidget* widget, const QString& c) {
#ifdef Q_WS_X11
char res_class[] = SWIFT_APPLICATION_NAME;
XClassHint hint;
hint.res_name = (QString(SWIFT_APPLICATION_NAME) + "-" + c).toUtf8().data();
hint.res_class = res_class;
XSetClassHint(widget->x11Info().display(), widget->winId(), &hint);
#else
(void) widget;
(void) c;
#endif
}
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);
}
static Window create_window(Display *dpy, int scr, int xsz, int ysz)
{
Window root;
XSetWindowAttributes wattr;
XClassHint chint;
XVisualInfo *vis;
int glx_attr[32];
fill_glx_attrib(glx_attr, mode_mask);
root = RootWindow(dpy, scr);
if(!(vis = glXChooseVisual(dpy, scr, glx_attr))) {
fprintf(stderr, "requested GLX visual is not available\n");
return 0;
}
if(!(ctx = glXCreateContext(dpy, vis, 0, True))) {
fprintf(stderr, "failed to create GLX context\n");
XFree(vis);
return 0;
}
wattr.background_pixel = wattr.border_pixel = BlackPixel(dpy, scr);
wattr.colormap = XCreateColormap(dpy, root, vis->visual, AllocNone);
win = XCreateWindow(dpy, root, 10, 10, xsz, ysz, 0, vis->depth, InputOutput,
vis->visual, CWColormap | CWBackPixel | CWBorderPixel, &wattr);
XSelectInput(dpy, win, inpmask);
wm_prot = XInternAtom(dpy, "WM_PROTOCOLS", False);
wm_del = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
XSetWMProtocols(dpy, win, &wm_del, 1);
wsys_set_title("vsray");
chint.res_name = "vsray";
chint.res_class = "vsray";
XSetClassHint(dpy, win, &chint);
if(glXMakeCurrent(dpy, win, ctx) == False) {
fprintf(stderr, "failed to make GLX context current\n");
glXDestroyContext(dpy, ctx);
XDestroyWindow(dpy, win);
return 0;
}
XMapWindow(dpy, win);
win_xsz = xsz;
win_ysz = ysz;
return win;
}
void setX11Resource(QWidget* widget, const QString& c) {
#if defined (Q_OS_UNIX) && !defined(Q_OS_MAC)
char res_class[] = SWIFT_APPLICATION_NAME;
XClassHint hint;
QByteArray resName = (QString(SWIFT_APPLICATION_NAME) + "-" + c).toUtf8();
hint.res_name = resName.data();
hint.res_class = res_class;
XSetClassHint(widget->x11Info().display(), widget->winId(), &hint);
#else
(void) widget;
(void) c;
#endif
}
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_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;
}
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);
}
// set class hints
int
SetClassHints(Display *display, Window window, char *res_name, char *res_class)
{
XClassHint class_hints;
// fill in class hints
class_hints.res_class = res_class;
class_hints.res_name = res_name;
// set values
XSetClassHint(display, window, &class_hints);
// all done
return(OK);
}
void x11wmClass(Display *dsp, WId wid, QString resName)
{
//Display *dsp = x11Display(); // get the display
//WId win = winId(); // get the window
XClassHint classhint; // class hints
// Get old class hint. It is important to save old class name
XGetClassHint(dsp, wid, &classhint);
XFree(classhint.res_name);
const QByteArray latinResName = resName.toLatin1();
classhint.res_name = (char *)latinResName.data(); // res_name
XSetClassHint(dsp, wid, &classhint); // set the class hints
XFree(classhint.res_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
}
bool KSMShutdownDlg::confirmShutdown(
bool maysd, bool choose, KWorkSpace::ShutdownType& sdtype, QString& bootOption,
const QString& theme)
{
QScopedPointer<KSMShutdownDlg> l(new KSMShutdownDlg( 0, maysd, choose, sdtype, theme ));
XClassHint classHint;
classHint.res_name = const_cast<char*>("ksmserver");
classHint.res_class = const_cast<char*>("ksmserver");
XSetClassHint(QX11Info::display(), l->winId(), &classHint);
bool result = l->exec();
sdtype = l->m_shutdownType;
bootOption = l->m_bootOption;
return result;
}
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);
}
