#include "client.h"
#include "dock.h"
+#include "xerror.h"
#include "startup.h"
#include "screen.h"
#include "moveresize.h"
focus_order_add_new(self);
/* focus the new window? */
- if (ob_state != State_Starting && config_focus_new) {
+ if (ob_state != State_Starting && config_focus_new &&
+ (self->type == Type_Normal || self->type == Type_Dialog)) {
gboolean group_foc = FALSE;
if (self->group) {
GSList *it;
- for (it = self->group->members; it; it = it->next)
+ for (it = self->group->members; it; it = it->next) {
if (client_focused(it->data)) {
group_foc = TRUE;
break;
}
+ }
}
/* note the check against Type_Normal/Dialog, not client_normal(self),
which would also include other types. in this case we want more
strict rules for focus */
- if (((self->type == Type_Normal ||
- (self->type == Type_Dialog &&
- (group_foc ||
- (!self->transient_for && (!self->group ||
- !self->group->members->next)))))) ||
+ if ((group_foc ||
+ (!self->transient_for && (!self->group ||
+ !self->group->members->next))) ||
client_search_focus_tree_full(self) ||
!focus_client ||
!client_normal(focus_client)) {
screen_update_struts();
+ dispatch_client(Event_Client_New, self, 0, 0);
+
/* make sure the window is visible */
client_move_onscreen(self);
- dispatch_client(Event_Client_New, self, 0, 0);
-
client_showhide(self);
if (activate) client_activate(self);
static void client_get_desktop(Client *self)
{
- guint32 d;
+ guint32 d = screen_num_desktops; /* an always-invalid value */
if (PROP_GET32(self->window, net_wm_desktop, cardinal, &d)) {
if (d >= screen_num_desktops && d != DESKTOP_ALL)
- d = screen_num_desktops - 1;
- self->desktop = d;
+ self->desktop = screen_num_desktops - 1;
+ else
+ self->desktop = d;
} else {
gboolean trdesk = FALSE;
/* defaults to the current desktop */
self->desktop = screen_desktop;
+ }
+ if (self->desktop != d) {
/* set the desktop hint, to make sure that it always exists */
PROP_SET32(self->window, net_wm_desktop, cardinal, self->desktop);
}
if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
client_set_desktop(self, DESKTOP_ALL, FALSE);
- /* change the decors on the frame, and with more/less decorations,
- we may also need to be repositioned */
- frame_adjust_area(self->frame, TRUE, TRUE);
- /* with new decor, the window's maximized size may change */
- client_remaximize(self);
+ /* adjust the client's decorations, etc. */
+ client_reconfigure(self);
} else {
/* this makes sure that these windows appear on all desktops */
if (self->type == Type_Desktop && self->desktop != DESKTOP_ALL)
}
}
-void client_remaximize(Client *self)
+void client_reconfigure(Client *self)
{
- int dir;
- if (self->max_horz && self->max_vert)
- dir = 0;
- else if (self->max_horz)
- dir = 1;
- else if (self->max_vert)
- dir = 2;
- else
- return; /* not maximized */
- self->max_horz = self->max_vert = FALSE;
- client_maximize(self, TRUE, dir, FALSE);
+ /* by making this pass FALSE for user, we avoid the emacs event storm where
+ every configurenotify causes an update in its normal hints, i think this
+ is generally what we want anyways... */
+ client_configure(self, Corner_TopLeft, self->area.x, self->area.y,
+ self->area.width, self->area.height, FALSE, TRUE);
}
void client_update_wmhints(Client *self)
group_remove(self->group, self);
self->group = NULL;
}
- /* i can only have transients from the group if i am not transient
- myself */
- if (hints->window_group != None && !self->transient_for) {
+ if (hints->window_group != None) {
self->group = group_add(hints->window_group, self);
- /* add other transients of the group that are already
- set up */
- for (it = self->group->members; it; it = it->next)
- if (it->data != self &&
- ((Client*)it->data)->transient_for == TRAN_GROUP)
- self->transients = g_slist_append(self->transients,
- it->data);
+ /* i can only have transients from the group if i am not
+ transient myself */
+ if (!self->transient_for) {
+ /* add other transients of the group that are already
+ set up */
+ for (it = self->group->members; it; it = it->next)
+ if (it->data != self &&
+ ((Client*)it->data)->transient_for == TRAN_GROUP)
+ self->transients = g_slist_append(self->transients,
+ it->data);
+ }
}
/* the WM_HINTS can contain an icon */
w = data[i++];
h = data[i++];
i += w * h;
- if (i > num) break;
+ if (i > num || w*h == 0) break;
++self->nicons;
}
w = self->icons[j].width = data[i++];
h = self->icons[j].height = data[i++];
- self->icons[j].data = g_new(pixel32, w * h);
+ if (w*h == 0) 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) << default_alpha_offset) +
- (((data[i] >> 16) & 0xff) << default_red_offset) +
- (((data[i] >> 8) & 0xff) << default_green_offset) +
- (((data[i] >> 0) & 0xff) << default_blue_offset);
+ (((data[i] >> 24) & 0xff) << RrDefaultAlphaOffset) +
+ (((data[i] >> 16) & 0xff) << RrDefaultRedOffset) +
+ (((data[i] >> 8) & 0xff) << RrDefaultGreenOffset) +
+ (((data[i] >> 0) & 0xff) << RrDefaultBlueOffset);
}
g_assert(i <= num);
}
if (num == 2) {
self->nicons++;
self->icons = g_new(Icon, self->nicons);
- if (!render_pixmap_to_rgba(data[0], data[1],
- &self->icons[self->nicons-1].width,
- &self->icons[self->nicons-1].height,
- &self->icons[self->nicons-1].data)) {
+ xerror_set_ignore(TRUE);
+ if (!RrPixmapToRGBA(ob_rr_inst,
+ data[0], data[1],
+ &self->icons[self->nicons-1].width,
+ &self->icons[self->nicons-1].height,
+ &self->icons[self->nicons-1].data)) {
g_free(&self->icons[self->nicons-1]);
self->nicons--;
}
+ xerror_set_ignore(FALSE);
}
g_free(data);
} else {
if (hints->flags & IconPixmapHint) {
self->nicons++;
self->icons = g_new(Icon, self->nicons);
- if (!render_pixmap_to_rgba(hints->icon_pixmap,
- (hints->flags & IconMaskHint ?
- hints->icon_mask : None),
- &self->icons[self->nicons-1].width,
- &self->icons[self->nicons-1].height,
- &self->icons[self->nicons-1].data)){
+ xerror_set_ignore(TRUE);
+ if (!RrPixmapToRGBA(ob_rr_inst,
+ hints->icon_pixmap,
+ (hints->flags & IconMaskHint ?
+ hints->icon_mask : None),
+ &self->icons[self->nicons-1].width,
+ &self->icons[self->nicons-1].height,
+ &self->icons[self->nicons-1].data)){
g_free(&self->icons[self->nicons-1]);
self->nicons--;
}
+ xerror_set_ignore(FALSE);
}
XFree(hints);
}
calc_recursive(it->data, orig, l, raised ? raised : l != old);
if (!raised && l != old)
- if (orig->frame) /* only restack if the original window is managed */
- stacking_raise(CLIENT_AS_WINDOW(self));
+ if (orig->frame) { /* only restack if the original window is managed */
+ /* XXX add_non_intrusive ever? */
+ stacking_remove(CLIENT_AS_WINDOW(self));
+ stacking_add(CLIENT_AS_WINDOW(self));
+ }
}
void client_calc_layer(Client *self)
/* set the size and position if fullscreen */
if (self->fullscreen) {
- x = 0;
- y = 0;
- w = screen_physical_size.width;
- h = screen_physical_size.height;
+#ifdef VIDMODE
+ int dot;
+ XF86VidModeModeLine mode;
+
+ if (XF86VidModeGetModeLine(ob_display, ob_screen, &dot, &mode)) {
+ w = mode.hdisplay;
+ h = mode.vdisplay;
+ if (mode.privsize) XFree(mode.private);
+ } else {
+#else
+ w = screen_physical_size.width;
+ h = screen_physical_size.height;
+#endif
+#ifdef VIDMODE
+ }
+ if (!XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y)) {
+ x = y = 0;
+#endif
+ }
user = FALSE; /* ignore that increment etc shit when in fullscreen */
} else {
/* set the size and position if maximized */
}
if (!(w == self->area.width && h == self->area.height)) {
- w -= self->base_size.width;
- h -= self->base_size.height;
+ int basew, baseh, minw, minh;
+
+ /* base size is substituted with min size if not specified */
+ if (self->base_size.width || self->base_size.height) {
+ basew = self->base_size.width;
+ baseh = self->base_size.height;
+ } else {
+ basew = self->min_size.width;
+ baseh = self->min_size.height;
+ }
+ /* min size is substituted with base size if not specified */
+ if (self->min_size.width || self->min_size.height) {
+ minw = self->min_size.width;
+ minh = self->min_size.height;
+ } else {
+ minw = self->base_size.width;
+ minh = self->base_size.height;
+ }
if (user) {
/* for interactive resizing. have to move half an increment in each
direction. */
/* how far we are towards the next size inc */
- int mw = w % self->size_inc.width;
- int mh = h % self->size_inc.height;
+ int mw = (w - basew) % self->size_inc.width;
+ int mh = (h - baseh) % self->size_inc.height;
/* amount to add */
int aw = self->size_inc.width / 2;
int ah = self->size_inc.height / 2;
h += ah;
/* if this is a user-requested resize, then check against min/max
- sizes and aspect ratios */
+ sizes */
/* smaller than min size or bigger than max size? */
if (w > self->max_size.width) w = self->max_size.width;
- if (w < self->min_size.width) w = self->min_size.width;
+ if (w < minw) w = minw;
if (h > self->max_size.height) h = self->max_size.height;
- if (h < self->min_size.height) h = self->min_size.height;
-
- /* adjust the height ot match the width for the aspect ratios */
- if (self->min_ratio)
- if (h * self->min_ratio > w) h = (int)(w / self->min_ratio);
- if (self->max_ratio)
- if (h * self->max_ratio < w) h = (int)(w / self->max_ratio);
+ if (h < minh) h = minh;
}
+ w -= basew;
+ h -= baseh;
+
/* keep to the increments */
w /= self->size_inc.width;
h /= self->size_inc.height;
w *= self->size_inc.width;
h *= self->size_inc.height;
- w += self->base_size.width;
- h += self->base_size.height;
+ w += basew;
+ h += baseh;
+
+ if (user) {
+ /* adjust the height to match the width for the aspect ratios.
+ for this, min size is not substituted for base size ever. */
+ w -= self->base_size.width;
+ h -= self->base_size.height;
+
+ if (self->min_ratio)
+ if (h * self->min_ratio > w) h = (int)(w / self->min_ratio);
+ if (self->max_ratio)
+ if (h * self->max_ratio < w) h = (int)(w / self->max_ratio);
+
+ w += self->base_size.width;
+ h += self->base_size.height;
+ }
}
switch (anchor) {
RECT_SET(self->area, x, y, w, h);
- if (resized)
+ /* for app-requested resizes, always resize if 'resized' is true.
+ for user-requested ones, only resize if final is true, or when
+ resizing in opaque mode */
+ if ((!user && resized) ||
+ (user && (final || (resized && config_opaque_resize))))
XResizeWindow(ob_display, self->window, w, h);
/* move/resize the frame to match the request */
if (self->frame) {
+ if (self->decorations != self->frame->decorations)
+ moved = resized = TRUE;
+
if (moved || resized)
frame_adjust_area(self->frame, moved, resized);
- if (!user || final) {
+ /* If you send this and the client hasn't changed you end up with buggy
+ clients (emacs) freaking out, cuz they send back a configure every
+ time they receive this event, which resends them this event... etc.
+ */
+ if ((!user && moved) || (user && final)) {
XEvent event;
event.type = ConfigureNotify;
event.xconfigure.display = ob_display;
/* this puts it after the current focused window */
focus_order_remove(self);
focus_order_add_new(self);
+
+ /* this is here cuz with the VIDMODE extension, the viewport can change
+ while a fullscreen window is iconic, and when it uniconifies, it
+ would be nice if it did so to the new position of the viewport */
+ client_reconfigure(self);
}
client_change_state(self);
client_showhide(self);
return self;
}
-gboolean client_focus(Client *self)
+gboolean client_can_focus(Client *self)
{
XEvent ev;
/* choose the correct target */
self = client_focus_target(self);
- if (self->desktop != DESKTOP_ALL && self->desktop != screen_desktop) {
- /* update the focus lists */
- focus_order_to_top(self);
+ if (!self->frame->visible)
return FALSE;
- }
if (!((self->can_focus || self->focus_notify) &&
(self->desktop == screen_desktop ||
}
}
+ return TRUE;
+}
+
+gboolean client_focus(Client *self)
+{
+ /* choose the correct target */
+ self = client_focus_target(self);
+
+ if (!client_can_focus(self)) {
+ if (!self->frame->visible) {
+ /* update the focus lists */
+ focus_order_to_top(self);
+ }
+ return FALSE;
+ }
+
if (self->can_focus)
/* RevertToPointerRoot causes much more headache than RevertToNone, so
I choose to use it always, hopefully to find errors quicker, if any