GdkFilterReturn filter_func(GdkXEvent *xevent, GdkEvent *event, gpointer data)
{
#ifdef X_EVENT_WATCHING
static const gchar* event_names[] = {
"undefined",
"undefined",
"KeyPress",
"KeyRelease",
"ButtonPress",
"ButtonRelease",
"MotionNotify",
"EnterNotify",
"LeaveNotify",
"FocusIn",
"FocusOut",
"KeymapNotify",
"Expose",
"GraphicsExpose",
"NoExpose",
"VisibilityNotify",
"CreateNotify",
"DestroyNotify",
"UnmapNotify",
"MapNotify",
"MapRequest",
"ReparentNotify",
"ConfigureNotify",
"ConfigureRequest",
"GravityNotify",
"ResizeRequest",
"CirculateNotify",
"CirculateRequest",
"PropertyNotify",
"SelectionClear",
"SelectionRequest",
"SelectionNotify",
"ColormapNotify",
"ClientMessage",
"MappingNotify"
};
XEvent *xe = (XEvent *) xevent;
g_debug ("%d -> %s (win: %d)", xe->type, event_names[xe->type], xe->xany.window);
if (xe->type == PropertyNotify) {
GdkAtom atom = gdk_x11_xatom_to_atom(xe->xproperty.atom);
g_debug (" Atom: %s (%s)", gdk_atom_name(atom), xe->xproperty.state == PropertyNewValue ? "PropertyNewValue" : "PropertyDelete");
} else if (xe->type == ClientMessage) {
GdkAtom atom = gdk_x11_xatom_to_atom(xe->xclient.message_type);
g_debug (" Atom: %s", gdk_atom_name(atom));
}
#endif
return GDK_FILTER_CONTINUE;
}
static void
DispatchSelectionNotifyEvent(GtkWidget *widget, XEvent *xevent)
{
GdkEvent event;
event.selection.type = GDK_SELECTION_NOTIFY;
event.selection.window = widget->window;
event.selection.selection = gdk_x11_xatom_to_atom(xevent->xselection.selection);
event.selection.target = gdk_x11_xatom_to_atom(xevent->xselection.target);
event.selection.property = gdk_x11_xatom_to_atom(xevent->xselection.property);
event.selection.time = xevent->xselection.time;
gtk_widget_event(widget, &event);
}
char*
meta_text_property_to_utf8 (Display *xdisplay,
const XTextProperty *prop)
{
char **list;
int count;
char *retval;
list = NULL;
count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (prop->encoding),
prop->format,
prop->value,
prop->nitems,
&list);
if (count == 0)
retval = NULL;
else
{
retval = list[0];
list[0] = g_strdup (""); /* something to free */
}
g_strfreev (list);
return retval;
}
static bool wxQueryWMspecSupport(Display* WXUNUSED(display),
Window WXUNUSED(rootWnd),
Atom (feature))
{
GdkAtom gatom = gdk_x11_xatom_to_atom(feature);
return gdk_x11_screen_supports_net_wm_hint(gdk_screen_get_default(), gatom);
}
static char*
text_property_to_utf8 (const XTextProperty *prop)
{
char **list;
int count;
char *retval;
ENTER;
list = NULL;
count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (prop->encoding),
prop->format,
prop->value,
prop->nitems,
&list);
DBG("count=%d\n", count);
if (count == 0)
return NULL;
retval = list[0];
list[0] = g_strdup (""); /* something to free */
g_strfreev (list);
RET(retval);
}
nsresult
compzillaWindow::GetUTF8StringProperty (Atom prop, nsACString& utf8Value)
{
SPEW ("GetUTF8StringProperty this=%p, prop=%s\n", this, XGetAtomName (mDisplay, prop));
Atom actual_type;
int format;
unsigned long nitems;
unsigned long bytes_after_return;
unsigned char *data;
if (XGetWindowProperty (mDisplay,
mWindow,
prop,
0,
BUFSIZ,
false,
AnyPropertyType,
&actual_type,
&format,
&nitems,
&bytes_after_return,
&data) != Success ||
format == None) {
SPEW (" + (Not Found)\n");
return NS_ERROR_FAILURE;
}
if (actual_type == atoms.x.UTF8_STRING) {
utf8Value = (char*)data;
}
else if (actual_type == XA_STRING) {
char **list = NULL;
int count;
count = gdk_text_property_to_utf8_list (gdk_x11_xatom_to_atom (actual_type),
format, data, nitems,
&list);
if (count == 0) {
XFree (data);
return NS_ERROR_FAILURE;
}
utf8Value = list[0];
g_strfreev (list);
}
else {
WARNING ("invalid type for string property '%s': '%s'\n",
XGetAtomName (mDisplay, prop),
XGetAtomName (mDisplay, actual_type));
XFree (data);
return NS_ERROR_FAILURE;
}
XFree (data);
return NS_OK;
}
static bool wxQueryWMspecSupport(Display* WXUNUSED(display),
Window WXUNUSED(rootWnd),
Atom (feature))
{
GdkAtom gatom = gdk_x11_xatom_to_atom(feature);
return gdk_net_wm_supports(gatom);
}
static gboolean get_desktop_window (Window *window)
{
Window *desktop_window;
GdkWindow *root_window;
GdkAtom type_returned;
int format_returned;
int length_returned;
root_window = gdk_screen_get_root_window (
gdk_screen_get_default ());
if (gdk_property_get (root_window,
gdk_atom_intern ("CAJA_DESKTOP_WINDOW_ID", FALSE),
gdk_x11_xatom_to_atom (XA_WINDOW),
0, 4, FALSE,
&type_returned,
&format_returned,
&length_returned,
(guchar**) &desktop_window)) {
*window = *desktop_window;
g_free (desktop_window);
return TRUE;
}
else {
*window = 0;
return FALSE;
}
}
void set_wmspec_dock_hint(GdkWindow *window)
{
GdkAtom atom = gdk_atom_intern ("_NET_WM_WINDOW_TYPE_DOCK", FALSE);
gdk_property_change (window,
gdk_atom_intern ("_NET_WM_WINDOW_TYPE", FALSE),
gdk_x11_xatom_to_atom (XA_ATOM), 32,
GDK_PROP_MODE_REPLACE, (guchar *) &atom, 1);
}
static void
hildon_banner_realize (GtkWidget *widget)
{
GdkWindow *gdkwin;
GdkScreen *screen;
GdkAtom atom;
guint32 portrait = 1;
const gchar *notification_type = "_HILDON_NOTIFICATION_TYPE_BANNER";
HildonBannerPrivate *priv = HILDON_BANNER_GET_PRIVATE (widget);
g_assert (priv);
/* We let the parent to init widget->window before we need it */
if (GTK_WIDGET_CLASS (hildon_banner_parent_class)->realize)
GTK_WIDGET_CLASS (hildon_banner_parent_class)->realize (widget);
/* We use special hint to turn the banner into information notification. */
gdk_window_set_type_hint (widget->window, GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_window_set_transient_for (GTK_WINDOW (widget), (GtkWindow *) priv->parent);
gdkwin = widget->window;
/* Set the _HILDON_NOTIFICATION_TYPE property so Matchbox places the window correctly */
atom = gdk_atom_intern ("_HILDON_NOTIFICATION_TYPE", FALSE);
gdk_property_change (gdkwin, atom, gdk_x11_xatom_to_atom (XA_STRING), 8, GDK_PROP_MODE_REPLACE,
(gpointer) notification_type, strlen (notification_type));
/* HildonBanner supports portrait mode */
atom = gdk_atom_intern ("_HILDON_PORTRAIT_MODE_SUPPORT", FALSE);
gdk_property_change (gdkwin, atom, gdk_x11_xatom_to_atom (XA_CARDINAL), 32,
GDK_PROP_MODE_REPLACE, (gpointer) &portrait, 1);
/* Manage override flag */
if ((priv->require_override_dnd)&&(!priv->overrides_dnd)) {
hildon_banner_set_override_flag (HILDON_BANNER (widget));
priv->overrides_dnd = TRUE;
}
screen = gtk_widget_get_screen (widget);
g_signal_connect (screen, "size-changed", G_CALLBACK (screen_size_changed), widget);
}
static void
hildon_banner_set_override_flag (HildonBanner *banner)
{
guint32 state = 1;
gdk_property_change (GTK_WIDGET (banner)->window,
gdk_atom_intern_static_string ("_HILDON_DO_NOT_DISTURB_OVERRIDE"),
gdk_x11_xatom_to_atom (XA_INTEGER),
32,
GDK_PROP_MODE_REPLACE,
(const guchar*) &state,
1);
}
static void
DispatchPropertyNotifyEvent(GtkWidget *widget, XEvent *xevent)
{
if (((GdkWindowObject *) widget->window)->event_mask & GDK_PROPERTY_CHANGE_MASK) {
GdkEvent event;
event.property.type = GDK_PROPERTY_NOTIFY;
event.property.window = widget->window;
event.property.atom = gdk_x11_xatom_to_atom(xevent->xproperty.atom);
event.property.time = xevent->xproperty.time;
event.property.state = xevent->xproperty.state;
gtk_widget_event(widget, &event);
}
}
static GdkFilterReturn matenu_settings_real_event_filter (XEvent* xevent, GdkEvent* event, MatenuSettings* self) {
GdkFilterReturn result = 0;
g_return_val_if_fail (self != NULL, 0);
g_return_val_if_fail (event != NULL, 0);
switch ((*xevent).type) {
case PropertyNotify:
{
GdkAtom atom_in;
atom_in = gdk_x11_xatom_to_atom ((*xevent).xproperty.atom);
if (matenu_settings_atom_equal (self, self->priv->atom, atom_in)) {
matenu_settings_pull (self);
}
break;
}
}
result = GDK_FILTER_CONTINUE;
return result;
}
static void
set_desktop_window_id (AthenaDesktopWindow *window,
GdkWindow *gdkwindow)
{
/* Tuck the desktop windows xid in the root to indicate we own the desktop.
*/
Window window_xid;
GdkWindow *root_window;
root_window = gdk_screen_get_root_window (
gtk_window_get_screen (GTK_WINDOW (window)));
window_xid = GDK_WINDOW_XID (gdkwindow);
gdk_property_change (root_window,
gdk_atom_intern ("ATHENA_DESKTOP_WINDOW_ID", FALSE),
gdk_x11_xatom_to_atom (XA_WINDOW), 32,
GDK_PROP_MODE_REPLACE, (guchar *) &window_xid, 1);
}
static void
OssoSetWindowOrientation(bool aPortrait)
{
// If we locked the screen, ignore any orientation changes
bool lockScreen = false;
nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
if (prefs)
prefs->GetBoolPref("toolkit.screen.lock", &lockScreen);
if (lockScreen)
return;
// Tell Hildon desktop to force our window to be either portrait or landscape,
// depending on the current rotation
// NOTE: We only update the most recent top-level window so this is only
// suitable for apps with only one window.
nsCOMPtr<nsIDOMWindow> window;
GetMostRecentWindow(EmptyString().get(), getter_AddRefs(window));
GtkWidget* widget = WidgetForDOMWindow(window);
if (widget && widget->window) {
GdkWindow *gdk = widget->window;
GdkAtom request = gdk_atom_intern("_HILDON_PORTRAIT_MODE_REQUEST", FALSE);
if (aPortrait) {
gulong portrait_set = 1;
gdk_property_change(gdk, request, gdk_x11_xatom_to_atom(XA_CARDINAL),
32, GDK_PROP_MODE_REPLACE, (const guchar *) &portrait_set, 1);
}
else {
gdk_property_delete(gdk, request);
}
}
// Update the system info property
nsCOMPtr<nsIWritablePropertyBag2> info = do_GetService("@mozilla.org/system-info;1");
if (info) {
info->SetPropertyAsAString(NS_LITERAL_STRING("screen-orientation"),
aPortrait ? NS_LITERAL_STRING("portrait") : NS_LITERAL_STRING("landscape"));
}
}
/* title_get_text_property */
static int _title_get_text_property(Title * title, Window window, Atom property,
char ** ret)
{
int res;
XTextProperty text;
GdkAtom atom;
int cnt;
char ** list;
int i;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s(title, window, %lu)\n", __func__, property);
#endif
gdk_error_trap_push();
res = XGetTextProperty(GDK_DISPLAY_XDISPLAY(title->display), window,
&text, property);
if(gdk_error_trap_pop() != 0 || res == 0)
return 1;
atom = gdk_x11_xatom_to_atom(text.encoding);
#if GTK_CHECK_VERSION(2, 24, 0)
cnt = gdk_x11_display_text_property_to_text_list(title->display,
atom, text.format, text.value, text.nitems, &list);
#else
cnt = gdk_text_property_to_utf8_list(atom, text.format, text.value,
text.nitems, &list);
#endif
if(cnt > 0)
{
*ret = list[0];
for(i = 1; i < cnt; i++)
g_free(list[i]);
g_free(list);
}
else
*ret = NULL;
if(text.value != NULL)
XFree(text.value);
return 0;
}
gchar *xfce_background_get_current_image()
{
GdkAtom atom;
gint fmt;
gint len;
/*guchar buf[2049];*/
guchar *buf;
buf = NULL;
if (gdk_property_get(
gdk_screen_get_root_window(
gdk_display_get_default_screen(gdk_display_get_default())
),
gdk_atom_intern("XFDESKTOP_IMAGE_FILE_0", FALSE),
gdk_x11_xatom_to_atom(XA_STRING),
0, 2048, 0,
&atom, &fmt, &len,
&buf) && fmt == 8)
{
buf[len] = 0;
return buf;
}
return NULL;
}
/*
* Make the widget a root window. Set its class, set the _NET_WM_WINDOW_TYPE to
* _NET_WM_WINDOW_TYPE_DESKTOP, and set the is_desktop_window property to true.
*/
static void
desktopize(GtkWidget *root)
{
GdkAtom atom;
GdkWindow *gdk_window;
atom = gdk_atom_intern("_NET_WM_WINDOW_TYPE_DESKTOP", FALSE);
gtk_window_set_wmclass(GTK_WINDOW(root), "desktop_window", "Argonaut");
gtk_widget_realize(root);
if ((gdk_window = gtk_widget_get_window(root)) == NULL)
errx(1, "gtk_widget_get_window: cannot get window");
gdk_property_change(gdk_window,
gdk_atom_intern("_NET_WM_WINDOW_TYPE", FALSE),
gdk_x11_xatom_to_atom(XA_ATOM), 32,
GDK_PROP_MODE_REPLACE, (guchar *)&atom, 1);
g_object_set_data(G_OBJECT(root), "is_desktop_window",
GINT_TO_POINTER(1));
}
void
nsCairoScreen::Init ()
{
#ifdef MOZ_ENABLE_GTK2
mAvailRect = mRect = nsRect(0, 0, gdk_screen_width(), gdk_screen_height());
// We need to account for the taskbar, etc in the available rect.
// See http://freedesktop.org/Standards/wm-spec/index.html#id2767771
// XXX It doesn't change that often, but we should probably
// listen for changes to _NET_WORKAREA.
// XXX do we care about _NET_WM_STRUT_PARTIAL? That will
// add much more complexity to the code here (our screen
// could have a non-rectangular shape), but should
// lead to greater accuracy.
#if GTK_CHECK_VERSION(2,2,0)
GdkWindow *root_window = gdk_get_default_root_window();
#else
GdkWindow *root_window = GDK_ROOT_PARENT();
#endif // GTK_CHECK_VERSION(2,2,0)
long *workareas;
GdkAtom type_returned;
int format_returned;
int length_returned;
#if GTK_CHECK_VERSION(2,0,0)
GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
#else
GdkAtom cardinal_atom = (GdkAtom) XA_CARDINAL;
#endif
gdk_error_trap_push();
// gdk_property_get uses (length + 3) / 4, hence G_MAXLONG - 3 here.
if (!gdk_property_get(root_window,
gdk_atom_intern ("_NET_WORKAREA", FALSE),
cardinal_atom,
0, G_MAXLONG - 3, FALSE,
&type_returned,
&format_returned,
&length_returned,
(guchar **) &workareas)) {
// This window manager doesn't support the freedesktop standard.
// Nothing we can do about it, so assume full screen size.
return;
}
// Flush the X queue to catch errors now.
gdk_flush();
if (!gdk_error_trap_pop() &&
type_returned == cardinal_atom &&
length_returned && (length_returned % 4) == 0 &&
format_returned == 32) {
int num_items = length_returned / sizeof(long);
for (int i = 0; i < num_items; i += 4) {
nsRect workarea(workareas[i], workareas[i + 1],
workareas[i + 2], workareas[i + 3]);
if (!mRect.Contains(workarea)) {
NS_WARNING("Invalid bounds");
continue;
}
mAvailRect.IntersectRect(mAvailRect, workarea);
}
}
#elif MOZ_ENABLE_XLIB
mScreenNum = 0;
mRect.x = mAvailRect.x = 0;
mRect.y = mAvailRect.y = 0;
mRect.width = mAvailRect.width = 1600;
mRect.height = mAvailRect.height = 1200;
#endif
}
void
nsScreenGtk :: Init (GdkWindow *aRootWindow)
{
// We listen for configure events on the root window to pick up
// changes to this rect. We could listen for "size_changed" signals
// on the default screen to do this, except that doesn't work with
// versions of GDK predating the GdkScreen object. See bug 256646.
mAvailRect = mRect = nsIntRect(0, 0, gdk_screen_width(), gdk_screen_height());
#ifdef MOZ_X11
// We need to account for the taskbar, etc in the available rect.
// See http://freedesktop.org/Standards/wm-spec/index.html#id2767771
// XXX do we care about _NET_WM_STRUT_PARTIAL? That will
// add much more complexity to the code here (our screen
// could have a non-rectangular shape), but should
// lead to greater accuracy.
long *workareas;
GdkAtom type_returned;
int format_returned;
int length_returned;
#if GTK_CHECK_VERSION(2,0,0)
GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL);
#else
GdkAtom cardinal_atom = (GdkAtom) XA_CARDINAL;
#endif
gdk_error_trap_push();
// gdk_property_get uses (length + 3) / 4, hence G_MAXLONG - 3 here.
if (!gdk_property_get(aRootWindow,
gdk_atom_intern ("_NET_WORKAREA", FALSE),
cardinal_atom,
0, G_MAXLONG - 3, FALSE,
&type_returned,
&format_returned,
&length_returned,
(guchar **) &workareas)) {
// This window manager doesn't support the freedesktop standard.
// Nothing we can do about it, so assume full screen size.
return;
}
// Flush the X queue to catch errors now.
gdk_flush();
if (!gdk_error_trap_pop() &&
type_returned == cardinal_atom &&
length_returned && (length_returned % 4) == 0 &&
format_returned == 32) {
int num_items = length_returned / sizeof(long);
for (int i = 0; i < num_items; i += 4) {
nsIntRect workarea(workareas[i], workareas[i + 1],
workareas[i + 2], workareas[i + 3]);
if (!mRect.Contains(workarea)) {
// Note that we hit this when processing screen size changes,
// since we'll get the configure event before the toolbars have
// been moved. We'll end up cleaning this up when we get the
// change notification to the _NET_WORKAREA property. However,
// we still want to listen to both, so we'll handle changes
// properly for desktop environments that don't set the
// _NET_WORKAREA property.
NS_WARNING("Invalid bounds");
continue;
}
mAvailRect.IntersectRect(mAvailRect, workarea);
}
}
g_free (workareas);
#endif
}
/* stolen from gwmh */
static gpointer
get_typed_property_data (Display *xdisplay,
Window xwindow,
Atom property,
Atom requested_type,
gint *size_p,
guint expected_format)
{
static const guint prop_buffer_lengh = 1024 * 1024;
unsigned char *prop_data = NULL;
Atom type_returned = 0;
unsigned long nitems_return = 0, bytes_after_return = 0;
int format_returned = 0;
gpointer data = NULL;
gboolean abort = FALSE;
g_return_val_if_fail (size_p != NULL, NULL);
*size_p = 0;
gdk_error_trap_push ();
abort = XGetWindowProperty (xdisplay,
xwindow,
property,
0, prop_buffer_lengh,
False,
requested_type,
&type_returned, &format_returned,
&nitems_return,
&bytes_after_return,
&prop_data) != Success;
if (gdk_error_trap_pop () ||
type_returned == None)
abort++;
if (!abort &&
requested_type != AnyPropertyType &&
requested_type != type_returned)
{
/* aparently this can happen for some properties of broken apps, be silent */
abort++;
}
if (!abort && bytes_after_return)
{
g_warning (G_GNUC_PRETTY_FUNCTION "(): Eeek, property has more than %u bytes, stored on harddisk?",
prop_buffer_lengh);
abort++;
}
if (!abort && expected_format && expected_format != format_returned)
{
g_warning (G_GNUC_PRETTY_FUNCTION "(): Expected format (%u) unmatched (%d)",
expected_format, format_returned);
abort++;
}
if (!abort && prop_data && nitems_return && format_returned)
{
switch (format_returned)
{
case 32:
*size_p = nitems_return * 4;
if (sizeof (gulong) == 8)
{
guint32 i, *mem = g_malloc0 (*size_p + 1);
gulong *prop_longs = (gulong*) prop_data;
for (i = 0; i < *size_p / 4; i++)
mem[i] = prop_longs[i];
data = mem;
}
break;
case 16:
*size_p = nitems_return * 2;
break;
case 8:
*size_p = nitems_return;
break;
default:
g_warning ("Unknown property data format with %d bits (extraterrestrial?)",
format_returned);
break;
}
if (!data && *size_p)
{
guint8 *mem = NULL;
if (format_returned == 8 && type_returned == XA_COMPOUND_TEXT)
{
gchar **tlist = NULL;
gint count = gdk_text_property_to_text_list
(gdk_x11_xatom_to_atom (type_returned), 8, prop_data,
nitems_return, &tlist);
if (count && tlist && tlist[0])
{
mem = (guint8 *)g_strdup (tlist[0]);
*size_p = strlen ((char *)mem);
}
if (tlist)
gdk_free_text_list (tlist);
}
if (!mem)
{
mem = g_malloc (*size_p + 1);
memcpy (mem, prop_data, *size_p);
mem[*size_p] = 0;
}
data = mem;
}
}
if (prop_data)
XFree (prop_data);
return data;
}
/**
* gdk_x11_get_xatom_name:
* @xatom: an X atom for GDK's default display
*
* Returns the name of an X atom for GDK's default display. This
* function is meant mainly for debugging, so for convenience, unlike
* <function>XAtomName()</function> and gdk_atom_name(), the result
* doesn't need to be freed. Also, this function will never return %NULL,
* even if @xatom is invalid.
*
* Return value: name of the X atom; this string is owned by GTK+,
* so it shouldn't be modifed or freed.
**/
const gchar *
gdk_x11_get_xatom_name (Atom xatom)
{
return get_atom_name (gdk_x11_xatom_to_atom (xatom));
}
/**
* gdk_x11_get_xatom_name:
* @xatom: an X atom for GDK's default display
*
* Returns the name of an X atom for GDK's default display. This
* function is meant mainly for debugging, so for convenience, unlike
* <function>XAtomName()</function> and gdk_atom_name(), the result
* doesn't need to be freed. Also, this function will never return %NULL,
* even if @xatom is invalid.
*
* Return value: name of the X atom; this string is owned by GTK+,
* so it shouldn't be modifed or freed.
**/
G_CONST_RETURN gchar *
gdk_x11_get_xatom_name (Atom xatom)
{
return get_atom_name (gdk_x11_xatom_to_atom (xatom));
}
