static void set_above_state() {
printf("_NET_WM_STATE = _NET_WM_STATE_ABOVE\n");
Atom ATOM = XInternAtom(g_display, "ATOM", False);
Atom _NET_WM_STATE = XInternAtom(g_display, "_NET_WM_STATE", False);
Atom _NET_WM_STATE_ABOVE = XInternAtom(
g_display, "_NET_WM_STATE_ABOVE", False);
XChangeProperty(g_display, g_window, _NET_WM_STATE, ATOM, 32,
PropModeReplace, (unsigned char *) &_NET_WM_STATE_ABOVE, 1);
XEvent ev;
memset(&ev, 0, sizeof(ev));
ev.type = ClientMessage;
ev.xclient.type = ClientMessage;
ev.xclient.message_type = XInternAtom(g_display, "_NET_WM_STATE", 0);
ev.xclient.display = g_display;
ev.xclient.window = g_window;
ev.xclient.format = 32;
ev.xclient.data.l[0] = 1; // set ? 1 : 0;
// *_STAYS_ON_TOP is probably KDE-specific
ev.xclient.data.l[1] = XInternAtom(
g_display, "_NET_WM_STATE_STAYS_ON_TOP", 0);
XLockDisplay(g_display);
XSendEvent(g_display, XDefaultRootWindow(g_display), 0,
SubstructureRedirectMask | SubstructureNotifyMask, &ev);
// to work with some non-KDE WMs we should use _NET_WM_STATE_ABOVE
ev.xclient.data.l[1] = XInternAtom(
g_display, "_NET_WM_STATE_ABOVE", 0);
XSendEvent(g_display, XDefaultRootWindow(g_display), 0,
SubstructureRedirectMask | SubstructureNotifyMask, &ev);
XUnlockDisplay(g_display);
}
//---------------------------------------------------------------------------
bool hxc_popuphints::create()
{
if (XD==NULL) return 0;
if (handle) close();
hxc::load_res(XD);
if (max_width==0) max_width=XDisplayWidth(XD,XDefaultScreen(XD))/2;
int th=hxc::font->ascent+hxc::font->descent+2;
EasyStringList lines;
get_current_lines(&lines);
w=border+2+2+border;
h=border+2+border;
for (int n=0;n<lines.NumStrings;n++){
w=max(border+2+(int)hxc::get_text_width(XD,lines[n].String)+2+border,w);
h+=th;
}
Window in_win,in_child;
int childx,childy,mx,my;
x=XDisplayWidth(XD,XDefaultScreen(XD))/2;
y=XDisplayWidth(XD,XDefaultScreen(XD))/2;
UINT mask;
XQueryPointer(XD,XDefaultRootWindow(XD),&in_win,&in_child,
&mx,&my,&childx,&childy,&mask);
x=mx;
y=my+20;
int sw=XDisplayWidth(XD,XDefaultScreen(XD));
int sh=XDisplayHeight(XD,XDefaultScreen(XD));
if (x+w>sw) x=sw-w;
if (y+h>sh) y=my-5-h;
XSetWindowAttributes swa;
swa.backing_store=NotUseful;
swa.override_redirect=True;
swa.cursor=hxc::arrow_cursor;
handle=XCreateWindow(XD,XDefaultRootWindow(XD),x,y,w,h,0,
CopyFromParent,InputOutput,CopyFromParent,
CWBackingStore | CWOverrideRedirect | CWCursor,
&swa);
SetProp(XD,handle,cWinProc,(DWORD)WinProc);
SetProp(XD,handle,cWinThis,(DWORD)this);
SetProp(XD,handle,hxc::cModal,(DWORD)0xffffffff);
XSelectInput(XD,handle,ExposureMask);
XMapWindow(XD,handle);
return false;
}
bool CursorImpl::loadFromPixels(const Uint8* pixels, Vector2u size, Vector2u hotspot)
{
release();
// Convert the image into a bitmap (monochrome!).
std::size_t bytes = (size.x + 7) / 8 * size.y;
std::vector<Uint8> mask(bytes, 0); // Defines which pixel is transparent.
std::vector<Uint8> data(bytes, 1); // Defines which pixel is white/black.
for (std::size_t j = 0; j < size.y; ++j)
{
for (std::size_t i = 0; i < size.x; ++i)
{
std::size_t pixelIndex = i + j * size.x;
std::size_t byteIndex = pixelIndex / 8;
std::size_t bitIndex = i % 8;
// Turn on pixel that are not transparent
Uint8 opacity = pixels[pixelIndex * 4 + 3] > 0 ? 1 : 0;
mask[byteIndex] |= opacity << bitIndex;
// Choose between black/background & white/foreground color for each pixel,
// based on the pixel color intensity: on average, if a channel is "active"
// at 25%, the bit is white.
int intensity = pixels[pixelIndex * 4 + 0] + pixels[pixelIndex * 4 + 1] + pixels[pixelIndex * 4 + 2];
Uint8 bit = intensity > 64 ? 1 : 0;
data[byteIndex] |= bit << bitIndex;
}
}
Pixmap maskPixmap = XCreateBitmapFromData(m_display, XDefaultRootWindow(m_display),
(char*)&mask[0], size.x, size.y);
Pixmap dataPixmap = XCreateBitmapFromData(m_display, XDefaultRootWindow(m_display),
(char*)&data[0], size.x, size.y);
// Define the foreground color as white and the background as black.
XColor fg, bg;
fg.red = fg.blue = fg.green = -1;
bg.red = bg.blue = bg.green = 0;
// Create the monochrome cursor.
m_cursor = XCreatePixmapCursor(m_display,
dataPixmap, maskPixmap,
&fg, &bg,
hotspot.x, hotspot.y);
// Free the resources
XFreePixmap(m_display, dataPixmap);
XFreePixmap(m_display, maskPixmap);
// We assume everything went fine...
return true;
}
GAE_RenderWindow_t* GAE_RenderWindow_open(GAE_RenderWindow_t* window) {
GAE_X11_RenderWindow_t* x11Window = (GAE_X11_RenderWindow_t*)window->platform;
x11Window->window = XCreateWindow(x11Window->display /* Pointer to the Display */
, XDefaultRootWindow(x11Window->display) /* Parent Window */
, 0 /* X of top-left corner */
, 0 /* Y of top-left corner */
, window->width /* requested width */
, window->height /* requested height */
, 0 /* border width */
, CopyFromParent /* window depth */
, CopyFromParent /* window class - InputOutput / InputOnly / CopyFromParent */
, CopyFromParent /* visual type */
, 0 /* value mask */
, 0); /* attributes */
XMapWindow(x11Window->display, x11Window->window);
XStoreName(x11Window->display, x11Window->window, window->name);
XSelectInput(x11Window->display, x11Window->window, ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask);
x11Window->deleteMessage = XInternAtom(x11Window->display, "WM_DELETE_WINDOW", 0);
XSetWMProtocols(x11Window->display, x11Window->window, &x11Window->deleteMessage, 1);
checkFullscreen(x11Window, window);
return window;
}
// Sends a key press and a key release event to the currently focused window.
// See /usr/include/X11/keysymdef.h for available keys.
void sendKey(int keysym) {
Display *display = XOpenDisplay(0);
Window rootWindow = XDefaultRootWindow(display);
// Get window with focus
Window focusWindow;
int revert;
XGetInputFocus(display, &focusWindow, &revert);
XKeyEvent event;
event.display = display;
event.root = rootWindow;
event.window = focusWindow;
event.same_screen = True;
event.state = 0;
event.keycode = XKeysymToKeycode(display, keysym);
// Send KeyPress event
event.type = KeyPress;
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent*)&event);
// Send KeyRelease event
event.type = KeyRelease;
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent*)&event);
XCloseDisplay(display);
}
static Window get_current_window_ewmh(RoccatWindowMonitor *monitor) {
RoccatWindowMonitorPrivate *priv = monitor->priv;
Atom type;
Window root;
Window window;
int status;
unsigned long nitems;
unsigned long bytes_after;
unsigned char *prop;
int format;
if (priv->net_active_window == None)
return None;
root = XDefaultRootWindow(priv->display);
if (root == None)
return None;
status = XGetWindowProperty(priv->display, root, priv->net_active_window, 0L, ~0L, False,
AnyPropertyType, &type, &format, &nitems, &bytes_after, &prop);
if (status == Success && type != None && prop) {
window = *(Window *)prop;
XFree(prop);
return window;
} else
return None;
}
void print_window_attrs(Display *display, Window focus_win, int &wx, int &wy){
XWindowAttributes wattrs;
XGetWindowAttributes(display, focus_win, &wattrs);
char *wname;
XFetchName(display, focus_win, &wname);
int root_x,root_y;
Window unused_child;
Window root = XDefaultRootWindow(display);
XTranslateCoordinates(display, focus_win, wattrs.root, wattrs.x, wattrs.y, &root_x, &root_y, &unused_child);
Window root_return;
int x_return, y_return;
unsigned int width_return, height_return;
unsigned int border_width_return;
unsigned int depth_return;
XGetGeometry(display, focus_win, &root_return, &x_return, &y_return, &width_return,
&height_return, &border_width_return, &depth_return);
debug()<<"Window Info: "<<"("<< wattrs.x <<','<< wattrs.y <<") "<< wattrs.width <<'x'<< wattrs.height<<' '<< focus_win<<' '<<wattrs.root<<std::endl
<<" "<<"("<< root_x <<','<<root_y<<')'<<std::endl
<<" "<<"("<< x_return <<','<<y_return<<") "<<width_return<<'x'<<height_return<<' '<<root_return<<(root_return==root?'=':'x')<<std::endl
<<' '<< wname<< std::endl;
wx = root_x; wy = root_y; // delta (+7,+24)
}
/*
* Initialize SubPopup(color)
*/
void InitSubPopupColor()
{
int i;
char buf[4];
Pixmap checkmarkBitmap;
String trans2 =
"<Leave>: SubPopdown(pctop)";
checkmarkBitmap = XCreateBitmapFromData(XtDisplay(toplevel),
XDefaultRootWindow(XtDisplay(toplevel)),
coloritem_bits,
coloritem_width,coloritem_height);
pcTop = Xt_P("pctop" ,simpleMenuWidgetClass,toplevel,NULL);
Xt_W("pcline",smeLineObjectClass ,pcTop ,XtNlineWidth,2,NULL);
for(i=0;i<POPUP_COLOR_NITEM;i++) {
sprintf(buf,"pc%1d",i);
pc[i] = Xt_W(buf,smeBSBObjectClass,pcTop,NULL);
XtVaSetValues(pc[i],
XtNleftBitmap,checkmarkBitmap,
XtNleftMargin,72,
XtNlabel,"",
NULL);
XtAddCallback(pc[i],XtNcallback,(XtCallbackProc)SelectColor,(XtPointer)i);
}
XtOverrideTranslations(pcTop,XtParseTranslationTable(trans2));
}
Pixmap XcodaCreatePixmapFromXpm(Widget parent,
const char** data,
int type)
{
Display *dpy = XtDisplay(parent);
Window win = XDefaultRootWindow(dpy);
Screen *scr = XDefaultScreenOfDisplay(dpy);
int depth = DefaultDepthOfScreen(scr);
Colormap cmap = DefaultColormapOfScreen(scr);
XpmAttributes attr;
unsigned int valuemask = 0;
int err;
/*unsigned int pixmap_ret, pixmap_mask;*/
Pixmap pixmap_ret, pixmap_mask;
XpmColorSymbol col_symbol[1];
Arg arg[5];
int ac = 0;
Pixel parent_bg;
if(type){ /* normal background for pixmap */
XtSetArg (arg[ac], XmNbackground, &parent_bg); ac++;
XtGetValues (parent, arg, ac);
ac = 0;
}
else{ /* inverted or highlighted pixmap */
XtSetArg (arg[ac], XmNforeground, &parent_bg); ac++;
XtGetValues (parent, arg, ac);
ac = 0;
}
col_symbol[0].name = (char *)NULL;
col_symbol[0].value = (char *)malloc((strlen("LightBlue")+1)*sizeof(char));
strcpy(col_symbol[0].value,"LightBlue");
col_symbol[0].pixel = parent_bg;
attr.colormap = cmap;
attr.depth = depth;
attr.colorsymbols = col_symbol;
attr.valuemask = valuemask;
attr.numsymbols = 1;
attr.closeness = 65536;
attr.valuemask |= XpmReturnPixels;
attr.valuemask |= XpmColormap;
attr.valuemask |= XpmColorSymbols;
attr.valuemask |= XpmDepth;
attr.valuemask |= XpmCloseness;
/*
printf("Calling XpmCreatePixmapFromData ...\n");
*/
err = XpmCreatePixmapFromData(dpy, win, (char **)data, &pixmap_ret, &pixmap_mask, &attr);
free (col_symbol[0].value);
if(err != XpmSuccess){
pixmap_ret = 0;
}
return pixmap_ret;
}
INLINE MMPoint getMousePos()
{
#if defined(IS_MACOSX)
CGEventRef event = CGEventCreate(NULL);
CGPoint point = CGEventGetLocation(event);
CFRelease(event);
return MMPointFromCGPoint(point);
#elif defined(USE_X11)
int x, y; /* This is all we care about. Seriously. */
Window garb1, garb2; /* Why you can't specify NULL as a parameter */
int garb_x, garb_y; /* is beyond me. */
unsigned int more_garbage;
Display *display = XGetMainDisplay();
XQueryPointer(display, XDefaultRootWindow(display), &garb1, &garb2,
&x, &y, &garb_x, &garb_y, &more_garbage);
return MMPointMake(x, y);
#elif defined(IS_WINDOWS)
POINT point;
GetCursorPos(&point);
return MMPointFromPOINT(point);
#endif
}
const Result ctrlr_sendKeyPressEvent (const KeyPress &keyPress)
{
Display *display = XOpenDisplay(0);
if(display == NULL)
return (Result::fail("Can't open display"));
Window winRoot = XDefaultRootWindow(display);
Window winFocus;
int revert;
if (!XGetInputFocus(display, &winFocus, &revert))
{
return (Result::fail("XGetInputFocus failed"));
}
XKeyEvent event = createKeyEvent(display, winFocus, winRoot, true, keyPress.getKeyCode(), keyPress.getModifiers().getRawFlags());
if (XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event) == 0)
{
return (Result::fail("XSendEvent failed"));
}
event = createKeyEvent(display, winFocus, winRoot, false, keyPress.getKeyCode(), keyPress.getModifiers().getRawFlags());
if (XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event) == 0)
{
return (Result::fail("XSendEvent failed"));
}
XCloseDisplay(display);
return (Result::ok());
}
void switch_window()
{
unsigned char *current_window_data, *desktop_data;
Window root, current_window;
int i;
if (display == NULL) return;
root = XDefaultRootWindow(display);
if ( get_property(root, "_NET_ACTIVE_WINDOW", ¤t_window_data) < 0)
{
return;
}
current_window = *((Window *) current_window_data);
XFree(current_window_data);
for (i=0; i<top_level_window_list.length
&& top_level_window_list.set[i] != current_window; i++);
// will be replaced with init windowz
if (i == top_level_window_list.length) return;
else if (i == top_level_window_list.length-1) i=-1;
if ( get_property(top_level_window_list.set[i+1], "_NET_WM_DESKTOP", &desktop_data) < 0)
{
return;
}
send_message("_NET_CURRENT_DESKTOP", root, *((unsigned long *) desktop_data), 0, 0, 0, 0);
send_message("_NET_ACTIVE_WINDOW", top_level_window_list.set[i+1], 0, 0, 0, 0, 0);
}
int send_event( int keycode, Display *active_display)
{
int res = 0;
XEvent event;
Window win;
int revert_to;
struct timeval t;
gettimeofday(&t, NULL);
XGetInputFocus(active_display, &win, &revert_to);
event.xkey.type = KeyPress;
event.xkey.serial = 0;
event.xkey.send_event = True;
event.xkey.display = active_display;
event.xkey.window = win;
event.xkey.root = XDefaultRootWindow(active_display);
event.xkey.subwindow = None;
event.xkey.time = t.tv_usec;
event.xkey.x = 0;
event.xkey.y = 0;
event.xkey.x_root = 0;
event.xkey.state = 0;
event.xkey.keycode = keycode;
event.xkey.same_screen=True;
res = XSendEvent(active_display, InputFocus, True, 3, &event);
XFlush(active_display);
if (res == BadValue || res == BadWindow)
res = -1;
return res;
}
int cheese(int keyPress)
{
// Obtain the X11 display.
Display *display = XOpenDisplay(0);
if(display == NULL)
return -1;
// Get the root window for the current display.
Window winRoot = XDefaultRootWindow(display);
// Find the window which has the current keyboard focus.
Window winFocus;
int revert;
XGetInputFocus(display, &winFocus, &revert);
// Send a fake key press event to the window.
XKeyEvent event = createKeyEvent(display, winFocus, winRoot, true, keyPress, 0);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
// Send a fake key release event to the window.
event = createKeyEvent(display, winFocus, winRoot, false, keyPress, 0);
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
// Done.
XCloseDisplay(display);
return 0;
}
static int VimRemotingClient_init_internal(VimRemotingClient *client)
{
prologue(client);
client->commProperty = XInternAtom(client->dpy, "Comm", False);
client->vimProperty = XInternAtom(client->dpy, "Vim", False);
client->registryProperty = XInternAtom(client->dpy, "VimRegistry", False);
client->window = XCreateSimpleWindow(
client->dpy, XDefaultRootWindow(client->dpy),
getpid(), 0, 10, 10, 0,
WhitePixel(client->dpy, DefaultScreen(client->dpy)),
WhitePixel(client->dpy, DefaultScreen(client->dpy)));
XSelectInput(client->dpy, client->window, PropertyChangeMask);
/* WARNING: Do not step through this while debugging, it will hangup
* the X server! */
XGrabServer(client->dpy);
deleteAnyLingerer(client);
XUngrabServer(client->dpy);
/* Make window recognizable as a vim window */
XChangeProperty(
client->dpy, client->window,
client->vimProperty, XA_STRING,
8, PropModeReplace, (char *)client->vim_version,
(int)strlen(client->vim_version) + 1);
XSync(client->dpy, False);
epilogue(client);
return client->got_x_error;
}
long desktop_count() {
if (!_check_init()) {
return -1;
}
if (!_is_supported_feature("_NET_NUMBER_OF_DESKTOPS")) {
fprintf(stderr,
"Your window manager does not support _NET_NUMBER_OF_DESKTOPS "
"so I'm returning 1 since you obviously have one desktop");
return 1;
}
Atom type;
int size = 0;
long item_count = 0;
long ret = 1;
Window root = XDefaultRootWindow(defaults->display);
Atom request =
XInternAtom(defaults->display, "_NET_NUMBER_OF_DESKTOPS", FALSE);
unsigned char *data =
_window_property(root, request, &item_count, &type, &size);
if (item_count > 0) {
ret = *((long*) data);
}
if(data) {
XFree(data);
}
return ret;
}
long get_current_desktop() {
Atom type;
int size = 0;
long item_count = 0;
long desktop = 1;
if (!_is_supported_feature("_NET_CURRENT_DESKTOP")) {
fprintf(stderr,
"Apparently your window manager doesn't support "
"_NET_CURRENT_DESKTOP so I'm returning 1.\n");
return 1;
}
Atom request =
XInternAtom(defaults->display, "_NET_CURRENT_DESKTOP", FALSE);
Window root = XDefaultRootWindow(defaults->display);
unsigned char *desktops =
_window_property(root, request, &item_count, &type, &size);
if (item_count > 0) {
desktop = *((long*) desktops);
} else {
desktop = -2; //Signals a problem as opposed to "I don't do that"
}
if(desktop) {
XFree(desktops);
}
desktop++; //Force desktop to be one based rather than zero based
return desktop;
}
int WindowInit(unsigned int const major, unsigned int const minor)
{
display = XOpenDisplay(NULL);
if(display == NULL) {
puts("Cannot connect to the X server.\n");
return -1;
}
width = XDisplayWidth(display, 0);
height = XDisplayHeight(display, 0);
XVisualInfo *visual = glXChooseVisual(display, 0, (int*)attrs);
if(visual == NULL) {
puts("Could not find a visual.\n");
return -2;
}
window = XDefaultRootWindow(display);
context = glXCreateContext(display, visual, NULL, GL_TRUE);
glXMakeCurrent(display, window, context);
XFree(visual);
XQueryPointer(display, window, &window_returned,
&window_returned, &root_x, &root_y, &win_x, &win_y,
&mask_return);
return 1;
}
void Widget::show(const Point &point)
{
const iint32 x = point.x();
const iint32 y = point.y();
const iint32 width = minimumSize().width();
const iint32 height = minimumSize().height();
IdealGUI::Application *app = static_cast<IdealGUI::Application*>(application());
IdealGUI::Application::PrivateImpl *a_d = static_cast<IdealGUI::Application::PrivateImpl*>(app->d);
Display *dpy = a_d->m_dpy;
if (!D_I->m_window) {
if (!d->m_parentWidget) {
D_I->m_window = XCreateSimpleWindow(dpy, XDefaultRootWindow(dpy), x, y, width, height, 0,
XWhitePixel(dpy, XDefaultScreen(dpy)),
XWhitePixel(dpy, XDefaultScreen(dpy)));
} else {
D_I->m_window = XCreateSimpleWindow(dpy, static_cast<IdealGUI::Widget::PrivateImpl*>(d->m_parentWidget->d)->m_window,
x, y, width, height, 0,
XWhitePixel(dpy, XDefaultScreen(dpy)),
XWhitePixel(dpy, XDefaultScreen(dpy)));
}
a_d->m_widgetMap[D_I->m_window] = this;
XSelectInput(dpy, D_I->m_window, ExposureMask | ButtonPressMask | ButtonReleaseMask |
EnterWindowMask | LeaveWindowMask | PointerMotionMask |
FocusChangeMask | KeyPressMask | KeyReleaseMask |
StructureNotifyMask | SubstructureNotifyMask);
}
XMapWindow(dpy, D_I->m_window);
D_I->m_cs = cairo_xlib_surface_create(dpy, D_I->m_window, DefaultVisual(dpy, 0), width, height);
}
Window* NetClientList(Display* display, unsigned long *len)
{
Window* windowList;
Atom type;
int form, errno;
unsigned long remain;
errno = XGetWindowProperty(
display,
XDefaultRootWindow(display),
XInternAtom(display, "_NET_CLIENT_LIST", False),
0,
65536,
False,
XA_WINDOW,
&type,
&form,
len,
&remain,
(byte**)&windowList
);
if(errno != Success)
{
MsgDev(D_ERROR, "VID_EnumerateInstances: Xlib error: %s\n", strerror(errno));
return NULL;
}
return windowList;
}
void keyboardEvent(bool pressed,int key)
{
// Find the window which has the current keyboard focus.
Window win;
int revert;
XGetInputFocus(display, &win, &revert);
Window winRoot = XDefaultRootWindow(display);
XKeyEvent event;
event.display = display;
event.window = win;
event.root = winRoot;
event.subwindow = None;
event.time = CurrentTime;
event.x = 1;
event.y = 1;
event.x_root = 1;
event.y_root = 1;
event.same_screen = True;
event.keycode = XKeysymToKeycode(display, key);
event.state = 0;//modifiers;
event.type = pressed? KeyPress : KeyRelease;
XSendEvent(event.display, event.window, True, KeyPressMask, (XEvent *)&event);
}
cmsHPROFILE GetProfileFromAtom(Display* disp, const char* prop_name)
{
Atom atom = XInternAtom(disp, prop_name, True);
if (atom)
{
int actual_format_return;
unsigned long nitems_return = 0;
unsigned long bytes_after_return = 0;
unsigned char* prop_return = 0;
Atom a;
Window w = XDefaultRootWindow(disp);
if (w)
{
XGetWindowProperty(disp, w, atom, 0, INT_MAX, False,
AnyPropertyType,
&a, &actual_format_return, &nitems_return,
&bytes_after_return, &prop_return);
if (nitems_return && prop_return)
{
cmsHPROFILE profile = cmsOpenProfileFromMem(prop_return, nitems_return);
XFree(prop_return);
if (profile != NULL)
{
return profile;
};
};
};
};
return NULL;
}
static void send_message(const char *type, Window win,
unsigned long data0, unsigned long data1, unsigned long data2,
unsigned long data3, unsigned long data4)
{
Window root;
XEvent event;
long mask = SubstructureRedirectMask | SubstructureNotifyMask;
root = XDefaultRootWindow(display);
event.xclient.type = ClientMessage;
event.xclient.serial = 0;
event.xclient.send_event = True;
event.xclient.message_type = XInternAtom(display, type, False);
event.xclient.window = win;
event.xclient.format = 32;
event.xclient.data.l[0] = data0;
event.xclient.data.l[1] = data1;
event.xclient.data.l[2] = data2;
event.xclient.data.l[3] = data3;
event.xclient.data.l[4] = data4;
XSendEvent(display, root, False, mask, &event);
XFlush(display);
}
int
loadPixmap (Display * dpy, MyPixmap * pm, char *dir, char *file,
XpmColorSymbol * cs, int n)
{
char filename[512];
XpmAttributes attr;
#ifdef DEBUG
printf ("entering loadPixmap\n");
#endif
pm->pixmap = None;
pm->mask = None;
pm->width = 1;
pm->height = 1;
snprintf (filename, sizeof (filename), "%s/%s", dir, file);
attr.colorsymbols = cs;
attr.numsymbols = n;
attr.valuemask = XpmSize;
if (n > 0 && cs)
attr.valuemask = attr.valuemask | XpmColorSymbols;
if (XpmReadFileToPixmap
(dpy, XDefaultRootWindow (dpy), filename, &pm->pixmap, &pm->mask,
&attr))
return False;
pm->width = attr.width;
pm->height = attr.height;
XpmFreeAttributes (&attr);
return True;
}
MouseTool::MouseTool(){
#ifdef __APPLE__
#elif __WIN32__
#else
dpy = XOpenDisplay(0); // Open the default display (the DISPLAY environment variable)
root_window = XDefaultRootWindow(dpy); // Get the default root window
#endif
}
Window SDLapplication::X11appRootWin()
{
LockX11();
Window win = XDefaultRootWindow(display);
UnlockX11();
return (win);
}
XinputHandler::XinputHandler() : InputHandlerObjectInterface()
{
display = XOpenDisplay(0);
if(display==NULL){
qFatal("Failed to open display");
}
context = XDefaultRootWindow(display);
}
GLboolean FWindow::Linux_Initialize()
{
Attributes = new GLint[12]{GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, DepthBits, GLX_STENCIL_SIZE, StencilBits,
GLX_RED_SIZE, ColourBits, GLX_GREEN_SIZE, ColourBits, GLX_BLUE_SIZE, ColourBits, None};
Decorators = 1;
CurrentWindowStyle |= LINUX_DECORATOR_CLOSE | LINUX_DECORATOR_MAXIMIZE | LINUX_DECORATOR_MINIMIZE | LINUX_DECORATOR_MOVE;
if (!WindowManager::GetDisplay())
{
PrintErrorMessage(ERROR_LINUX_CANNOTCONNECTXSERVER);
exit(0);
}
VisualInfo = glXGetVisualFromFBConfig(WindowManager::GetDisplay(), GetBestFrameBufferConfig());
//VisualInfo = glXChooseVisual(WindowManager::GetDisplay(), 0, Attributes);
if (!VisualInfo)
{
PrintErrorMessage(ERROR_LINUX_INVALIDVISUALINFO);
exit(0);
}
SetAttributes.colormap = XCreateColormap(WindowManager::GetDisplay(),
DefaultRootWindow(WindowManager::GetDisplay()),
VisualInfo->visual, AllocNone);
SetAttributes.event_mask = ExposureMask | KeyPressMask
| KeyReleaseMask | MotionNotify | ButtonPressMask | ButtonReleaseMask
| FocusIn | FocusOut | Button1MotionMask | Button2MotionMask | Button3MotionMask |
Button4MotionMask | Button5MotionMask | PointerMotionMask | FocusChangeMask
| VisibilityChangeMask | PropertyChangeMask | SubstructureNotifyMask;
WindowHandle = XCreateWindow(WindowManager::GetInstance()->m_Display,
XDefaultRootWindow(WindowManager::GetInstance()->m_Display), 0, 0,
Resolution[0], Resolution[1],
0, VisualInfo->depth, InputOutput,
VisualInfo->visual, CWColormap | CWEventMask,
&SetAttributes);
if(!WindowHandle)
{
PrintErrorMessage(ERROR_LINUX_CANNOTCREATEWINDOW);
exit(0);
}
XMapWindow(WindowManager::GetDisplay(), WindowHandle);
XStoreName(WindowManager::GetDisplay(), WindowHandle,
Name);
InitializeAtomics();
XSetWMProtocols(WindowManager::GetDisplay(), WindowHandle, &AtomClose, GL_TRUE);
return Linux_InitializeGL();
}
static xrandrt_t *xrandrt_init(const char *display_name)
{
xrandrt_t *xr;
int fd;
Display *disp;
disp = XOpenDisplay(display_name);
if ((xr = malloc(sizeof(*xr))) == NULL) {
if (disp != NULL)
XCloseDisplay(disp);
}
else {
fd = XConnectionNumber(disp);
memset(xr, 0, sizeof(*xr));
xr->disp = disp;
xr->chan = g_io_channel_unix_new(fd);
xr->evsrc = g_io_add_watch(xr->chan, G_IO_IN|G_IO_HUP|G_IO_ERR,
xevent_cb,xr);
printf("videoep: xrandr initialized\n");
{
Window root;
Visual *vis;
int sno;
unsigned long wp;
unsigned long bp;
Window win;
int depth;
XSetWindowAttributes attr;
unsigned long mask;
root = XDefaultRootWindow(disp);
sno = XDefaultScreen(disp);
vis = XDefaultVisual(disp, sno);
depth = XDefaultDepth(disp, sno);
bp = XBlackPixel(disp, sno);
wp = XWhitePixel(disp, sno);
mask = CWBackPixel | CWBorderPixel | CWEventMask;
attr.background_pixel = wp;
attr.border_pixel = bp;
attr.event_mask = ButtonPressMask | FocusChangeMask;
win = XCreateWindow(disp, root, 50,50, 400,300, 1, depth,
InputOutput, vis, mask, &attr);
XMapWindow(disp,win);
XFlush(disp);
}
}
return xr;
}
void XLibWindowManagerAdapterPrivate::dispatchOpenWindowEvents()
{
Window root = XDefaultRootWindow(m_display);
handleCreatedWindow(root);
getClients(&m_clients, &m_numberOfClients);
for (unsigned long i = 0; i < m_numberOfClients; ++i) {
handleCreatedWindow(m_clients[i]);
}
}
