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 */
+ /* adjust the client's decorations, etc. */
client_reconfigure(self);
} else {
/* this makes sure that these windows appear on all desktops */
void client_reconfigure(Client *self)
{
+ /* 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, TRUE, TRUE);
+ self->area.width, self->area.height, FALSE, TRUE);
}
void client_update_wmhints(Client *self)
if (w*h == 0) continue;
- self->icons[j].data = g_new(pixel32, w * h);
+ 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);
}
self->nicons++;
self->icons = g_new(Icon, self->nicons);
xerror_set_ignore(TRUE);
- 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)) {
+ 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--;
}
self->nicons++;
self->icons = g_new(Icon, self->nicons);
xerror_set_ignore(TRUE);
- 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)){
+ 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--;
}
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) {
#ifdef VIDMODE
- XF86VidModeGetViewPort(ob_display, ob_screen, &x, &y);
+ 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
- x = 0;
- y = 0;
+ w = screen_physical_size.width;
+ h = screen_physical_size.height;
#endif
- w = screen_physical_size.width;
- h = screen_physical_size.height;
+#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;