#include "grab.h"
#include "prompt.h"
#include "focus.h"
+#include "focus_cycle.h"
#include "stacking.h"
#include "openbox.h"
#include "group.h"
#include "menuframe.h"
#include "keyboard.h"
#include "mouse.h"
-#include "render/render.h"
+#include "obrender/render.h"
#include "gettext.h"
#include "obt/display.h"
#include "obt/prop.h"
static void client_get_all(ObClient *self, gboolean real);
static void client_get_startup_id(ObClient *self);
static void client_get_session_ids(ObClient *self);
+static void client_save_app_rule_values(ObClient *self);
static void client_get_area(ObClient *self);
static void client_get_desktop(ObClient *self);
static void client_get_state(ObClient *self);
gboolean activate = FALSE;
ObAppSettings *settings;
gboolean transient = FALSE;
- Rect place, *monitor;
+ Rect place, *monitor, *allmonitors;
Time launch_time, map_time;
guint32 user_time;
+ gboolean obplaced;
ob_debug("Managing window: 0x%lx", window);
self->obwin.type = OB_WINDOW_CLASS_CLIENT;
self->window = window;
self->prompt = prompt;
+ self->managed = TRUE;
/* non-zero defaults */
self->wmstate = WithdrawnState; /* make sure it gets updated first time */
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,
(user_time != 0) &&
/* this checks for focus=false for the window */
(!settings || settings->focus != 0) &&
- focus_valid_target(self, FALSE, FALSE, TRUE, FALSE, FALSE))
+ focus_valid_target(self, self->desktop,
+ FALSE, FALSE, 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));
+ allmonitors = screen_physical_area_all_monitors();
/* 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);
- /* splash screens are also returned as TRUE for transient,
- and so will be forced on screen below */
- transient = 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 &&
+ /* oldschool fullscreen windows are allowed */
+ !(self->decorations == 0 && (RECT_EQUAL(place, *monitor) ||
+ RECT_EQUAL(place, *allmonitors))))
+ {
+ Rect *r;
+
+ r = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS, NULL);
+ place.x = r->x;
+ place.y = r->y;
+ ob_debug("Moving buggy app from (0,0) to (%d,%d)", r->x, r->y);
+ g_free(r);
+ }
/* make sure the window is visible. */
client_find_onscreen(self, &place.x, &place.y,
it is up to the placement routines to avoid
the xinerama divides)
- splash screens get "transient" set to TRUE by
- the place_client call
+ children and splash screens are forced on
+ screen, but i don't remember why i decided to
+ do that.
*/
ob_state() == OB_STATE_RUNNING &&
- (transient ||
+ (self->type == OB_CLIENT_TYPE_DIALOG ||
+ self->type == OB_CLIENT_TYPE_SPLASH ||
(!((self->positioned & USPosition) ||
(settings && settings->pos_given)) &&
client_normal(self) &&
makes its fullscreen window fit the screen
but it is not USSize'd or USPosition'd) */
!(self->decorations == 0 &&
- RECT_EQUAL(place, *monitor)))));
+ (RECT_EQUAL(place, *monitor) ||
+ RECT_EQUAL(place, *allmonitors))))));
}
/* 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)))))
+ !(self->decorations == 0 && (RECT_EQUAL(place, *monitor) ||
+ RECT_EQUAL(place, *allmonitors))))))
{
Rect *a = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR, &place);
g_free(monitor);
monitor = NULL;
+ g_free(allmonitors);
+ allmonitors = NULL;
ob_debug_type(OB_DEBUG_FOCUS, "Going to try activate new window? %s",
activate ? "yes" : "no");
mouse_grab_for_client(self, FALSE);
+ self->managed = FALSE;
+
/* remove the window from our save set, unless we are managing an internal
ObPrompt window */
if (!self->prompt)
ObAppSettings *app = it->data;
gboolean match = TRUE;
- g_assert(app->name != NULL || app->class != NULL);
+ g_assert(app->name != NULL || app->class != NULL ||
+ app->role != NULL || app->title != NULL ||
+ (signed)app->type >= 0);
- /* we know that either name or class is not NULL so it will have to
- match to use the rule */
if (app->name &&
!g_pattern_match(app->name, strlen(self->name), self->name, NULL))
match = FALSE;
!g_pattern_match(app->role,
strlen(self->role), self->role, NULL))
match = FALSE;
- else if ((signed)app->type >= 0 && app->type != self->type)
+ 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 (match) {
ob_debug("Window matching: %s", app->name);
/* 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);
XFree(hints);
}
+
+ focus_cycle_addremove(self, TRUE);
}
void client_update_title(ObClient *self)
STRUT_PARTIAL_SET(strut, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0);
- if (!STRUT_EQUAL(strut, self->strut)) {
+ if (!PARTIAL_STRUT_EQUAL(strut, self->strut)) {
self->strut = strut;
/* updating here is pointless while we're being mapped cuz we're not in
}
}
+/*! Save the properties used for app matching rules, as seen by Openbox when
+ the window mapped, so that users can still access them later if the app
+ changes them */
+static void client_save_app_rule_values(ObClient *self)
+{
+ 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);
+
+ switch (self->type) {
+ case OB_CLIENT_TYPE_NORMAL:
+ type = "normal"; break;
+ case OB_CLIENT_TYPE_DIALOG:
+ type = "dialog"; break;
+ case OB_CLIENT_TYPE_UTILITY:
+ type = "utility"; break;
+ case OB_CLIENT_TYPE_MENU:
+ type = "menu"; break;
+ case OB_CLIENT_TYPE_TOOLBAR:
+ type = "toolbar"; break;
+ case OB_CLIENT_TYPE_SPLASH:
+ type = "splash"; break;
+ case OB_CLIENT_TYPE_DESKTOP:
+ type = "desktop"; break;
+ case OB_CLIENT_TYPE_DOCK:
+ type = "dock"; break;
+ }
+ OBT_PROP_SETS(self->window, OB_APP_TYPE, utf8, type);
+}
+
static void client_change_wm_state(ObClient *self)
{
gulong state[2];
static ObStackingLayer calc_layer(ObClient *self)
{
ObStackingLayer l;
- Rect *monitor;
+ 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;
*/
(self->decorations == 0 &&
!(self->max_horz && self->max_vert) &&
- RECT_EQUAL(self->area, *monitor))) &&
+ (RECT_EQUAL(self->area, *monitor) ||
+ RECT_EQUAL(self->area, *allmonitors)))) &&
/* 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 l = OB_STACKING_LAYER_NORMAL;
g_free(monitor);
+ g_free(allmonitors);
return l;
}
self->iconic = iconic;
/* update the focus lists.. iconic windows go to the bottom of
- the list */
+ the list. this will also call focus_cycle_addremove(). */
focus_order_to_bottom(self);
changed = TRUE;
self->desktop != DESKTOP_ALL)
client_set_desktop(self, screen_desktop, FALSE, FALSE);
- /* this puts it after the current focused window */
- focus_order_remove(self);
- focus_order_add_new(self);
+ /* this puts it after the current focused window, this will
+ also cause focus_cycle_addremove() to be called for the
+ client */
+ focus_order_like_new(self);
changed = TRUE;
}
/* the new desktop's geometry may be different, so we may need to
resize, for example if we are maximized */
client_reconfigure(self, FALSE);
+
+ focus_cycle_addremove(self, FALSE);
}
/* move all transients */
{
self = client_search_top_direct_parent(self);
client_set_desktop_recursive(self, target, donthide, dontraise);
+
+ focus_cycle_addremove(NULL, TRUE);
}
gboolean client_is_direct_child(ObClient *parent, ObClient *child)
client_hilite(self, demands_attention);
client_change_state(self); /* change the hint to reflect these changes */
+
+ focus_cycle_addremove(self, TRUE);
}
ObClient *client_focus_target(ObClient *self)
}
/* this function exists to map to the net_active_window message in the ewmh */
-void client_activate(ObClient *self, gboolean desktop, gboolean raise,
+void client_activate(ObClient *self, gboolean desktop,
+ gboolean here, gboolean raise,
gboolean unshade, gboolean user)
{
if ((user && (desktop ||
self->desktop == screen_desktop)) ||
client_can_steal_focus(self, event_curtime, CurrentTime))
{
- client_present(self, FALSE, raise, unshade);
+ client_present(self, here, raise, unshade);
}
else
client_hilite(self, TRUE);
gint *dest, gboolean *near_edge)
{
GList *it;
- Rect *a, *mon;
+ Rect *a;
Rect dock_area;
gint edge;
+ guint i;
a = screen_area(self->desktop, SCREEN_AREA_ALL_MONITORS,
&self->frame->area);
- mon = screen_area(self->desktop, SCREEN_AREA_ONE_MONITOR,
- &self->frame->area);
switch (dir) {
case OB_DIRECTION_NORTH:
- if (my_head >= RECT_TOP(*mon) + 1)
- edge = RECT_TOP(*mon) - 1;
- else
- edge = RECT_TOP(*a) - 1;
+ edge = RECT_TOP(*a) - 1;
break;
case OB_DIRECTION_SOUTH:
- if (my_head <= RECT_BOTTOM(*mon) - 1)
- edge = RECT_BOTTOM(*mon) + 1;
- else
- edge = RECT_BOTTOM(*a) + 1;
+ edge = RECT_BOTTOM(*a) + 1;
break;
case OB_DIRECTION_EAST:
- if (my_head <= RECT_RIGHT(*mon) - 1)
- edge = RECT_RIGHT(*mon) + 1;
- else
- edge = RECT_RIGHT(*a) + 1;
+ edge = RECT_RIGHT(*a) + 1;
break;
case OB_DIRECTION_WEST:
- if (my_head >= RECT_LEFT(*mon) + 1)
- edge = RECT_LEFT(*mon) - 1;
- else
- edge = RECT_LEFT(*a) - 1;
+ edge = RECT_LEFT(*a) - 1;
break;
default:
g_assert_not_reached();
*dest = edge;
*near_edge = TRUE;
+ /* search for edges of monitors */
+ for (i = 0; i < screen_num_monitors; ++i) {
+ 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);
+ }
+
+ /* search for edges of clients */
for (it = client_list; it; it = g_list_next(it)) {
ObClient *cur = it->data;
detect_edge(dock_area, dir, my_head, my_size, my_edge_start,
my_edge_size, dest, near_edge);
g_free(a);
- g_free(mon);
}
void client_find_move_directional(ObClient *self, ObDirection dir,
projects / chaz / openbox / blobdiff