#include "obrender/render.h"
#include "gettext.h"
#include "obt/display.h"
+#include "obt/xqueue.h"
#include "obt/prop.h"
#ifdef HAVE_UNISTD_H
static void client_call_notifies(ObClient *self, GSList *list);
static void client_ping_event(ObClient *self, gboolean dead);
static void client_prompt_kill(ObClient *self);
-static gboolean client_can_steal_focus(ObClient *self, Time steal_time,
- Time launch_time);
+static gboolean client_can_steal_focus(ObClient *self,
+ gboolean allow_other_desktop,
+ gboolean request_from_user,
+ Time steal_time, Time launch_time);
+static void client_setup_default_decor_and_functions(ObClient *self);
+static void client_setup_decor_undecorated(ObClient *self);
void client_startup(gboolean reconfig)
{
- if ((client_default_icon = RrImageCacheFind(ob_rr_icons,
- ob_rr_theme->def_win_icon,
- ob_rr_theme->def_win_icon_w,
- ob_rr_theme->def_win_icon_h)))
- RrImageRef(client_default_icon);
- else {
- client_default_icon = RrImageNew(ob_rr_icons);
- RrImageAddPicture(client_default_icon,
- ob_rr_theme->def_win_icon,
- ob_rr_theme->def_win_icon_w,
- ob_rr_theme->def_win_icon_h);
- }
+ client_default_icon = RrImageNewFromData(
+ ob_rr_icons, ob_rr_theme->def_win_icon,
+ ob_rr_theme->def_win_icon_w, ob_rr_theme->def_win_icon_h);
if (reconfig) return;
}
}
+void client_remove_destroy_notify_data(ObClientCallback func, gpointer data)
+{
+ GSList *it;
+
+ for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
+ ClientCallback *d = it->data;
+ if (d->func == func && d->data == data) {
+ g_slice_free(ClientCallback, d);
+ client_destroy_notifies =
+ g_slist_delete_link(client_destroy_notifies, it);
+ break;
+ }
+ }
+}
+
void client_set_list(void)
{
Window *windows, *win_it;
{
ObClient *self;
XSetWindowAttributes attrib_set;
- gboolean activate = FALSE;
+ gboolean try_activate = FALSE;
+ gboolean do_activate;
ObAppSettings *settings;
gboolean transient = FALSE;
Rect place;
Time launch_time;
guint32 user_time;
gboolean obplaced;
+ gulong ignore_start;
ob_debug("Managing window: 0x%lx", window);
- /* we want to always have a valid time when the window is mapping */
- g_assert(event_curtime != CurrentTime);
-
/* choose the events we want to receive on the CLIENT window
(ObPrompt windows can request events too) */
attrib_set.event_mask = CLIENT_EVENTMASK |
that needs to be freed with g_free(). */
settings = client_get_settings_state(self);
- /* now we have all of the window's information so we can set this up.
- do this before creating the frame, so it can tell that we are still
- mapping and doesn't go applying things right away */
- client_setup_decor_and_functions(self, FALSE);
+ /* the session should get the last say though */
+ client_restore_session_state(self);
+
+ /* the per-app settings/session may have changed the decorations for
+ the window, so we setup decorations for that here. this is a special
+ case because we want to place the window according to these decoration
+ changes.
+ we do this before setting up the frame so that it will reflect the
+ decorations of the window as it will be placed on screen.
+ */
+ client_setup_decor_undecorated(self);
/* specify that if we exit, the window should not be destroyed and
should be reparented back to root automatically, unless we are managing
time now */
grab_server(FALSE);
- /* the session should get the last say though */
- client_restore_session_state(self);
+ /* this needs to occur once we have a frame, since it sets a property on
+ the frame */
+ client_update_opacity(self);
+
+ /* don't put helper/modal windows on a different desktop if they are
+ related to the focused window. */
+ if (!screen_compare_desktops(self->desktop, screen_desktop) &&
+ focus_client && client_search_transient(focus_client, self) &&
+ (client_helper(self) || self->modal))
+ {
+ self->desktop = screen_desktop;
+ }
/* tell startup notification that this app started */
launch_time = sn_app_started(self->startup_id, self->class, self->name);
if (!OBT_PROP_GET32(self->window, NET_WM_USER_TIME, CARDINAL, &user_time))
- user_time = event_curtime;
+ user_time = event_time();
/* do this after we have a frame.. it uses the frame to help determine the
WM_STATE to apply. */
if (ob_state() != OB_STATE_STARTING &&
(!self->session || self->session->focused) &&
/* this means focus=true for window is same as config_focus_new=true */
- ((config_focus_new || (settings && settings->focus == 1)) ||
+ ((config_focus_new || settings->focus == 1) ||
client_search_focus_tree_full(self)) &&
/* NET_WM_USER_TIME 0 when mapping means don't focus */
(user_time != 0) &&
/* this checks for focus=false for the window */
- (!settings || settings->focus != 0) &&
+ settings->focus != 0 &&
focus_valid_target(self, self->desktop,
FALSE, FALSE, TRUE, TRUE, FALSE, FALSE,
settings->focus == 1))
{
- activate = TRUE;
+ try_activate = TRUE;
}
/* remove the client's border */
/* where the frame was placed is where the window was originally */
place = self->area;
+ ob_debug("Going to try activate new window? %s",
+ try_activate ? "yes" : "no");
+ if (try_activate)
+ do_activate = client_can_steal_focus(
+ self, settings->focus == 1,
+ (!!launch_time || settings->focus == 1),
+ event_time(), launch_time);
+ else
+ do_activate = FALSE;
+
/* figure out placement for the window if the window is new */
if (ob_state() == OB_STATE_RUNNING) {
ob_debug("Positioned: %s @ %d %d",
"program + user specified" :
"BADNESS !?")))), place.width, place.height);
- obplaced = place_client(self, &place.x, &place.y, settings);
+ obplaced = place_client(self, do_activate, &place.x, &place.y,
+ settings);
/* watch for buggy apps that ask to be placed at (0,0) when there is
a strut there */
(self->type == OB_CLIENT_TYPE_DIALOG ||
self->type == OB_CLIENT_TYPE_SPLASH ||
(!((self->positioned & USPosition) ||
- (settings && settings->pos_given)) &&
+ settings->pos_given) &&
client_normal(self) &&
!self->session &&
/* don't move oldschool fullscreen windows to
client_apply_startup_state(self, place.x, place.y,
place.width, place.height);
- ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s",
- activate ? "yes" : "no");
- if (activate) {
- activate = client_can_steal_focus(self, event_curtime, launch_time);
+ /* set the initial value of the desktop hint, when one wasn't requested
+ on map. */
+ OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop);
+
+ /* grab mouse bindings before showing the window */
+ mouse_grab_for_client(self, TRUE);
+
+ if (!config_focus_under_mouse)
+ ignore_start = event_start_ignore_all_enters();
+
+ /* this has to happen before we try focus the window, but we want it to
+ happen after the client's stacking has been determined or it looks bad
+ */
+ client_show(self);
- if (!activate) {
+ /* activate/hilight/raise the window */
+ if (try_activate) {
+ if (do_activate) {
+ gboolean stacked = client_restore_session_stacking(self);
+ client_present(self, FALSE, !stacked, TRUE);
+ }
+ else {
/* if the client isn't stealing focus, then hilite it so the user
knows it is there, but don't do this if we're restoring from a
session */
stacking_raise(CLIENT_AS_WINDOW(self));
}
- mouse_grab_for_client(self, TRUE);
-
- /* this has to happen before we try focus the window, but we want it to
- happen after the client's stacking has been determined or it looks bad
- */
- {
- gulong ignore_start;
- if (!config_focus_under_mouse)
- ignore_start = event_start_ignore_all_enters();
-
- client_show(self);
-
- if (!config_focus_under_mouse)
- event_end_ignore_all_enters(ignore_start);
- }
-
- if (activate) {
- gboolean stacked = client_restore_session_stacking(self);
- client_present(self, FALSE, !stacked, TRUE);
- }
+ if (!config_focus_under_mouse)
+ event_end_ignore_all_enters(ignore_start);
/* add to client list/map */
client_list = g_list_append(client_list, self);
uses too. this returns a shallow copy that needs to be freed */
settings = client_get_settings_state(self);
- client_setup_decor_and_functions(self, FALSE);
-
/* create the decoration frame for the client window and adjust its size */
self->frame = frame_new(self);
- frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
+
+ client_apply_startup_state(self, self->area.x, self->area.y,
+ self->area.width, self->area.height);
ob_debug("gave extents left %d right %d top %d bottom %d",
self->frame->size.left, self->frame->size.right,
g_slice_free(ObClient, self);
}
-static gboolean client_can_steal_focus(ObClient *self, Time steal_time,
+static gboolean client_can_steal_focus(ObClient *self,
+ gboolean allow_other_desktop,
+ gboolean request_from_user,
+ Time steal_time,
Time launch_time)
{
gboolean steal;
gboolean relative_focused;
- gboolean parent_focused;
steal = TRUE;
- parent_focused = (focus_client != NULL &&
- client_search_focus_parent(self));
relative_focused = (focus_client != NULL &&
(client_search_focus_tree_full(self) != NULL ||
client_search_focus_group_full(self) != NULL));
/* This is focus stealing prevention */
- ob_debug_type(OB_DEBUG_FOCUS,
- "Want to focus window 0x%x at time %u "
- "launched at %u (last user interaction time %u)",
- self->window, steal_time, launch_time,
- event_last_user_time);
-
- /* if it's on another desktop */
- if (!(self->desktop == screen_desktop ||
- self->desktop == DESKTOP_ALL) &&
- /* the timestamp is from before you changed desktops */
- (!launch_time ||
- (screen_desktop_user_time &&
- !event_time_after(launch_time, screen_desktop_user_time))))
- {
- steal = FALSE;
- ob_debug_type(OB_DEBUG_FOCUS,
- "Not focusing the window because its on another "
- "desktop\n");
+ ob_debug("Want to focus window 0x%x at time %u "
+ "launched at %u (last user interaction time %u) "
+ "request from %s, allow other desktop: %s, "
+ "desktop switch time %u",
+ self->window, steal_time, launch_time,
+ event_last_user_time,
+ (request_from_user ? "user" : "other"),
+ (allow_other_desktop ? "yes" : "no"),
+ screen_desktop_user_time);
+
+ /*
+ if no launch time is provided for an application, make one up.
+
+ if the window is related to other existing windows
+ and one of those windows was the last used
+ then we will give it a launch time equal to the last user time,
+ which will end up giving the window focus probably.
+ else
+ the window is related to other windows, but you are not working in
+ them?
+ seems suspicious, so we will give it a launch time of
+ NOW - STEAL_INTERVAL,
+ so it will be given focus only if we didn't use something else
+ during the steal interval.
+ else
+ the window is all on its own, so we can't judge it. give it a launch
+ time equal to the last user time, so it will probably take focus.
+
+ this way running things from a terminal will give them focus, but popups
+ without a launch time shouldn't steal focus so easily.
+ */
+
+ if (!launch_time) {
+ if (client_has_relative(self)) {
+ if (event_last_user_time && client_search_focus_group_full(self)) {
+ /* our relative is focused */
+ launch_time = event_last_user_time;
+ ob_debug("Unknown launch time, using %u - window in active "
+ "group", launch_time);
+ }
+ else if (!request_from_user) {
+ /* has relatives which are not being used. suspicious */
+ launch_time = event_time() - OB_EVENT_USER_TIME_DELAY;
+ ob_debug("Unknown launch time, using %u - window in inactive "
+ "group", launch_time);
+ }
+ else {
+ /* has relatives which are not being used, but the user seems
+ to want to go there! */
+ launch_time = event_last_user_time;
+ ob_debug("Unknown launch time, using %u - user request",
+ launch_time);
+ }
+ }
+ else {
+ /* the window is on its own, probably the user knows it is going
+ to appear */
+ launch_time = event_last_user_time;
+ ob_debug("Unknown launch time, using %u - independent window",
+ launch_time);
+ }
+ }
+
+ /* if it's on another desktop
+ and if allow_other_desktop is true, we generally let it steal focus.
+ but if it didn't come from the user, don't let it steal unless it was
+ launched before the user switched desktops.
+ focus, unless it was launched after we changed desktops and the request
+ came from the user
+ */
+ if (!screen_compare_desktops(screen_desktop, self->desktop)) {
+ /* must be allowed */
+ if (!allow_other_desktop) {
+ steal = FALSE;
+ ob_debug("Not focusing the window because its on another desktop");
+ }
+ /* if we don't know when the desktop changed, but request is from an
+ application, don't let it change desktop on you */
+ else if (!request_from_user) {
+ steal = FALSE;
+ ob_debug("Not focusing the window because non-user request");
+ }
}
/* If something is focused... */
else if (focus_client) {
/* If the user is working in another window right now, then don't
steal focus */
- if (!parent_focused &&
- event_last_user_time && launch_time &&
- event_time_after(event_last_user_time, launch_time) &&
- event_last_user_time != launch_time &&
+ if (!relative_focused &&
+ event_last_user_time &&
+ /* last user time must be strictly > launch_time to block focus */
+ (event_time_after(event_last_user_time, launch_time) &&
+ event_last_user_time != launch_time) &&
event_time_after(event_last_user_time,
steal_time - OB_EVENT_USER_TIME_DELAY))
{
steal = FALSE;
- ob_debug_type(OB_DEBUG_FOCUS,
- "Not focusing the window because the user is "
- "working in another window that is not "
- "its parent");
- }
- /* If the new window is a transient (and its relatives aren't
- focused) */
- else if (client_has_parent(self) && !relative_focused) {
- steal = FALSE;
- ob_debug_type(OB_DEBUG_FOCUS,
- "Not focusing the window because it is a "
- "transient, and its relatives aren't focused");
- }
- /* Don't steal focus from globally active clients.
- I stole this idea from KWin. It seems nice.
- */
- else if (!(focus_client->can_focus ||
- focus_client->focus_notify))
- {
- steal = FALSE;
- ob_debug_type(OB_DEBUG_FOCUS,
- "Not focusing the window because a globally "
- "active client has focus");
+ ob_debug("Not focusing the window because the user is "
+ "working in another window that is not its relative");
}
/* Don't move focus if it's not going to go to this window
anyway */
else if (client_focus_target(self) != self) {
steal = FALSE;
- ob_debug_type(OB_DEBUG_FOCUS,
- "Not focusing the window because another window "
- "would get the focus anyway");
+ ob_debug("Not focusing the window because another window "
+ "would get the focus anyway");
}
- /* Don't move focus if the window is not visible on the current
- desktop and none of its relatives are focused */
- else if (!(self->desktop == screen_desktop ||
- self->desktop == DESKTOP_ALL) &&
- !relative_focused)
- {
- steal = FALSE;
- ob_debug_type(OB_DEBUG_FOCUS,
- "Not focusing the window because it is on "
- "another desktop and no relatives are focused ");
+ /* For requests that don't come from the user */
+ else if (!request_from_user) {
+ /* If the new window is a transient (and its relatives aren't
+ focused) */
+ if (client_has_parent(self) && !relative_focused) {
+ steal = FALSE;
+ ob_debug("Not focusing the window because it is a "
+ "transient, and its relatives aren't focused");
+ }
+ /* Don't steal focus from globally active clients.
+ I stole this idea from KWin. It seems nice.
+ */
+ else if (!(focus_client->can_focus || focus_client->focus_notify))
+ {
+ steal = FALSE;
+ ob_debug("Not focusing the window because a globally "
+ "active client has focus");
+ }
+ /* Don't move focus if the window is not visible on the current
+ desktop and none of its relatives are focused */
+ else if (!allow_other_desktop &&
+ !screen_compare_desktops(self->desktop, screen_desktop) &&
+ !relative_focused)
+ {
+ steal = FALSE;
+ ob_debug("Not focusing the window because it is on "
+ "another desktop and no relatives are focused ");
+ }
}
}
if (!steal)
- ob_debug_type(OB_DEBUG_FOCUS,
- "Focus stealing prevention activated for %s at "
- "time %u (last user interaction time %u)",
- self->title, steal_time, event_last_user_time);
+ ob_debug("Focus stealing prevention activated for %s at "
+ "time %u (last user interaction time %u)",
+ self->title, steal_time, event_last_user_time);
+ else
+ ob_debug("Allowing focus stealing for %s at time %u (last user "
+ "interaction time %u)",
+ self->title, steal_time, event_last_user_time);
return steal;
}
client_get_mwm_hints(self);
/* this can change the mwmhints for special cases */
client_get_type_and_transientness(self);
- client_get_state(self);
client_update_normal_hints(self);
+ /* set up the maximum possible decor/functions */
+ client_setup_default_decor_and_functions(self);
+
+ client_get_state(self);
+
/* get the session related properties, these can change decorations
from per-app settings */
client_get_session_ids(self);
static void client_get_startup_id(ObClient *self)
{
- if (!(OBT_PROP_GETS(self->window, NET_STARTUP_ID, utf8,
- &self->startup_id)))
+ if (!(OBT_PROP_GETS_UTF8(self->window, NET_STARTUP_ID, &self->startup_id)))
if (self->group)
- OBT_PROP_GETS(self->group->leader,
- NET_STARTUP_ID, utf8, &self->startup_id);
+ OBT_PROP_GETS_UTF8(self->group->leader, NET_STARTUP_ID,
+ &self->startup_id);
}
static void client_get_area(ObClient *self)
if (OBT_PROP_GET32(self->window, NET_WM_SYNC_REQUEST_COUNTER, CARDINAL,&i))
{
+ XSyncValue val;
+
self->sync_counter = i;
+
+ /* this must be set when managing a new window according to EWMH */
+ XSyncIntToValue(&val, 0);
+ XSyncSetCounter(obt_display, self->sync_counter, val);
} else
self->sync_counter = None;
}
self->colormap = colormap;
}
+void client_update_opacity(ObClient *self)
+{
+ guint32 o;
+
+ if (OBT_PROP_GET32(self->window, NET_WM_WINDOW_OPACITY, CARDINAL, &o))
+ OBT_PROP_SET32(self->frame->window, NET_WM_WINDOW_OPACITY, CARDINAL, o);
+ else
+ OBT_PROP_ERASE(self->frame->window, NET_WM_WINDOW_OPACITY);
+}
+
void client_update_normal_hints(ObClient *self)
{
XSizeHints size;
ob_debug("Normal hints: not set");
}
-void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
+static void client_setup_default_decor_and_functions(ObClient *self)
{
/* start with everything (cept fullscreen) */
self->decorations =
break;
}
+ /* If the client has no decor from its type (which never changes) then
+ don't allow the user to "undecorate" the window. Otherwise, allow them
+ to, even if there are motif hints removing the decor, because those
+ may change these days (e.g. chromium) */
+ if (self->decorations == 0)
+ self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
+
/* Mwm Hints are applied subtractively to what has already been chosen for
decor and functionality */
if (self->mwmhints.flags & OB_MWM_FLAG_DECORATIONS) {
self->functions &= ~OB_CLIENT_FUNC_MAXIMIZE;
self->decorations &= ~OB_FRAME_DECOR_MAXIMIZE;
}
+}
- if (self->max_horz && self->max_vert) {
- /* you can't resize fully maximized windows */
- self->functions &= ~OB_CLIENT_FUNC_RESIZE;
- /* kill the handle on fully maxed windows */
- self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
- }
-
- /* If there are no decorations to remove, don't allow the user to try
- toggle the state */
- if (self->decorations == 0)
- self->functions &= ~OB_CLIENT_FUNC_UNDECORATE;
-
- /* finally, the user can have requested no decorations, which overrides
- everything (but doesnt give it a border if it doesnt have one) */
+/*! Set up decor for a client based on its undecorated state. */
+static void client_setup_decor_undecorated(ObClient *self)
+{
+ /* If the user requested no decorations, then remove all the decorations,
+ except the border. But don't add a border if there wasn't one. */
if (self->undecorated)
self->decorations &= (config_theme_keepborder ?
OB_FRAME_DECOR_BORDER : 0);
+}
+
+void client_setup_decor_and_functions(ObClient *self, gboolean reconfig)
+{
+ client_setup_default_decor_and_functions(self);
+
+ client_setup_decor_undecorated(self);
+
+ if (self->max_horz && self->max_vert) {
+ /* once upon a time you couldn't resize maximized windows, that is not
+ the case any more though !
+
+ but do kill the handle on fully maxed windows */
+ self->decorations &= ~(OB_FRAME_DECOR_HANDLE | OB_FRAME_DECOR_GRIPS);
+ }
/* if we don't have a titlebar, then we cannot shade! */
if (!(self->decorations & OB_FRAME_DECOR_TITLEBAR))
client_change_allowed_actions(self);
if (reconfig)
- /* force reconfigure to make sure decorations are updated */
- client_reconfigure(self, TRUE);
+ /* reconfigure to make sure decorations are updated */
+ client_reconfigure(self, FALSE);
}
static void client_change_allowed_actions(ObClient *self)
g_free(self->original_title);
/* try netwm */
- if (!OBT_PROP_GETS(self->window, NET_WM_NAME, utf8, &data)) {
+ if (!OBT_PROP_GETS_UTF8(self->window, NET_WM_NAME, &data)) {
/* try old x stuff */
- if (!(OBT_PROP_GETS(self->window, WM_NAME, locale, &data)
- || OBT_PROP_GETS(self->window, WM_NAME, utf8, &data))) {
+ if (!OBT_PROP_GETS(self->window, WM_NAME, &data)) {
if (self->transient) {
- /*
- GNOME alert windows are not given titles:
- http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
- */
+ /*
+ GNOME alert windows are not given titles:
+ http://developer.gnome.org/projects/gup/hig/draft_hig_new/windows-alert.html
+ */
data = g_strdup("");
} else
data = g_strdup(_("Unnamed Window"));
g_free(data);
}
- OBT_PROP_SETS(self->window, NET_WM_VISIBLE_NAME, utf8, visible);
+ OBT_PROP_SETS(self->window, NET_WM_VISIBLE_NAME, visible);
self->title = visible;
if (self->frame)
g_free(self->icon_title);
/* try netwm */
- if (!OBT_PROP_GETS(self->window, NET_WM_ICON_NAME, utf8, &data))
+ if (!OBT_PROP_GETS_UTF8(self->window, NET_WM_ICON_NAME, &data))
/* try old x stuff */
- if (!(OBT_PROP_GETS(self->window, WM_ICON_NAME, locale, &data) ||
- OBT_PROP_GETS(self->window, WM_ICON_NAME, utf8, &data)))
+ if (!OBT_PROP_GETS(self->window, WM_ICON_NAME, &data))
data = g_strdup(self->title);
if (self->client_machine) {
g_free(data);
}
- OBT_PROP_SETS(self->window, NET_WM_VISIBLE_ICON_NAME, utf8, visible);
+ OBT_PROP_SETS(self->window, NET_WM_VISIBLE_ICON_NAME, visible);
self->icon_title = visible;
}
guint num;
guint32 *data;
guint w, h, i, j;
- guint num_seen; /* number of icons present */
RrImage *img;
img = NULL;
if (OBT_PROP_GETA32(self->window, NET_WM_ICON, CARDINAL, &data, &num)) {
/* figure out how many valid icons are in here */
i = 0;
- num_seen = 0;
while (i + 2 < num) { /* +2 is to make sure there is a w and h */
w = data[i++];
h = data[i++];
/* watch for the data being too small for the specified size,
or for zero sized icons. */
- if (i + w*h > num || w == 0 || h == 0) break;
+ if (i + w*h > num || w == 0 || h == 0) {
+ i += w*h;
+ continue;
+ }
/* convert it to the right bit order for ObRender */
for (j = 0; j < w*h; ++j)
(((data[i+j] >> 8) & 0xff) << RrDefaultGreenOffset) +
(((data[i+j] >> 0) & 0xff) << RrDefaultBlueOffset);
- /* is it in the cache? */
- img = RrImageCacheFind(ob_rr_icons, &data[i], w, h);
- if (img) RrImageRef(img); /* own it */
+ /* add it to the image cache as an original */
+ if (!img)
+ img = RrImageNewFromData(ob_rr_icons, &data[i], w, h);
+ else
+ RrImageAddFromData(img, &data[i], w, h);
i += w*h;
- ++num_seen;
-
- /* don't bother looping anymore if we already found it in the cache
- since we'll just use that! */
- if (img) break;
- }
-
- /* if it's not in the cache yet, then add it to the cache now.
- we have already converted it to the correct bit order above */
- if (!img && num_seen > 0) {
- img = RrImageNew(ob_rr_icons);
- i = 0;
- for (j = 0; j < num_seen; ++j) {
- w = data[i++];
- h = data[i++];
- RrImageAddPicture(img, &data[i], w, h);
- i += w*h;
- }
}
g_free(data);
if (xicon) {
if (w > 0 && h > 0) {
- /* is this icon in the cache yet? */
- img = RrImageCacheFind(ob_rr_icons, data, w, h);
- if (img) RrImageRef(img); /* own it */
-
- /* if not, then add it */
- if (!img) {
- img = RrImageNew(ob_rr_icons);
- RrImageAddPicture(img, data, w, h);
- }
+ if (!img)
+ img = RrImageNewFromData(ob_rr_icons, data, w, h);
+ else
+ RrImageAddFromData(img, data, w, h);
}
g_free(data);
leader = None;
/* get the SM_CLIENT_ID */
- got = FALSE;
- if (leader)
- got = OBT_PROP_GETS(leader, SM_CLIENT_ID, locale, &self->sm_client_id);
- if (!got)
- OBT_PROP_GETS(self->window, SM_CLIENT_ID, locale, &self->sm_client_id);
+ if (leader && leader != self->window)
+ OBT_PROP_GETS_XPCS(leader, SM_CLIENT_ID, &self->sm_client_id);
+ else
+ OBT_PROP_GETS_XPCS(self->window, SM_CLIENT_ID, &self->sm_client_id);
/* get the WM_CLASS (name and class). make them "" if they are not
provided */
- got = FALSE;
- if (leader)
- got = OBT_PROP_GETSS(leader, WM_CLASS, locale, &ss);
- if (!got)
- got = OBT_PROP_GETSS(self->window, WM_CLASS, locale, &ss);
+ got = OBT_PROP_GETSS_TYPE(self->window, WM_CLASS, STRING_NO_CC, &ss);
if (got) {
if (ss[0]) {
if (self->class == NULL) self->class = g_strdup("");
/* get the WM_WINDOW_ROLE. make it "" if it is not provided */
- got = FALSE;
- if (leader)
- got = OBT_PROP_GETS(leader, WM_WINDOW_ROLE, locale, &s);
- if (!got)
- got = OBT_PROP_GETS(self->window, WM_WINDOW_ROLE, locale, &s);
+ got = OBT_PROP_GETS_XPCS(self->window, WM_WINDOW_ROLE, &s);
if (got)
self->role = s;
got = FALSE;
if (leader)
- got = OBT_PROP_GETSS(leader, WM_COMMAND, locale, &ss);
+ got = OBT_PROP_GETSS(leader, WM_COMMAND, &ss);
if (!got)
- got = OBT_PROP_GETSS(self->window, WM_COMMAND, locale, &ss);
+ got = OBT_PROP_GETSS(self->window, WM_COMMAND, &ss);
if (got) {
/* merge/mash them all together */
/* get the WM_CLIENT_MACHINE */
got = FALSE;
if (leader)
- got = OBT_PROP_GETS(leader, WM_CLIENT_MACHINE, locale, &s);
+ got = OBT_PROP_GETS(leader, WM_CLIENT_MACHINE, &s);
if (!got)
- got = OBT_PROP_GETS(self->window, WM_CLIENT_MACHINE, locale, &s);
+ got = OBT_PROP_GETS(self->window, WM_CLIENT_MACHINE, &s);
if (got) {
gchar localhost[128];
{
const gchar *type;
- OBT_PROP_SETS(self->window, OB_APP_ROLE, utf8, self->role);
- OBT_PROP_SETS(self->window, OB_APP_NAME, utf8, self->name);
- OBT_PROP_SETS(self->window, OB_APP_CLASS, utf8, self->class);
- OBT_PROP_SETS(self->window, OB_APP_TITLE, utf8, self->original_title);
+ OBT_PROP_SETS(self->window, OB_APP_ROLE, self->role);
+ OBT_PROP_SETS(self->window, OB_APP_NAME, self->name);
+ OBT_PROP_SETS(self->window, OB_APP_CLASS, self->class);
+ OBT_PROP_SETS(self->window, OB_APP_TITLE, self->original_title);
switch (self->type) {
case OB_CLIENT_TYPE_NORMAL:
case OB_CLIENT_TYPE_DOCK:
type = "dock"; break;
}
- OBT_PROP_SETS(self->window, OB_APP_TYPE, utf8, type);
+ OBT_PROP_SETS(self->window, OB_APP_TYPE, type);
}
static void client_change_wm_state(ObClient *self)
return self->parents != NULL;
}
+gboolean client_has_children(ObClient *self)
+{
+ return self->transients != NULL;
+}
+
gboolean client_is_oldfullscreen(const ObClient *self,
const Rect *area)
{
static ObStackingLayer calc_layer(ObClient *self)
{
ObStackingLayer l;
- const Rect *monitor, *allmonitors;
-
- monitor = screen_physical_area_monitor(client_monitor(self));
- allmonitors = screen_physical_area_all_monitors();
if (self->type == OB_CLIENT_TYPE_DESKTOP)
l = OB_STACKING_LAYER_DESKTOP;
if (iconic)
client_iconify(self, TRUE, FALSE, TRUE);
- if (fullscreen)
- client_fullscreen(self, TRUE);
if (undecorated)
client_set_undecorated(self, TRUE);
if (shaded)
else if (max_horz)
client_maximize(self, TRUE, 1);
+ /* fullscreen removes the ability to apply other states */
+ if (fullscreen)
+ client_fullscreen(self, TRUE);
+
+ /* make sure client_setup_decor_and_functions() is called at least once */
+ client_setup_decor_and_functions(self, FALSE);
+
/* if the window hasn't been configured yet, then do so now, in fact the
x,y,w,h may _not_ be the same as the area rect, which can end up
meaning that the client isn't properly moved/resized by the fullscreen
self->area = oldarea;
client_configure(self, x, y, w, h, FALSE, TRUE, FALSE);
- /* set the desktop hint, to make sure that it always exists */
- OBT_PROP_SET32(self->window, NET_WM_DESKTOP, CARDINAL, self->desktop);
-
/* nothing to do for the other states:
skip_taskbar
skip_pager
the updated frame dimensions. */
frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
+ /* cap any X windows at the size of an unsigned short */
+ *w = MIN(*w,
+ (gint)G_MAXUSHORT
+ - self->frame->size.left - self->frame->size.right);
+ *h = MIN(*h,
+ (gint)G_MAXUSHORT
+ - self->frame->size.top - self->frame->size.bottom);
+
/* gets the frame's position */
frame_client_gravity(self->frame, x, y);
through this code */
{
gint basew, baseh, minw, minh;
- gint incw, inch;
+ gint incw, inch, maxw, maxh;
gfloat minratio, maxratio;
- incw = self->fullscreen || self->max_horz ? 1 : self->size_inc.width;
- inch = self->fullscreen || self->max_vert ? 1 : self->size_inc.height;
+ incw = self->size_inc.width;
+ inch = self->size_inc.height;
minratio = self->fullscreen || (self->max_horz && self->max_vert) ?
0 : self->min_ratio;
maxratio = self->fullscreen || (self->max_horz && self->max_vert) ?
*w -= basew;
*h -= baseh;
+ /* the sizes to used for maximized */
+ maxw = *w;
+ maxh = *h;
+
/* keep to the increments */
*w /= incw;
*h /= inch;
*w *= incw;
*h *= inch;
+ /* if maximized/fs then don't use the size increments */
+ if (self->fullscreen || self->max_horz) *w = maxw;
+ if (self->fullscreen || self->max_vert) *h = maxh;
+
*w += basew;
*h += baseh;
When user = FALSE, then the request is coming from the application
itself, and we are more strict about when to send a synthetic
ConfigureNotify. We strictly follow the rules of the ICCCM sec 4.1.5
- in this case (if force_reply is true)
+ in this case (or send one if force_reply is true)
When user = TRUE, then the request is coming from "us", like when we
maximize a window or something. In this case we are more lenient. We
used to follow the same rules as above, but _Java_ Swing can't handle
this. So just to appease Swing, when user = TRUE, we always send
a synthetic ConfigureNotify to give the window its root coordinates.
+ Lastly, if force_reply is TRUE, we always send a
+ ConfigureNotify, which is needed during a resize with XSYNCronization.
*/
if ((!user && !resized && (rootmoved || force_reply)) ||
- (user && final && rootmoved))
+ (user && ((!resized && force_reply) || (final && rootmoved))))
{
XEvent event;
/* if it moved between monitors, then this can affect the stacking
layer of this window or others - for fullscreen windows.
also if it changed to/from oldschool fullscreen then its layer may
- change */
- if (screen_find_monitor(&self->frame->area) !=
- screen_find_monitor(&oldframe) ||
- (final && (client_is_oldfullscreen(self, &oldclient) !=
- client_is_oldfullscreen(self, &self->area))))
+ change
+
+ watch out tho, don't try change stacking stuff if the window is no
+ longer being managed !
+ */
+ if (self->managed &&
+ (screen_find_monitor(&self->frame->area) !=
+ screen_find_monitor(&oldframe) ||
+ (final && (client_is_oldfullscreen(self, &oldclient) !=
+ client_is_oldfullscreen(self, &self->area)))))
{
client_calc_layer(self);
}
ob_debug("Window %s going fullscreen (%d)",
self->title, self->fullscreen);
+ if (fs) {
+ /* make sure the window is on some monitor */
+ client_find_onscreen(self, &x, &y, w, h, FALSE);
+ }
+
client_setup_decor_and_functions(self, FALSE);
client_move_resize(self, x, y, w, h);
if (dir == 0 || dir == 2) /* vert */
self->max_vert = max;
+ if (max) {
+ /* make sure the window is on some monitor */
+ client_find_onscreen(self, &x, &y, w, h, FALSE);
+ }
+
client_change_state(self); /* change the state hints on the client */
client_setup_decor_and_functions(self, FALSE);
else {
/* request the client to close with WM_DELETE_WINDOW */
OBT_PROP_MSG_TO(self->window, self->window, WM_PROTOCOLS,
- OBT_PROP_ATOM(WM_DELETE_WINDOW), event_curtime,
+ OBT_PROP_ATOM(WM_DELETE_WINDOW), event_time(),
0, 0, 0, NoEventMask);
/* we're trying to close the window, so see if it is responding. if it
return NULL;
}
-static gboolean client_validate_unmap(ObClient *self, int n)
-{
- XEvent e;
- gboolean ret = TRUE;
-
- if (XCheckTypedWindowEvent(obt_display, self->window, UnmapNotify, &e)) {
- if (n < self->ignore_unmaps) // ignore this one, but look for more
- ret = client_validate_unmap(self, n+1);
- else
- ret = FALSE; // the window is going to become unmanaged
+struct ObClientFindDestroyUnmap {
+ Window window;
+ gint ignore_unmaps;
+};
- /* put them back on the event stack so they end up in the same order */
- XPutBackEvent(obt_display, &e);
- }
-
- return ret;
+static gboolean find_destroy_unmap(XEvent *e, gpointer data)
+{
+ struct ObClientFindDestroyUnmap *find = data;
+ if (e->type == DestroyNotify)
+ return e->xdestroywindow.window == find->window;
+ if (e->type == UnmapNotify && e->xunmap.window == find->window)
+ /* ignore the first $find->ignore_unmaps$ many unmap events */
+ return --find->ignore_unmaps < 0;
+ return FALSE;
}
gboolean client_validate(ObClient *self)
{
- XEvent e;
+ struct ObClientFindDestroyUnmap find;
XSync(obt_display, FALSE); /* get all events on the server */
- if (XCheckTypedWindowEvent(obt_display, self->window, DestroyNotify, &e)) {
- XPutBackEvent(obt_display, &e);
- return FALSE;
- }
-
- if (!client_validate_unmap(self, 0))
+ find.window = self->window;
+ find.ignore_unmaps = self->ignore_unmaps;
+ if (xqueue_exists_local(find_destroy_unmap, &find))
return FALSE;
return TRUE;
gboolean client_focus(ObClient *self)
{
+ if (!client_validate(self)) return FALSE;
+
/* we might not focus this window, so if we have modal children which would
be focused instead, bring them to this desktop */
client_bring_modal_windows(self);
return FALSE;
}
+ /* if we have helper windows they should be there with the window */
+ client_bring_helper_windows(self);
+
ob_debug_type(OB_DEBUG_FOCUS,
"Focusing client \"%s\" (0x%x) at time %u",
- self->title, self->window, event_curtime);
+ self->title, self->window, event_time());
/* if using focus_delay, stop the timer now so that focus doesn't
go moving on us */
/* This can cause a BadMatch error with CurrentTime, or if an app
passed in a bad time for _NET_WM_ACTIVE_WINDOW. */
XSetInputFocus(obt_display, self->window, RevertToPointerRoot,
- event_curtime);
+ event_time());
}
if (self->focus_notify) {
ce.xclient.window = self->window;
ce.xclient.format = 32;
ce.xclient.data.l[0] = OBT_PROP_ATOM(WM_TAKE_FOCUS);
- ce.xclient.data.l[1] = event_curtime;
+ ce.xclient.data.l[1] = event_time();
ce.xclient.data.l[2] = 0l;
ce.xclient.data.l[3] = 0l;
ce.xclient.data.l[4] = 0l;
gboolean here, gboolean raise,
gboolean unshade, gboolean user)
{
- if ((user && (desktop ||
- self->desktop == DESKTOP_ALL ||
- self->desktop == screen_desktop)) ||
- client_can_steal_focus(self, event_curtime, CurrentTime))
- {
+ self = client_focus_target(self);
+
+ if (client_can_steal_focus(self, desktop, user, event_time(), CurrentTime))
client_present(self, here, raise, unshade);
- }
else
client_hilite(self, TRUE);
}
if (((helpers && client_helper(self)) ||
(modals && self->modal)) &&
- ((self->desktop != desktop && self->desktop != DESKTOP_ALL) ||
+ (!screen_compare_desktops(self->desktop, desktop) ||
(iconic && self->iconic)))
{
if (iconic && self->iconic)
}
/* search for edges of clients */
- if (((dir == OB_DIRECTION_NORTH || dir == OB_DIRECTION_SOUTH) &&
- !self->max_vert) ||
- ((dir == OB_DIRECTION_EAST || dir == OB_DIRECTION_WEST) &&
- !self->max_horz))
- {
- for (it = client_list; it; it = g_list_next(it)) {
- ObClient *cur = it->data;
+ for (it = client_list; it; it = g_list_next(it)) {
+ ObClient *cur = it->data;
- /* skip windows to not bump into */
- if (cur == self)
- continue;
- if (cur->iconic)
- continue;
- if (self->desktop != cur->desktop && cur->desktop != DESKTOP_ALL &&
- cur->desktop != screen_desktop)
- continue;
+ /* skip windows to not bump into */
+ if (cur == self)
+ continue;
+ if (cur->iconic)
+ continue;
+ if (self->desktop != cur->desktop && cur->desktop != DESKTOP_ALL &&
+ cur->desktop != screen_desktop)
+ continue;
- ob_debug("trying window %s", cur->title);
+ ob_debug("trying window %s", cur->title);
- detect_edge(cur->frame->area, dir, my_head, my_size, my_edge_start,
- my_edge_size, dest, near_edge);
- }
- dock_get_area(&dock_area);
- detect_edge(dock_area, dir, my_head, my_size, my_edge_start,
+ detect_edge(cur->frame->area, dir, my_head, my_size, my_edge_start,
my_edge_size, dest, near_edge);
}
+ dock_get_area(&dock_area);
+ detect_edge(dock_area, dir, my_head, my_size, my_edge_start,
+ my_edge_size, dest, near_edge);
g_slice_free(Rect, a);
}
return self->group && self->group->members->next;
}
+gboolean client_has_relative(ObClient *self)
+{
+ return client_has_parent(self) ||
+ client_has_group_siblings(self) ||
+ client_has_children(self);
+}
+
/*! Returns TRUE if the client is running on the same machine as Openbox */
gboolean client_on_localhost(ObClient *self)
{