gpointer data;
} ClientCallback;
-GList *client_list = NULL;
+GList *client_list = NULL;
-static GSList *client_destroy_notifies = NULL;
+static GSList *client_destroy_notifies = NULL;
+static RrImage *client_default_icon = NULL;
static void client_get_all(ObClient *self, gboolean real);
static void client_get_startup_id(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);
+ }
+
if (reconfig) return;
client_set_list();
void client_shutdown(gboolean reconfig)
{
+ RrImageUnref(client_default_icon);
+ client_default_icon = NULL;
+
if (reconfig) return;
}
"Not focusing the window because the user is "
"working in another window");
}
- /* If its a transient (and its parents aren't focused) */
+ /* If it's a transient (and its parents aren't focused) */
else if (client_has_parent(self)) {
activate = FALSE;
ob_debug_type(OB_DEBUG_FOCUS,
if (!activate) {
ob_debug_type(OB_DEBUG_FOCUS,
"Focus stealing prevention activated for %s at "
- "time %u (last user interactioon time %u)",
+ "time %u (last user interaction time %u)",
self->title, map_time, event_last_user_time);
/* if the client isn't focused, then hilite it so the user
knows it is there */
/* update the list hints */
client_set_list();
- /* watch for when the application stops responding. only do this for
- normal windows, i.e. windows which have titlebars and close buttons
- and things like that.
- we don't need to stop pinging on unmanage, because it will be handled
- automatically by the destroy callback!
- */
- if (self->ping && client_normal(self))
- ping_start(self, client_ping_event);
-
/* free the ObAppSettings shallow copy */
g_free(settings);
void client_unmanage_all(void)
{
- while (client_list != NULL)
+ while (client_list)
client_unmanage(client_list->data);
}
void client_unmanage(ObClient *self)
{
- guint j;
GSList *it;
gulong ignore_start;
ob_debug("Unmanaged window 0x%lx", self->window);
/* free all data allocated in the client struct */
+ RrImageUnref(self->icon_set);
g_slist_free(self->transients);
- for (j = 0; j < self->nicons; ++j)
- g_free(self->icons[j].data);
- if (self->nicons > 0)
- g_free(self->icons);
g_free(self->startup_id);
g_free(self->wm_command);
g_free(self->title);
!g_pattern_match(app->name, strlen(self->name), self->name, NULL))
match = FALSE;
else if (app->class &&
- !g_pattern_match(app->class,
- strlen(self->class), self->class, NULL))
+ !g_pattern_match(app->class,
+ strlen(self->class), self->class, NULL))
match = FALSE;
else if (app->role &&
!g_pattern_match(app->role,
strlen(self->role), self->role, NULL))
match = FALSE;
+ else if ((signed)app->type >= 0 && app->type != self->type)
+ match = FALSE;
if (match) {
ob_debug("Window matching: %s", app->name);
/* This makes sure windows aren't entirely outside of the screen so you
can't see them at all.
- It makes sure 10% of the window is on the screen at least. At don't
+ It makes sure 10% of the window is on the screen at least. And don't
let it move itself off the top of the screen, which would hide the
titlebar on you. (The user can still do this if they want too, it's
only limiting the application.
static void client_get_shaped(ObClient *self)
{
self->shaped = FALSE;
-#ifdef SHAPE
+#ifdef SHAPE
if (obt_display_extension_shape) {
gint foo;
guint ufoo;
XShapeQueryExtents(obt_display, self->window, &s, &foo,
&foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo,
&ufoo);
- self->shaped = (s != 0);
+ self->shaped = !!s;
}
#endif
}
gboolean trangroup = FALSE;
if (XGetTransientForHint(obt_display, self->window, &t)) {
- if (t != self->window) { /* cant be transient to itself! */
+ if (t != self->window) { /* can't be transient to itself! */
ObWindow *tw = window_find(t);
- /* if this happens then we need to check for it*/
+ /* if this happens then we need to check for it */
g_assert(tw != CLIENT_AS_WINDOW(self));
if (tw && WINDOW_IS_CLIENT(tw)) {
/* watch out for windows with a parent that is something
/* If we are now transient for a single window we need to add ourselves to
its children
- WARNING: Cyclical transient ness is possible if two windows are
+ WARNING: Cyclical transient-ness is possible if two windows are
transient for eachother.
*/
else if (newparent &&
}
/** If we change our group transient-ness, our children change their
- effect group transient-ness, which affects how they relate to other
+ effective group transient-ness, which affects how they relate to other
group windows **/
for (it = self->transients; it; it = g_slist_next(it)) {
if (client_focused(self)) {
screen_install_colormap(self, FALSE); /* uninstall old one */
self->colormap = colormap;
- screen_install_colormap(self, FALSE); /* install new one */
+ screen_install_colormap(self, TRUE); /* install new one */
} else
self->colormap = colormap;
}
self->min_ratio = 0.0f;
self->max_ratio = 0.0f;
SIZE_SET(self->size_inc, 1, 1);
- SIZE_SET(self->base_size, 0, 0);
+ SIZE_SET(self->base_size, -1, -1);
SIZE_SET(self->min_size, 0, 0);
SIZE_SET(self->max_size, G_MAXINT, G_MAXINT);
{
XWMHints *hints;
- /* assume a window takes input if it doesnt specify */
+ /* assume a window takes input if it doesn't specify */
self->can_focus = TRUE;
if ((hints = XGetWMHints(obt_display, self->window)) != NULL) {
ObGroup *oldgroup = self->group;
/* remove from the old group if there was one */
- if (self->group != NULL) {
+ if (self->group) {
group_remove(self->group, self);
self->group = NULL;
}
*/
data = g_strdup("");
} else
- data = g_strdup("Unnamed Window");
+ data = g_strdup(_("Unnamed Window"));
}
}
self->original_title = g_strdup(data);
}
}
-/* Avoid storing icons above this size if possible */
-#define AVOID_ABOVE 64
-
void client_update_icons(ObClient *self)
{
guint num;
guint32 *data;
guint w, h, i, j;
guint num_seen; /* number of icons present */
- guint num_small_seen; /* number of icons small enough present */
- guint smallest, smallest_area;
+ RrImage *img;
- for (i = 0; i < self->nicons; ++i)
- g_free(self->icons[i].data);
- if (self->nicons > 0)
- g_free(self->icons);
- self->nicons = 0;
+ img = NULL;
+
+ /* grab the server, because we might be setting the window's icon and
+ we don't want them to set it in between and we overwrite their own
+ icon */
+ grab_server(TRUE);
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 = num_small_seen = 0;
- smallest = smallest_area = 0;
- if (num > 2)
- while (i < num) {
+ 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;
+
+ /* convert it to the right bit order for ObRender */
+ for (j = 0; j < w*h; ++j)
+ data[i+j] =
+ (((data[i+j] >> 24) & 0xff) << RrDefaultAlphaOffset) +
+ (((data[i+j] >> 16) & 0xff) << RrDefaultRedOffset) +
+ (((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 */
+
+ 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++];
- i += w * h;
- /* watch for it being too small for the specified size, or for
- zero sized icons. */
- if (i > num || w == 0 || h == 0) break;
-
- if (!smallest_area || w*h < smallest_area) {
- smallest = num_seen;
- smallest_area = w*h;
- }
- ++num_seen;
- if (w <= AVOID_ABOVE && h <= AVOID_ABOVE)
- ++num_small_seen;
- }
- if (num_small_seen > 0)
- self->nicons = num_small_seen;
- else if (num_seen)
- self->nicons = 1;
-
- self->icons = g_new(ObClientIcon, self->nicons);
-
- /* store the icons */
- i = 0;
- for (j = 0; j < self->nicons;) {
- guint x, y, t;
-
- w = self->icons[j].width = data[i++];
- h = self->icons[j].height = data[i++];
-
- /* if there are some icons smaller than the threshold, we're
- skipping all the ones above */
- if (num_small_seen > 0) {
- if (w > AVOID_ABOVE || h > AVOID_ABOVE) {
- i += w*h;
- continue;
- }
- }
- /* if there were no icons smaller than the threshold, then we are
- only taking the smallest available one we saw */
- else if (j != smallest) {
+ RrImageAddPicture(img, &data[i], w, h);
i += w*h;
- continue;
}
-
- self->icons[j].data = g_new(RrPixel32, w * h);
- for (x = 0, y = 0, t = 0; t < w * h; ++t, ++x, ++i) {
- if (x >= w) {
- x = 0;
- ++y;
- }
- self->icons[j].data[t] =
- (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
- (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
- (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
- (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
- }
- g_assert(i <= num);
-
- ++j;
}
g_free(data);
- } else {
+ }
+
+ /* if we didn't find an image from the NET_WM_ICON stuff, then try the
+ legacy X hints */
+ if (!img) {
XWMHints *hints;
if ((hints = XGetWMHints(obt_display, self->window))) {
if (hints->flags & IconPixmapHint) {
- self->nicons = 1;
- self->icons = g_new(ObClientIcon, self->nicons);
+ gboolean xicon;
obt_display_ignore_errors(TRUE);
- if (!RrPixmapToRGBA(ob_rr_inst,
- hints->icon_pixmap,
- (hints->flags & IconMaskHint ?
- hints->icon_mask : None),
- &self->icons[0].width,
- &self->icons[0].height,
- &self->icons[0].data))
- {
- g_free(self->icons);
- self->nicons = 0;
- }
+ xicon = RrPixmapToRGBA(ob_rr_inst,
+ hints->icon_pixmap,
+ (hints->flags & IconMaskHint ?
+ hints->icon_mask : None),
+ (gint*)&w, (gint*)&h, &data);
obt_display_ignore_errors(FALSE);
+
+
+ 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);
+ }
+ }
+
+ g_free(data);
+ }
}
XFree(hints);
}
}
- /* set the default icon onto the window
- in theory, this could be a race, but if a window doesn't set an icon
- or removes it entirely, it's not very likely it is going to set one
- right away afterwards
+ /* set the client's icons to be whatever we found */
+ RrImageUnref(self->icon_set);
+ self->icon_set = img;
- if it has parents, then one of them will have an icon already
+ /* if the client has no icon at all, then we set a default icon onto it.
+ but, if it has parents, then one of them will have an icon already
*/
- if (self->nicons == 0 && !self->parents) {
+ if (!self->icon_set && !self->parents) {
RrPixel32 *icon = ob_rr_theme->def_win_icon;
- gulong *data;
-
- data = g_new(gulong, 48*48+2);
- data[0] = data[1] = 48;
- for (i = 0; i < 48*48; ++i)
- data[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
+ gulong *ldata; /* use a long here to satisfy OBT_PROP_SETA32 */
+
+ w = ob_rr_theme->def_win_icon_w;
+ h = ob_rr_theme->def_win_icon_h;
+ ldata = g_new(gulong, w*h+2);
+ ldata[0] = w;
+ ldata[1] = h;
+ for (i = 0; i < w*h; ++i)
+ ldata[i+2] = (((icon[i] >> RrDefaultAlphaOffset) & 0xff) << 24) +
(((icon[i] >> RrDefaultRedOffset) & 0xff) << 16) +
(((icon[i] >> RrDefaultGreenOffset) & 0xff) << 8) +
(((icon[i] >> RrDefaultBlueOffset) & 0xff) << 0);
- OBT_PROP_SETA32(self->window, NET_WM_ICON, CARDINAL, data, 48*48+2);
- g_free(data);
+ OBT_PROP_SETA32(self->window, NET_WM_ICON, CARDINAL, ldata, w*h+2);
+ g_free(ldata);
} else if (self->frame)
/* don't draw the icon empty if we're just setting one now anyways,
we'll get the property change any second */
frame_adjust_icon(self->frame);
+
+ grab_server(FALSE);
}
void client_update_icon_geometry(ObClient *self)
gboolean show = FALSE;
if (client_should_show(self)) {
+ /* replay pending pointer event before showing the window, in case it
+ should be going to something under the window */
+ mouse_replay_pointer();
+
frame_show(self->frame);
show = TRUE;
if (!client_should_show(self)) {
if (self == focus_client) {
- /* if there is a grab going on, then we need to cancel it. if we
- move focus during the grab, applications will get
- NotifyWhileGrabbed events and ignore them !
-
- actions should not rely on being able to move focus during an
- interactive grab.
- */
event_cancel_all_key_grabs();
}
so trying to ignore them is futile in case 3 anyways
*/
+ /* replay pending pointer event before hiding the window, in case it
+ should be going to the window */
+ mouse_replay_pointer();
+
frame_hide(self->frame);
hide = TRUE;
Rect desired = {*x, *y, *w, *h};
frame_rect_to_frame(self->frame, &desired);
- /* make the frame recalculate its dimentions n shit without changing
+ /* make the frame recalculate its dimensions n shit without changing
anything visible for real, this way the constraints below can work with
the updated frame dimensions. */
frame_adjust_area(self->frame, FALSE, TRUE, TRUE);
/* gets the client's position */
frame_frame_gravity(self->frame, x, y);
- /* work within the prefered sizes given by the window */
+ /* work within the preferred sizes given by the window */
if (!(*w == self->area.width && *h == self->area.height)) {
gint basew, baseh, minw, minh;
gint incw, inch;
0 : self->max_ratio;
/* base size is substituted with min size if not specified */
- if (self->base_size.width || self->base_size.height) {
+ if (self->base_size.width >= 0 || self->base_size.height >= 0) {
basew = self->base_size.width;
baseh = self->base_size.height;
} else {
minh = self->base_size.height;
}
+ /* This comment is no longer true */
/* if this is a user-requested resize, then check against min/max
sizes */
if (!user)
ignore_start = event_start_ignore_all_enters();
+ /* replay pending pointer event before move the window, in case it
+ would change what window gets the event */
+ mouse_replay_pointer();
+
frame_adjust_area(self->frame, fmoved, fresized, FALSE);
if (!user)
if (fs) {
self->pre_fullscreen_area = self->area;
/* if the window is maximized, its area isn't all that meaningful.
- save it's premax area instead. */
+ save its premax area instead. */
if (self->max_horz) {
self->pre_fullscreen_area.x = self->pre_max_area.x;
self->pre_fullscreen_area.width = self->pre_max_area.width;
GSList *it;
gboolean changed = FALSE;
-
if (self->iconic != iconic) {
ob_debug("%sconifying window: 0x%lx", (iconic ? "I" : "Uni"),
self->window);
static void client_ping_event(ObClient *self, gboolean dead)
{
- self->not_responding = dead;
- client_update_title(self);
+ if (self->not_responding != dead) {
+ self->not_responding = dead;
+ client_update_title(self);
- if (!dead) {
- /* it came back to life ! */
+ if (dead)
+ /* the client isn't responding, so ask to kill it */
+ client_prompt_kill(self);
+ else {
+ /* it came back to life ! */
- if (self->kill_prompt) {
- prompt_unref(self->kill_prompt);
- self->kill_prompt = NULL;
- }
+ if (self->kill_prompt) {
+ prompt_unref(self->kill_prompt);
+ self->kill_prompt = NULL;
+ }
- self->kill_level = 0;
+ self->kill_level = 0;
+ }
}
}
{
if (!(self->functions & OB_CLIENT_FUNC_CLOSE)) return;
+ /* if closing an internal obprompt, that is just cancelling it */
if (self->prompt) {
prompt_cancel(self->prompt);
return;
OBT_PROP_ATOM(WM_DELETE_WINDOW), event_curtime,
0, 0, 0, NoEventMask);
+ /* we're trying to close the window, so see if it is responding. if it
+ is not, then we will let them kill the window */
+ if (self->ping)
+ ping_start(self, client_ping_event);
+
+ /* if we already know the window isn't responding (maybe they clicked
+ no in the kill dialog but it hasn't come back to life), then show
+ the kill dialog */
if (self->not_responding)
client_prompt_kill(self);
}
/* check if we're already prompting */
if (!self->kill_prompt) {
ObPromptAnswer answers[] = {
- { _("No"), OB_KILL_RESULT_NO },
- { _("Yes"), OB_KILL_RESULT_YES }
+ { 0, OB_KILL_RESULT_NO },
+ { 0, OB_KILL_RESULT_YES }
};
gchar *m;
- const gchar *sig;
+ const gchar *y;
- if (self->kill_level == 0)
- sig = "terminate";
- else
- sig = "kill";
+ if (client_on_localhost(self)) {
+ const gchar *sig;
- m = g_strdup_printf
- (_("The window \"%s\" does not seem to be responding. Do you want to force it to exit by sending the %s signal?"), self->original_title, sig);
+ if (self->kill_level == 0)
+ sig = "terminate";
+ else
+ sig = "kill";
+
+ m = g_strdup_printf
+ (_("The window \"%s\" does not seem to be responding. Do you want to force it to exit by sending the %s signal?"),
+ self->original_title, sig);
+ y = _("End Process");
+ }
+ else {
+ m = g_strdup_printf
+ (_("The window \"%s\" does not seem to be responding. Do you want to disconnect it from the X server?"),
+ self->original_title);
+ y = _("Disconnect");
+ }
+ /* set the dialog buttons' text */
+ answers[0].text = _("Cancel"); /* "no" */
+ answers[1].text = y; /* "yes" */
self->kill_prompt = prompt_new(m, answers,
sizeof(answers)/sizeof(answers[0]),
g_free(m);
}
- prompt_show(self->kill_prompt, self);
+ prompt_show(self->kill_prompt, self, TRUE);
}
void client_kill(ObClient *self)
/* don't kill our own windows */
if (self->prompt) return;
- if (!self->client_machine && self->pid) {
+ if (client_on_localhost(self) && self->pid) {
/* running on the local host */
if (self->kill_level == 0) {
ob_debug("killing window 0x%x with pid %lu, with SIGTERM",
go moving on us */
event_halt_focus_delay();
- /* if there is a grab going on, then we need to cancel it. if we move
- focus during the grab, applications will get NotifyWhileGrabbed events
- and ignore them !
-
- actions should not rely on being able to move focus during an
- interactive grab.
- */
event_cancel_all_key_grabs();
obt_display_ignore_errors(TRUE);
client_focus(self);
}
+/* this function exists to map to the client_activate message in the ewmh,
+ the user arg is unused because nobody uses it correctly anyway. */
void client_activate(ObClient *self, gboolean here, gboolean raise,
gboolean unshade, gboolean user)
{
return self == focus_client;
}
-static ObClientIcon* client_icon_recursive(ObClient *self, gint w, gint h)
+RrImage* client_icon(ObClient *self)
{
- guint i;
- gulong min_diff, min_i;
+ RrImage *ret = NULL;
- if (!self->nicons) {
- ObClientIcon *parent = NULL;
+ if (self->icon_set)
+ ret = self->icon_set;
+ else if (self->parents) {
GSList *it;
-
- for (it = self->parents; it; it = g_slist_next(it)) {
- ObClient *c = it->data;
- if ((parent = client_icon_recursive(c, w, h)))
- break;
- }
-
- return parent;
- }
-
- /* some kind of crappy approximation to find the icon closest in size to
- what we requested, but icons are generally all the same ratio as
- eachother so it's good enough. */
-
- min_diff = ABS(self->icons[0].width - w) + ABS(self->icons[0].height - h);
- min_i = 0;
-
- for (i = 1; i < self->nicons; ++i) {
- gulong diff;
-
- diff = ABS(self->icons[i].width - w) + ABS(self->icons[i].height - h);
- if (diff < min_diff) {
- min_diff = diff;
- min_i = i;
- }
- }
- return &self->icons[min_i];
-}
-
-const ObClientIcon* client_icon(ObClient *self, gint w, gint h)
-{
- ObClientIcon *ret;
- static ObClientIcon deficon;
-
- if (!(ret = client_icon_recursive(self, w, h))) {
- deficon.width = deficon.height = 48;
- deficon.data = ob_rr_theme->def_win_icon;
- ret = &deficon;
+ for (it = self->parents; it && !ret; it = g_slist_next(it))
+ ret = client_icon(it->data);
}
+ if (!ret)
+ ret = client_default_icon;
return ret;
}
{
return self->group && self->group->members->next;
}
+
+/*! Returns TRUE if the client is running on the same machine as Openbox */
+gboolean client_on_localhost(ObClient *self)
+{
+ return self->client_machine == NULL;
+}