void client_add_destroy_notify(ObClientCallback func, gpointer data)
{
- ClientCallback *d = g_new(ClientCallback, 1);
+ ClientCallback *d = g_slice_new(ClientCallback);
d->func = func;
d->data = data;
client_destroy_notifies = g_slist_prepend(client_destroy_notifies, d);
for (it = client_destroy_notifies; it; it = g_slist_next(it)) {
ClientCallback *d = it->data;
if (d->func == func) {
- g_free(d);
+ g_slice_free(ClientCallback, d);
client_destroy_notifies =
g_slist_delete_link(client_destroy_notifies, it);
break;
gboolean activate = FALSE;
ObAppSettings *settings;
gboolean transient = FALSE;
- Rect place, *monitor;
- Time launch_time, map_time;
+ Rect place;
+ Time launch_time;
guint32 user_time;
+ gboolean obplaced;
ob_debug("Managing window: 0x%lx", window);
- map_time = event_get_server_time();
+ /* 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) */
/* create the ObClient struct, and populate it from the hints on the
window */
- self = g_new0(ObClient, 1);
+ self = g_slice_new0(ObClient);
self->obwin.type = OB_WINDOW_CLASS_CLIENT;
self->window = window;
self->prompt = prompt;
ob_debug("Window type: %d", self->type);
ob_debug("Window group: 0x%x", self->group?self->group->leader:0);
- ob_debug("Window name: %s class: %s role: %s", self->name, self->class, self->role);
+ ob_debug("Window name: %s class: %s role: %s title: %s",
+ self->name, self->class, self->role, self->title);
/* per-app settings override stuff from client_get_all, and return the
settings for other uses too. the returned settings is a shallow copy,
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 = map_time;
+ user_time = event_curtime;
/* do this after we have a frame.. it uses the frame to help determine the
WM_STATE to apply. */
/* this checks for focus=false for the window */
(!settings || settings->focus != 0) &&
focus_valid_target(self, self->desktop,
- FALSE, FALSE, TRUE, FALSE, FALSE,
+ FALSE, FALSE, TRUE, TRUE, FALSE, FALSE,
settings->focus == 1))
{
activate = TRUE;
/* where the frame was placed is where the window was originally */
place = self->area;
- monitor = screen_physical_area_monitor(screen_find_monitor(&place));
/* figure out placement for the window if the window is new */
if (ob_state() == OB_STATE_RUNNING) {
"program + user specified" :
"BADNESS !?")))), place.width, place.height);
- place_client(self, &place.x, &place.y, settings);
+ obplaced = place_client(self, &place.x, &place.y, settings);
+
+ /* watch for buggy apps that ask to be placed at (0,0) when there is
+ a strut there */
+ if (!obplaced && place.x == 0 && place.y == 0 &&
+ /* non-normal windows are allowed */
+ client_normal(self) &&
+ /* oldschool fullscreen windows are allowed */
+ !client_is_oldfullscreen(self, &place))
+ {
+ Rect *r;
+
+ r = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS, NULL);
+ if (r->x || r->y) {
+ place.x = r->x;
+ place.y = r->y;
+ ob_debug("Moving buggy app from (0,0) to (%d,%d)", r->x, r->y);
+ }
+ g_slice_free(Rect, r);
+ }
/* make sure the window is visible. */
client_find_onscreen(self, &place.x, &place.y,
fit inside the struts (fixes Acroread, which
makes its fullscreen window fit the screen
but it is not USSize'd or USPosition'd) */
- !(self->decorations == 0 &&
- RECT_EQUAL(place, *monitor)))));
+ !client_is_oldfullscreen(self, &place))));
}
/* if the window isn't user-sized, then make it fit inside
/* don't shrink oldschool fullscreen windows to fit inside the
struts (fixes Acroread, which makes its fullscreen window
fit the screen but it is not USSize'd or USPosition'd) */
- !(self->decorations == 0 && RECT_EQUAL(place, *monitor)))))
+ !client_is_oldfullscreen(self, &place))))
{
Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &place);
place.width -= self->frame->size.left + self->frame->size.right;
place.height -= self->frame->size.top + self->frame->size.bottom;
- g_free(a);
+ g_slice_free(Rect, a);
}
ob_debug("placing window 0x%x at %d, %d with size %d x %d. "
client_apply_startup_state(self, place.x, place.y,
place.width, place.height);
- g_free(monitor);
- monitor = NULL;
-
ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s",
activate ? "yes" : "no");
if (activate) {
- activate = client_can_steal_focus(self, map_time, launch_time);
+ activate = client_can_steal_focus(self, event_curtime, launch_time);
if (!activate) {
/* if the client isn't stealing focus, then hilite it so the user
client_set_list();
/* free the ObAppSettings shallow copy */
- g_free(settings);
+ g_slice_free(ObAppSettings, settings);
ob_debug("Managed window 0x%lx plate 0x%x (%s)",
window, self->frame->window, self->class);
/* do this minimal stuff to figure out the client's decorations */
- self = g_new0(ObClient, 1);
+ self = g_slice_new0(ObClient);
self->window = window;
client_get_all(self, FALSE);
self->frame->size.top, self->frame->size.bottom);
/* free the ObAppSettings shallow copy */
- g_free(settings);
+ g_slice_free(ObAppSettings, settings);
return self;
}
g_free(self->role);
g_free(self->client_machine);
g_free(self->sm_client_id);
- g_free(self);
+ g_slice_free(ObClient, self);
}
void client_fake_unmanage(ObClient *self)
/* this is all that got allocated to get the decorations */
frame_free(self->frame);
- g_free(self);
+ g_slice_free(ObClient, self);
}
static gboolean client_can_steal_focus(ObClient *self, Time steal_time,
/* This is focus stealing prevention */
ob_debug_type(OB_DEBUG_FOCUS,
- "Want to focus new window 0x%x at time %u "
+ "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 (!(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))
+ (!launch_time ||
+ (screen_desktop_user_time &&
+ !event_time_after(launch_time, screen_desktop_user_time))))
{
steal = FALSE;
ob_debug_type(OB_DEBUG_FOCUS,
gboolean match = TRUE;
g_assert(app->name != NULL || app->class != NULL ||
- app->role != NULL || (signed)app->type >= 0);
+ app->role != NULL || app->title != NULL ||
+ (signed)app->type >= 0);
if (app->name &&
!g_pattern_match(app->name, strlen(self->name), self->name, NULL))
!g_pattern_match(app->role,
strlen(self->role), self->role, NULL))
match = FALSE;
+ else if (app->title &&
+ !g_pattern_match(app->title,
+ strlen(self->title), self->title, NULL))
+ match = FALSE;
else if ((signed)app->type >= 0 && app->type != self->type) {
match = FALSE;
}
if (rudeb && !self->strut.bottom && *y + fh > a->y + a->height)
*y = a->y + MAX(0, a->height - fh);
- g_free(a);
+ g_slice_free(Rect, a);
}
/* get where the client should be */
from per-app settings */
client_get_session_ids(self);
- /* save the values of the variables used for app rule matching */
- client_save_app_rule_values(self);
-
/* now we got everything that can affect the decorations */
if (!real)
return;
/* get this early so we have it for debugging */
client_update_title(self);
+ /* save the values of the variables used for app rule matching */
+ client_save_app_rule_values(self);
+
client_update_protocols(self);
client_update_wmhints(self);
if (!got &&
OBT_PROP_GETA32(self->window, NET_WM_STRUT, CARDINAL, &data, &num)) {
if (num == 4) {
- Rect *a;
+ const Rect *a;
got = TRUE;
a->x, a->x + a->width - 1,
a->y, a->y + a->height - 1,
a->x, a->x + a->width - 1);
- g_free(a);
}
g_free(data);
}
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);
switch (self->type) {
case OB_CLIENT_TYPE_NORMAL:
return self->parents != NULL;
}
+gboolean client_is_oldfullscreen(const ObClient *self,
+ const Rect *area)
+{
+ const Rect *monitor, *allmonitors;
+
+ /* No decorations and fills the monitor = oldskool fullscreen.
+ But not for maximized windows.
+ */
+
+ if (self->decorations || self->max_horz || self->max_vert) return FALSE;
+
+ monitor = screen_physical_area_monitor(screen_find_monitor(area));
+ allmonitors = screen_physical_area_all_monitors();
+
+ return (RECT_EQUAL(*area, *monitor) ||
+ RECT_EQUAL(*area, *allmonitors));
+}
+
static ObStackingLayer calc_layer(ObClient *self)
{
ObStackingLayer l;
- Rect *monitor;
+ 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;
else l = OB_STACKING_LAYER_ABOVE;
}
else if ((self->fullscreen ||
- /* No decorations and fills the monitor = oldskool fullscreen.
- But not for maximized windows.
- */
- (self->decorations == 0 &&
- !(self->max_horz && self->max_vert) &&
- RECT_EQUAL(self->area, *monitor))) &&
+ client_is_oldfullscreen(self, &self->area)) &&
/* you are fullscreen while you or your children are focused.. */
(client_focused(self) || client_search_focus_tree(self) ||
/* you can be fullscreen if you're on another desktop */
else if (self->below) l = OB_STACKING_LAYER_BELOW;
else l = OB_STACKING_LAYER_NORMAL;
- g_free(monitor);
-
return l;
}
/* set the size and position if fullscreen */
if (self->fullscreen) {
- Rect *a;
+ const Rect *a;
guint i;
i = screen_find_monitor(&desired);
user = FALSE; /* ignore if the client can't be moved/resized when it
is fullscreening */
-
- g_free(a);
} else if (self->max_horz || self->max_vert) {
Rect *a;
guint i;
user = FALSE; /* ignore if the client can't be moved/resized when it
is maximizing */
- g_free(a);
+ g_slice_free(Rect, a);
}
/* gets the client's position */
void client_configure(ObClient *self, gint x, gint y, gint w, gint h,
gboolean user, gboolean final, gboolean force_reply)
{
- Rect oldframe;
- gint oldw, oldh;
+ Rect oldframe, oldclient;
gboolean send_resize_client;
gboolean moved = FALSE, resized = FALSE, rootmoved = FALSE;
gboolean fmoved, fresized;
moved = (x != self->area.x || y != self->area.y);
resized = (w != self->area.width || h != self->area.height);
- oldw = self->area.width;
- oldh = self->area.height;
oldframe = self->frame->area;
+ oldclient = self->area;
RECT_SET(self->area, x, y, w, h);
/* for app-requested resizes, always resize if 'resized' is true.
(resized && config_resize_redraw))));
/* if the client is enlarging, then resize the client before the frame */
- if (send_resize_client && (w > oldw || h > oldh)) {
+ if (send_resize_client && (w > oldclient.width || h > oldclient.height)) {
XMoveResizeWindow(obt_display, self->window,
self->frame->size.left, self->frame->size.top,
- MAX(w, oldw), MAX(h, oldh));
+ MAX(w, oldclient.width), MAX(h, oldclient.height));
frame_adjust_client_area(self->frame);
}
both of these resize sections may run, because the top one only resizes
in the direction that is growing
*/
- if (send_resize_client && (w <= oldw || h <= oldh)) {
+ if (send_resize_client && (w <= oldclient.width || h <= oldclient.height))
+ {
frame_adjust_client_area(self->frame);
XMoveResizeWindow(obt_display, self->window,
self->frame->size.left, self->frame->size.top, w, h);
XFlush(obt_display);
/* if it moved between monitors, then this can affect the stacking
- layer of this window or others - for fullscreen windows */
+ 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))
+ screen_find_monitor(&oldframe) ||
+ (final && (client_is_oldfullscreen(self, &oldclient) !=
+ client_is_oldfullscreen(self, &self->area))))
{
client_calc_layer(self);
}
if (fs) {
self->pre_fullscreen_area = self->area;
+ self->pre_fullscreen_max_horz = self->max_horz;
+ self->pre_fullscreen_max_vert = self->max_vert;
+
/* if the window is maximized, its area isn't all that meaningful.
save its premax area instead. */
if (self->max_horz) {
g_assert(self->pre_fullscreen_area.width > 0 &&
self->pre_fullscreen_area.height > 0);
+ self->max_horz = self->pre_fullscreen_max_horz;
+ self->max_vert = self->pre_fullscreen_max_vert;
+ if (self->max_horz) {
+ self->pre_max_area.x = self->pre_fullscreen_area.x;
+ self->pre_max_area.width = self->pre_fullscreen_area.width;
+ }
+ if (self->max_vert) {
+ self->pre_max_area.y = self->pre_fullscreen_area.y;
+ self->pre_max_area.height = self->pre_fullscreen_area.height;
+ }
+
x = self->pre_fullscreen_area.x;
y = self->pre_fullscreen_area.y;
w = self->pre_fullscreen_area.width;
Rect *area = screen_area(self->desktop, i, NULL);
detect_edge(*area, dir, my_head, my_size, my_edge_start,
my_edge_size, dest, near_edge);
- g_free(area);
+ g_slice_free(Rect, area);
}
/* search for edges of clients */
- for (it = client_list; it; it = g_list_next(it)) {
- ObClient *cur = it->data;
+ 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;
- /* 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,
+ 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);
}
- dock_get_area(&dock_area);
- detect_edge(dock_area, dir, my_head, my_size, my_edge_start,
- my_edge_size, dest, near_edge);
- g_free(a);
+
+ g_slice_free(Rect, a);
}
void client_find_move_directional(ObClient *self, ObDirection dir,
projects / chaz / openbox / blobdiff