static void
init_mit_saver_extension (saver_info *si)
{
int i;
Pixmap *blank_pix = (Pixmap *) calloc (sizeof(Pixmap), si->nscreens);
for (i = 0; i < si->nscreens; i++)
{
saver_screen_info *ssi = &si->screens[i];
XID kill_id = 0;
Atom kill_type = 0;
Window root = RootWindowOfScreen (ssi->screen);
blank_pix[i] = XCreatePixmap (si->dpy, root, 1, 1, 1);
/* Kill off the old MIT-SCREEN-SAVER client if there is one.
This tends to generate X errors, though (possibly due to a bug
in the server extension itself?) so just ignore errors here. */
if (XScreenSaverGetRegistered (si->dpy,
XScreenNumberOfScreen (ssi->screen),
&kill_id, &kill_type)
&& kill_id != blank_pix[i])
{
XErrorHandler old_handler =
XSetErrorHandler (ignore_all_errors_ehandler);
XKillClient (si->dpy, kill_id);
XSync (si->dpy, False);
XSetErrorHandler (old_handler);
}
XScreenSaverSelectInput (si->dpy, root, ScreenSaverNotifyMask);
XScreenSaverRegister (si->dpy,
XScreenNumberOfScreen (ssi->screen),
(XID) blank_pix[i], XA_PIXMAP);
}
free(blank_pix);
}
EggTrayIcon *
egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
EggTrayIcon *icon;
char buffer[256];
GdkWindow *root_window;
GdkDisplay *display;
GdkScreen *screen;
g_return_val_if_fail (xscreen != NULL, NULL);
icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
gtk_window_set_title (GTK_WINDOW (icon), name);
display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
gtk_plug_construct_for_display (GTK_PLUG (icon),
display, 0);
gtk_window_set_screen (GTK_WINDOW (icon), screen);
gtk_widget_realize (GTK_WIDGET (icon));
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer),
"_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
buffer, False);
icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
"MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE", False);
egg_tray_icon_update_manager_window (icon);
root_window = gdk_screen_get_root_window (gtk_widget_get_screen (GTK_WIDGET (icon)));
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window,
egg_tray_icon_manager_filter, icon);
return icon;
}
MetaUI*
meta_ui_new (Display *xdisplay,
Screen *screen)
{
GdkDisplay *gdisplay;
MetaUI *ui;
ui = g_new0 (MetaUI, 1);
ui->xdisplay = xdisplay;
ui->xscreen = screen;
gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
g_assert (gdisplay == gdk_display_get_default ());
ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
/* GTK+ needs the frame-sync protocol to work in order to properly
* handle style changes. This means that the dummy widget we create
* to get the style for title bars actually needs to be mapped
* and fully tracked as a MetaWindow. Horrible, but mostly harmless -
* the window is a 1x1 overide redirect window positioned offscreen.
*/
gtk_widget_show (GTK_WIDGET (ui->frames));
g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
return ui;
}
static void
XmuFreeXftColor (XtAppContext app, XrmValuePtr toVal, XtPointer closure,
XrmValuePtr args, Cardinal *num_args)
{
Screen *screen;
Colormap colormap;
XftColor *color;
if (*num_args != 2)
{
XtAppErrorMsg (app,
"freeXftColor", "wrongParameters",
"XtToolkitError",
"Freeing an XftColor requires screen and colormap arguments",
(String *) NULL, (Cardinal *)NULL);
return;
}
screen = *((Screen **) args[0].addr);
colormap = *((Colormap *) args[1].addr);
color = (XftColor *) toVal->addr;
XftColorFree (DisplayOfScreen (screen),
DefaultVisual (DisplayOfScreen (screen),
XScreenNumberOfScreen (screen)),
colormap, color);
}
static void setTrayIcon(QWidget &widget)
{
/* System Tray Protocol Specification. */
Display *dpy = qt_xdisplay();
Screen *screen = XDefaultScreenOfDisplay(dpy);
int iScreen = XScreenNumberOfScreen(screen);
char szAtom[32];
snprintf(szAtom, sizeof(szAtom), "_NET_SYSTEM_TRAY_S%d", iScreen);
Atom selectionAtom = XInternAtom(dpy, szAtom, False);
XGrabServer(dpy);
Window managerWin = XGetSelectionOwner(dpy, selectionAtom);
if (managerWin != None)
XSelectInput(dpy, managerWin, StructureNotifyMask);
XUngrabServer(dpy);
XFlush(dpy);
if (managerWin != None) {
XEvent ev;
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = managerWin;
ev.xclient.message_type = XInternAtom(dpy, "_NET_SYSTEM_TRAY_OPCODE", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = CurrentTime;
ev.xclient.data.l[1] = SYSTEM_TRAY_REQUEST_DOCK;
ev.xclient.data.l[2] = widget.winId();
ev.xclient.data.l[3] = 0;
ev.xclient.data.l[4] = 0;
XSendEvent(dpy, managerWin, False, NoEventMask, &ev);
XSync(dpy, False);
}
}
static GLXFBConfig* _gfx_x11_get_config(
Screen* screen,
const GFXColorDepth* depth,
int backBuffer)
{
/* Create buffer attribute array */
int bufferAttr[] = {
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_DOUBLEBUFFER, backBuffer ? True : False,
GLX_RED_SIZE, depth->redBits,
GLX_GREEN_SIZE, depth->greenBits,
GLX_BLUE_SIZE, depth->blueBits,
None
};
/* Get config from screen */
int buffElements;
return glXChooseFBConfig(
_gfx_x11.display,
XScreenNumberOfScreen(screen),
bufferAttr,
&buffElements
);
}
int plugin_hide(int ph)
{
int i;
XWMHints *hints;
Display *display = XtDisplay(topLevel);
Screen *screen = XtScreen(topLevel);
Window w = plugin[ph].victim;
XSync(display, False);
XWithdrawWindow(display, w, XScreenNumberOfScreen(screen));
XSync(display, False);
hints = XGetWMHints(display, w);
hints->flags |= WindowGroupHint;
hints->window_group = RootWindowOfScreen(screen);
XSetWMHints(display, w, hints);
#if 1 /* testing */
for (i = 0; i < REPARENT_LOOPS; i++) {
Window root, parent, *child;
Cardinal n;
XQueryTree(display, w, &root, &parent, &child, &n);
XReparentWindow(display, w, root, 0, 0);
XSync(display, False);
}
#endif
if (plugin[ph].core != None) {
XtDestroyWidget(plugin[ph].core);
plugin[ph].core = None;
}
return 0;
}
static void
draw_text (struct widget_xft_data *data, char *lbl, int inverse)
{
Screen *sc = XtScreen (data->widget);
int screen = XScreenNumberOfScreen (sc);
int y = data->xft_font->ascent;
int x = inverse ? 0 : 2;
char *bp = lbl;
data->xft_draw = XftDrawCreate (XtDisplay (data->widget),
data->p,
DefaultVisual (XtDisplay (data->widget),
screen),
DefaultColormapOfScreen (sc));
XftDrawRect (data->xft_draw,
inverse ? &data->xft_fg : &data->xft_bg,
0, 0, data->p_width, data->p_height);
if (!inverse) y += 2;
while (bp && *bp != '\0')
{
char *cp = strchr (bp, '\n');
XftDrawStringUtf8 (data->xft_draw,
inverse ? &data->xft_bg : &data->xft_fg,
data->xft_font, x, y,
(FcChar8 *) bp,
cp ? cp - bp : strlen (bp));
bp = cp ? cp + 1 : NULL;
/* 1.2 gives reasonable line spacing. */
y += data->xft_font->height * 1.2;
}
}
int XLibWrapper::getScreenForWindow( Window window )
{
XWindowAttributes windowAttributes;
XGetWindowAttributes( _display, window, &windowAttributes );
return XScreenNumberOfScreen( windowAttributes.screen );
}
///////////////////////////////////////////////////////////////////////
/// Function: Number
///
/// Author: $author$
/// Date: 5/28/2012
///////////////////////////////////////////////////////////////////////
virtual int Number() const
{
int number = -1;
if ((m_attached))
number = XScreenNumberOfScreen(m_attached);
return number;
}
static GC DisplayInfoSharedGC(DisplayInfo d, Screen *screen, int depth)
{
int s = XScreenNumberOfScreen(screen);
register int i;
XGCValues v;
Pixmap p;
if (s >= ScreenCount(DisplayOfScreen(screen))) return NULL;
for (i = 0; i < d->depthsForScreen[s] &&
d->validDepths[s][i] != depth; i++) {}
if (i >= d->depthsForScreen[s]) return NULL;
if (d->gcForDepth[s][i] == 0) { /* Not "None" -- used calloc */
if (depth == DefaultDepthOfScreen(screen)) {
d->gcForDepth[s][i] = XCreateGC(d->display,
RootWindowOfScreen(screen), 0, &v);
} else {
p = XCreatePixmap(d->display,
RootWindowOfScreen(screen),
1, 1, depth);
d->gcForDepth[s][i] = XCreateGC(d->display, p, 0, &v);
XFreePixmap(d->display, p);
}
}
return d->gcForDepth[s][i];
}
MetaUI*
meta_ui_new (Display *xdisplay,
Screen *screen)
{
GdkDisplay *gdisplay;
MetaUI *ui;
ui = g_new0 (MetaUI, 1);
ui->xdisplay = xdisplay;
ui->xscreen = screen;
gdisplay = gdk_x11_lookup_xdisplay (xdisplay);
g_assert (gdisplay == gdk_display_get_default ());
g_assert (xdisplay == GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
ui->frames = meta_frames_new (XScreenNumberOfScreen (screen));
#if GTK_CHECK_VERSION (3, 0, 0)
/* This does not actually show any widget. MetaFrames has been hacked so
* that showing it doesn't actually do anything. But we need the flags
* set for GTK to deliver events properly. */
gtk_widget_show (GTK_WIDGET (ui->frames));
#else
gtk_widget_realize (GTK_WIDGET (ui->frames));
#endif
g_object_set_data (G_OBJECT (gdisplay), "meta-ui", ui);
return ui;
}
cairo_status_t
_cairo_xlib_screen_get_visual_info (cairo_xlib_screen_info_t *info,
Visual *visual,
cairo_xlib_visual_info_t **out)
{
Display *dpy = info->display->display;
cairo_xlib_visual_info_t **visuals, *ret = NULL;
cairo_status_t status;
int i, n_visuals;
CAIRO_MUTEX_LOCK (info->mutex);
visuals = _cairo_array_index (&info->visuals, 0);
n_visuals = _cairo_array_num_elements (&info->visuals);
for (i = 0; i < n_visuals; i++) {
if (visuals[i]->visualid == visual->visualid) {
ret = visuals[i];
break;
}
}
CAIRO_MUTEX_UNLOCK (info->mutex);
if (ret != NULL) {
*out = ret;
return CAIRO_STATUS_SUCCESS;
}
status = _cairo_xlib_visual_info_create (dpy,
XScreenNumberOfScreen (info->screen),
visual->visualid,
&ret);
if (status)
return status;
CAIRO_MUTEX_LOCK (info->mutex);
if (n_visuals != _cairo_array_num_elements (&info->visuals)) {
/* check that another thread has not added our visual */
int new_visuals = _cairo_array_num_elements (&info->visuals);
visuals = _cairo_array_index (&info->visuals, 0);
for (i = n_visuals; i < new_visuals; i++) {
if (visuals[i]->visualid == visual->visualid) {
_cairo_xlib_visual_info_destroy (dpy, ret);
ret = visuals[i];
break;
}
}
if (i == new_visuals)
status = _cairo_array_append (&info->visuals, &ret);
} else
status = _cairo_array_append (&info->visuals, &ret);
CAIRO_MUTEX_UNLOCK (info->mutex);
if (status) {
_cairo_xlib_visual_info_destroy (dpy, ret);
return status;
}
*out = ret;
return CAIRO_STATUS_SUCCESS;
}
/* Initialize the visualInfo based on the attribute list */
static void createVisualInfo(GLwDrawingAreaWidget w)
{
assert(w->glwDrawingArea.attribList);
w->glwDrawingArea.visualInfo = glXChooseVisual(XtDisplay(w),
XScreenNumberOfScreen(XtScreen(w)),
w->glwDrawingArea.attribList);
if (!w->glwDrawingArea.visualInfo)
error((Widget)w,"requested visual not supported");
}
Boolean
WSMProcessProtoTarget(Widget w, Atom target, XtPointer input,
unsigned long input_len, int input_fmt,
Atom *return_type, XtPointer *output,
unsigned long *output_len, int *output_fmt)
{
Display *dpy;
int scr_num;
WSMScreenInfo *screen_info;
WSMRequest request;
WSMReply reply;
/*
* Check the Target to make sure it is valid.
* Check the format to make sure it is WSM_PROTO_FMT.
*/
if (!WSMIsKnownTarget(w, target))
return(False);
if (input_fmt != WSM_PROTO_FMT) {
fprintf(stderr, "Format of the request must be %d\n", WSM_PROTO_FMT);
return(False);
}
dpy = XtDisplay(w);
scr_num = XScreenNumberOfScreen(XtScreen(w));
/*
* Unpack up the request from the wire.
*/
_WSMUnpackRequest(dpy, scr_num, (MessageData) input, input_len,
_WSMTargetToReqType(dpy, target), &request);
/*
* Call the app's callback function to process the request.
*/
screen_info = _WSMGetScreenInfo(dpy, scr_num);
reply.any.type = request.any.type;
reply.any.allocated = False;
(*screen_info->request_callback)(w, screen_info->request_data,
&request, &reply);
/*
* Pack up the reply and send it back.
*/
*output = (XtPointer) _WSMPackReply(dpy, scr_num, &reply, output_len);
*output_fmt = WSM_PROTO_FMT;
*return_type = target; /* Is this the right return type? */
FreeRequest(&request);
FreeReply(&reply);
return(TRUE);
}
int getRootWindowScreen(Window root)
{
XWindowAttributes attr;
if (!XGetWindowAttributes(disp(), root, &attr))
return DefaultScreen(disp());
return XScreenNumberOfScreen(attr.screen);
}
ibool MGLAPI XWIN8_initDriver(void *data,MGLDC *dc,int driverId,int modeId,ulong hwnd,
int virtualX,int virtualY,int numBuffers,ibool stereo,int refreshRate)
/****************************************************************************
*
* Function: WDCI8_initDriver
* Parameters: dc - Device context.
* Returns: True if the device was correctly initialised.
*
* Description: Initialises the device driver, and starts the specified
* graphics mode. This is also where we fill in all of the
* vectors in the device context to initialise our device
* context properly.
*
****************************************************************************/
{
Screen *scr;
Window wnd;
char *buf;
XSetWindowAttributes xswa;
dc->mi = XWIN8_modes[modeId - grSVGA_640x480x256];
dc->deviceType = MGL_WINDOWED_DEVICE;
g_state.d.hardwareCursor = false;
dc->v = &g_state;
dc->wm.xwindc.dpy = globalDisplay;
dc->wm.xwindc.scr = scr = DefaultScreenOfDisplay(globalDisplay);
dc->wm.xwindc.gc = DefaultGCOfScreen(scr);
xswa.background_pixel = BlackPixel(globalDisplay,XScreenNumberOfScreen(scr));
xswa.backing_store = Always;
dc->wm.xwindc.wnd = wnd = XCreateWindow(globalDisplay, RootWindowOfScreen(scr), 0,0, dc->mi.xRes+1, dc->mi.yRes+1,
0, CopyFromParent, CopyFromParent, CopyFromParent,
CWBackPixel | CWBackingStore, &xswa
);
buf = MGL_malloc((dc->mi.xRes+1) * (dc->mi.yRes+1));
dc->wm.xwindc.img = XCreateImage(globalDisplay, DefaultVisualOfScreen(scr),
8, ZPixmap, 0, NULL, dc->mi.xRes+1, dc->mi.yRes+1, 8, 0);
dc->wm.xwindc.img->data = buf;
XInitImage(dc->wm.xwindc.img);
// Sets up the private colormap
dc->wm.xwindc.hpal = xswa.colormap = XCreateColormap(globalDisplay, wnd, DefaultVisualOfScreen(scr), AllocAll);
XChangeWindowAttributes(globalDisplay, wnd, CWColormap, &xswa);
XMapRaised(globalDisplay, wnd);
XClearWindow(globalDisplay, wnd);
XStoreName(globalDisplay, wnd, "MGL [Unix/X11 8 bit Display]");
XWIN_initInternal(dc);
dc->r.realizePalette = XWIN8_realizePalette;
dc->r.getDefaultPalette = XWIN8_getDefaultPalette;
dc->r.putImage = XWIN8_putImage;
return true;
}
/*
We try two different ways of getting the display here.
1) if we have a current context (glw), we try using glXGetCurrentDisplay, if it exists
2) Fall back to XOpenDisplay()
*/
static Display *
glxglue_get_display(const cc_glglue * currentcontext = NULL)
{
if (currentcontext && currentcontext->glx.glXGetCurrentDisplay) {
if (glxglue_screen == -1) {
glxglue_screen = XScreenNumberOfScreen(
XDefaultScreenOfDisplay(
(Display*)currentcontext->glx.glXGetCurrentDisplay()));
}
if (coin_glglue_debug()) {
cc_debugerror_postinfo("glxglue_get_display", "got Display*==%p; got Screen==%d",
currentcontext->glx.glXGetCurrentDisplay(),
glxglue_screen);
}
return (Display*)currentcontext->glx.glXGetCurrentDisplay();
}
if ((glxglue_display == NULL) && !glxglue_opendisplay_failed) {
/* FIXME: should use the real display-setting. :-( 20020926 mortene. */
/* UPDATE 20090218 tamer: Passing NULL through XOpenDisplay()
* makes a POSIX-conformant system default to the value of the
* DISPLAY environment variable. Isn't that exactly what we want?
* Do you mean that the display_name can potentially be provided
* by other means than the DISPLAY envvar? */
if (!(glxglue_display = XOpenDisplay(NULL))) {
cc_debugerror_post("glxglue_init",
"Couldn't open NULL display.");
glxglue_opendisplay_failed = TRUE;
}
glxglue_screen = XScreenNumberOfScreen(
XDefaultScreenOfDisplay(glxglue_display));
if (coin_glglue_debug()) {
cc_debugerror_postinfo("glxglue_get_display", "got Display*==%p; got Screen==%d",
glxglue_display, glxglue_screen);
}
}
return glxglue_display;
}
EggTrayIcon *egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
GdkDisplay *display;
GdkScreen *screen;
display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
return egg_tray_icon_new_for_screen (screen, name);
}
EggTrayIcon *
egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
EggTrayIcon *icon;
char buffer[256];
GdkWindow *root_window;
g_return_val_if_fail (xscreen != NULL, NULL);
icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
gtk_window_set_title (GTK_WINDOW (icon), name);
#if HAVE_GTK_MULTIHEAD
/* FIXME: this code does not compile, screen is undefined. Now try
* getting the GdkScreen from xscreen (:. Dunno how to solve this
* (there is prolly some easy way I cant think of right now)
*/
gtk_plug_construct_for_display (GTK_PLUG (icon),
gdk_screen_get_display (screen), 0);
#else
gtk_plug_construct (GTK_PLUG (icon), 0);
#endif
gtk_widget_realize (GTK_WIDGET (icon));
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer),
"_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
buffer, False);
icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
"MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE", False);
egg_tray_icon_update_manager_window (icon);
#if HAVE_GTK_MULTIHEAD
root_window = gdk_screen_get_root_window (gtk_widget_get_screen (screen));
#else
root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ());
#endif
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window,
egg_tray_icon_manager_filter, icon);
return icon;
}
static void
egg_tray_icon_realize (GtkWidget *widget)
{
EggTrayIcon *icon = EGG_TRAY_ICON (widget);
gint screen;
Display *xdisplay;
char buffer[256];
GdkWindow *root_window;
if (GTK_WIDGET_CLASS (parent_class)->realize)
GTK_WIDGET_CLASS (parent_class)->realize (widget);
make_transparent (widget, NULL);
xdisplay = egg_tray_icon_get_x_display(icon);
if (xdisplay == NULL)
return;
#if GTK_CHECK_VERSION(2,1,0)
screen = gdk_screen_get_number (gtk_widget_get_screen (widget));
#else
screen = XScreenNumberOfScreen (DefaultScreenOfDisplay (gdk_display));
#endif
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer),
"_NET_SYSTEM_TRAY_S%d",
screen);
icon->selection_atom = XInternAtom (xdisplay, buffer, False);
icon->manager_atom = XInternAtom (xdisplay, "MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (xdisplay,
"_NET_SYSTEM_TRAY_OPCODE",
False);
icon->orientation_atom = XInternAtom (xdisplay,
"_NET_SYSTEM_TRAY_ORIENTATION",
False);
egg_tray_icon_update_manager_window (icon, FALSE);
egg_tray_icon_send_dock_request (icon);
#if GTK_CHECK_VERSION(2,1,0)
root_window = gdk_screen_get_root_window (gtk_widget_get_screen (widget));
#else
root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ());
#endif
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window,
egg_tray_icon_manager_filter, icon);
}
Boolean
WSMDefaultOwnSelection(Widget w, WSMClientType client_type,
WSMRequestCallbackFunc request_callback,
XtPointer request_data)
{
Time time;
Display *dpy = XtDisplay(w);
Atom own_selection =
_WSMGetSelectionAtom(dpy,
XScreenNumberOfScreen(XtScreen(w)), client_type);
if (XGetSelectionOwner(dpy, own_selection) != None) {
/*
* Someone out there already owns this selection, we should give
* up and return.
*/
printf("Error - Someone out there already owns this selection.\n");
return(False);
}
if (!XtIsRealized(w)) {
fprintf(stderr, "%s must be realized, and is not.\n",
"Programmer Error: Widget passed to WSMDefaultOwnSelection");
return(False);
}
WSMRegisterRequestCallback(dpy,
XScreenNumberOfScreen(XtScreen(w)),
request_callback, request_data);
time = GetTimestamp(dpy); /* CurrentTime or Zero is a no-no! */
/*
* NOTE - w MUST have its XmNconvertCallback set properly,
* otherwise, no conversions will be handled!
*/
XmeNamedSource(w, own_selection, time);
return(True);
}
Pimpl (const Image& im, Window windowH) : image (im)
{
ScopedXLock xlock;
Screen* const screen = XDefaultScreenOfDisplay (display);
const int screenNumber = XScreenNumberOfScreen (screen);
String screenAtom ("_NET_SYSTEM_TRAY_S");
screenAtom << screenNumber;
Atom selectionAtom = XInternAtom (display, screenAtom.toUTF8(), false);
XGrabServer (display);
Window managerWin = XGetSelectionOwner (display, selectionAtom);
if (managerWin != None)
XSelectInput (display, managerWin, StructureNotifyMask);
XUngrabServer (display);
XFlush (display);
if (managerWin != None)
{
XEvent ev = { 0 };
ev.xclient.type = ClientMessage;
ev.xclient.window = managerWin;
ev.xclient.message_type = XInternAtom (display, "_NET_SYSTEM_TRAY_OPCODE", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = CurrentTime;
ev.xclient.data.l[1] = 0 /*SYSTEM_TRAY_REQUEST_DOCK*/;
ev.xclient.data.l[2] = (long) windowH;
ev.xclient.data.l[3] = 0;
ev.xclient.data.l[4] = 0;
XSendEvent (display, managerWin, False, NoEventMask, &ev);
XSync (display, False);
}
// For older KDE's ...
long atomData = 1;
Atom trayAtom = XInternAtom (display, "KWM_DOCKWINDOW", false);
XChangeProperty (display, windowH, trayAtom, trayAtom, 32, PropModeReplace, (unsigned char*) &atomData, 1);
// For more recent KDE's...
trayAtom = XInternAtom (display, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", false);
XChangeProperty (display, windowH, trayAtom, XA_WINDOW, 32, PropModeReplace, (unsigned char*) &windowH, 1);
// A minimum size must be specified for GNOME and Xfce, otherwise the icon is displayed with a width of 1
XSizeHints* hints = XAllocSizeHints();
hints->flags = PMinSize;
hints->min_width = 22;
hints->min_height = 22;
XSetWMNormalHints (display, windowH, hints);
XFree (hints);
}
// Constructor.
TrayIcon::TrayIcon ( QWidget *pParent, const char *pszName, const QPixmap &pm, const char *pszLabel = NULL)
: QLabel(pParent, pszName, WMouseNoMask | WRepaintNoErase | WType_TopLevel | WStyle_Customize | WStyle_NoBorder | WStyle_StaysOnTop)
{
QLabel::setMinimumSize(22, 22);
QLabel::setBackgroundMode(Qt::X11ParentRelative);
QLabel::setBackgroundOrigin(QWidget::WindowOrigin);
Display *dpy = qt_xdisplay();
WId trayWin = winId();
// System Tray Protocol Specification.
Screen *screen = XDefaultScreenOfDisplay(dpy);
int iScreen = XScreenNumberOfScreen(screen);
char szAtom[32];
snprintf(szAtom, sizeof(szAtom), "_NET_SYSTEM_TRAY_S%d", iScreen);
Atom selectionAtom = XInternAtom(dpy, szAtom, false);
XGrabServer(dpy);
Window managerWin = XGetSelectionOwner(dpy, selectionAtom);
if (managerWin != None)
XSelectInput(dpy, managerWin, StructureNotifyMask);
XUngrabServer(dpy);
XFlush(dpy);
if (managerWin != None) {
XEvent ev;
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = managerWin;
ev.xclient.message_type = XInternAtom(dpy, "_NET_SYSTEM_TRAY_OPCODE", false);
ev.xclient.format = 32;
ev.xclient.data.l[0] = CurrentTime;
ev.xclient.data.l[1] = SYSTEM_TRAY_REQUEST_DOCK;
ev.xclient.data.l[2] = trayWin;
ev.xclient.data.l[3] = 0;
ev.xclient.data.l[4] = 0;
XSendEvent(dpy, managerWin, false, NoEventMask, &ev);
XSync(dpy, false);
}
Atom trayAtom;
// For older KDE's (hopefully)...
int data = 1;
trayAtom = XInternAtom(dpy, "KWM_DOCKWINDOW", false);
XChangeProperty(dpy, trayWin, trayAtom, trayAtom, 32, PropModeReplace, (unsigned char *) &data, 1);
// For not so older KDE's...
WId forWin = pParent ? pParent->topLevelWidget()->winId() : qt_xrootwin();
trayAtom = XInternAtom(dpy, "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", false);
XChangeProperty(dpy, trayWin, trayAtom, XA_WINDOW, 32, PropModeReplace, (unsigned char *) &forWin, 1);
setPixmap(pm);
if (pszLabel) {
QToolTip::add(this, pszLabel);
}
}
/*----------------------------------------------------------------------*/
/* extern */ Dimension
XfeScreenWidth(Widget w)
{
assert( _XfeIsAlive(w) );
if (!_XfeIsAlive(w))
{
return 0;
}
return DisplayWidth(XtDisplay(w),XScreenNumberOfScreen(_XfeScreen(w)));
}
static Boolean
XmuCvtStringToXftColor(Display *dpy,
XrmValue *args, Cardinal *num_args,
XrmValue *fromVal, XrmValue *toVal,
XtPointer *converter_data)
{
char *spec;
XRenderColor renderColor;
XftColor xftColor;
Screen *screen;
Colormap colormap;
if (*num_args != 2)
{
XtAppErrorMsg (XtDisplayToApplicationContext (dpy),
"cvtStringToXftColor", "wrongParameters",
"XtToolkitError",
"String to render color conversion needs screen and colormap arguments",
(String *) NULL, (Cardinal *)NULL);
return False;
}
screen = *((Screen **) args[0].addr);
colormap = *((Colormap *) args[1].addr);
spec = (char *) fromVal->addr;
if (strcasecmp (spec, XtDefaultForeground) == 0)
{
renderColor.red = 0;
renderColor.green = 0;
renderColor.blue = 0;
renderColor.alpha = 0xffff;
}
else if (strcasecmp (spec, XtDefaultBackground) == 0)
{
renderColor.red = 0xffff;
renderColor.green = 0xffff;
renderColor.blue = 0xffff;
renderColor.alpha = 0xffff;
}
else if (!XRenderParseColor (dpy, spec, &renderColor))
return False;
if (!XftColorAllocValue (dpy,
DefaultVisual (dpy,
XScreenNumberOfScreen (screen)),
colormap,
&renderColor,
&xftColor))
return False;
donestr (XftColor, xftColor, XtRXftColor);
}
void
meta_ui_theme_get_frame_borders (MetaUI *ui,
MetaFrameType type,
MetaFrameFlags flags,
MetaFrameBorders *borders)
{
int text_height;
GtkStyleContext *style = NULL;
PangoContext *context;
const PangoFontDescription *font_desc;
PangoFontDescription *free_font_desc = NULL;
if (meta_ui_have_a_theme ())
{
context = gtk_widget_get_pango_context (GTK_WIDGET (ui->frames));
font_desc = meta_prefs_get_titlebar_font ();
if (!font_desc)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (ui->xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, XScreenNumberOfScreen (ui->xscreen));
GtkWidgetPath *widget_path;
style = gtk_style_context_new ();
gtk_style_context_set_screen (style, screen);
widget_path = gtk_widget_path_new ();
gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW);
gtk_style_context_set_path (style, widget_path);
gtk_widget_path_free (widget_path);
gtk_style_context_get (style, GTK_STATE_FLAG_NORMAL, "font", &free_font_desc, NULL);
font_desc = (const PangoFontDescription *) free_font_desc;
}
text_height = meta_pango_font_desc_get_text_height (font_desc, context);
meta_theme_get_frame_borders (meta_theme_get_current (),
type, text_height, flags,
borders);
if (free_font_desc)
pango_font_description_free (free_font_desc);
}
else
{
meta_frame_borders_clear (borders);
}
if (style != NULL)
g_object_unref (style);
}
// Cancel plot
static void popdown_plot_shell(PlotWindowInfo *plot)
{
static bool entered = false;
if (entered)
return;
entered = true;
// Manage dialogs
if (plot->working_dialog != 0)
XtUnmanageChild(plot->working_dialog);
if (plot->command_dialog != 0)
XtUnmanageChild(plot->command_dialog);
if (plot->export_dialog != 0)
XtUnmanageChild(plot->export_dialog);
if (plot->shell != 0)
{
XWithdrawWindow(XtDisplay(plot->shell), XtWindow(plot->shell),
XScreenNumberOfScreen(XtScreen(plot->shell)));
XtPopdown(plot->shell);
// XtPopdown may not withdraw an iconified shell. Hence, make
// sure the shell really becomes disabled.
XtSetSensitive(plot->shell, False);
}
// Manage settings
if (plot->settings_timer != 0)
{
// Still waiting for settings
XtRemoveTimeOut(plot->settings_timer);
plot->settings_timer = 0;
unlink(plot->settings_file.chars());
}
if (plot->settings_delay != 0)
{
plot->settings_delay->outcome = "canceled";
delete plot->settings_delay;
plot->settings_delay = 0;
}
plot->settings = "";
plot->active = false;
entered = false;
}
XdkScreen * xdk_display_lookup_screen(XdkDisplay * self, Screen * screen)
{
g_return_val_if_fail(self, NULL);
g_return_val_if_fail(screen, NULL);
XdkDisplayPrivate * priv = self->priv;
gint screen_number = XScreenNumberOfScreen(screen);
if(screen_number <= 0 || screen_number >= priv->screens->len) {
return NULL;
}
return g_ptr_array_index(priv->screens, screen_number);
}
bool DockWnd::x11Event(XEvent *e)
{
if (e->type == ClientMessage){
if (!inTray){
Atom xembed_atom = XInternAtom( qt_xdisplay(), "_XEMBED", FALSE );
if (e->xclient.message_type == xembed_atom){
inTray = true;
bInit = true;
if (wharfIcon){
delete wharfIcon;
wharfIcon = NULL;
}
reset();
}
}
}
if ((e->type == ReparentNotify) && !bInit && inNetTray){
Display *dsp = qt_xdisplay();
if (e->xreparent.parent == XRootWindow(dsp,
XScreenNumberOfScreen(XDefaultScreenOfDisplay(dsp)))){
inNetTray = false;
}else{
inTray = true;
if (wharfIcon){
delete wharfIcon;
wharfIcon = NULL;
}
bInit = true;
move(0, 0);
resize(22, 22);
XResizeWindow(dsp, winId(), 22, 22);
reset();
}
}
if (((e->type == FocusIn) || (e->type == Expose)) && !bInit){
if (wharfIcon){
delete wharfIcon;
wharfIcon = NULL;
}
if (!inTray){
bInit = true;
setFocusPolicy(NoFocus);
move(pMain->getDockX(), pMain->getDockY());
reset();
}
}
return QWidget::x11Event(e);
}
