X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fplace.c;h=7d5c869439863e7cd594b02aa94e72c074af8668;hb=HEAD;hp=0b8309a22ba74d6c867c1b673c27022ad60f101c;hpb=128209b1c3dd4be15b8ddf5e6e007a335e987549;p=chaz%2Fopenbox diff --git a/openbox/place.c b/openbox/place.c index 0b8309a2..7d5c8694 100644 --- a/openbox/place.c +++ b/openbox/place.c @@ -23,438 +23,344 @@ #include "frame.h" #include "focus.h" #include "config.h" +#include "dock.h" #include "debug.h" +#include "place_overlap.h" -static void add_choice(guint *choice, guint mychoice) +static Rect *choose_pointer_monitor(ObClient *c) { - guint i; - for (i = 0; i < screen_num_monitors; ++i) { - if (choice[i] == mychoice) - return; - else if (choice[i] == screen_num_monitors) { - choice[i] = mychoice; - return; - } - } + return screen_area(c->desktop, screen_monitor_pointer(), NULL); } -static Rect *pick_pointer_head(ObClient *c) -{ - guint i; - gint px, py; - - screen_pointer_pos(&px, &py); - - for (i = 0; i < screen_num_monitors; ++i) { - if (RECT_CONTAINS(*screen_physical_area_monitor(i), px, py)) { - return screen_area_monitor(c->desktop, i); - } - } - g_assert_not_reached(); -} +/* use the following priority lists for choose_monitor() + + When a window is being placed in the FOREGROUND, use a monitor chosen in + the following order: + 1. per-app settings + 2. same monitor as parent + 3. primary monitor if placement=PRIMARY + active monitor if placement=ACTIVE + pointer monitor if placement=MOUSE + 4. primary monitor + 5. other monitors where the window has group members on the same desktop + 6. other monitors where the window has group members on other desktops + 7. other monitors + + When a window is being placed in the BACKGROUND, use a monitor chosen in the + following order: + 1. per-app settings + 2. same monitor as parent + 3. other monitors where the window has group members on the same desktop + 3a. primary monitor in this set + 3b. other monitors in this set + 4. other monitors where the window has group members on other desktops + 4a. primary monitor in this set + 4b. other monitors in this set + 5. other monitors + 5a. primary monitor in this set + 5b. other monitors in this set +*/ -/*! Pick a monitor to place a window on. - The returned array value should be freed with g_free. The areas within the - array should not be freed. */ -static Rect **pick_head(ObClient *c) +/*! One for each possible head, used to sort them in order of precedence. */ +typedef struct { + guint monitor; + guint flags; +} ObPlaceHead; + +/*! Flags for ObPlaceHead */ +enum { + HEAD_PARENT = 1 << 0, /* parent's monitor */ + HEAD_PLACED = 1 << 1, /* chosen monitor by placement */ + HEAD_PRIMARY = 1 << 2, /* primary monitor */ + HEAD_GROUP_DESK = 1 << 3, /* has a group member on the same desktop */ + HEAD_GROUP = 1 << 4, /* has a group member on another desktop */ + HEAD_PERAPP = 1 << 5, /* chosen by per-app settings */ +}; + +gint cmp_foreground(const void *a, const void *b) { - Rect **area; - guint *choice; - guint i; - gint px, py; - ObClient *p; + const ObPlaceHead *h1 = a; + const ObPlaceHead *h2 = b; + gint i = 0; - area = g_new(Rect*, screen_num_monitors); - choice = g_new(guint, screen_num_monitors); - for (i = 0; i < screen_num_monitors; ++i) - choice[i] = screen_num_monitors; /* make them all invalid to start */ + if (h1->monitor == h2->monitor) return 0; - /* try direct parent first */ - if ((p = client_direct_parent(c))) { - add_choice(choice, client_monitor(p)); - ob_debug("placement adding choice %d for parent\n", - client_monitor(p)); - } + if (h1->flags & HEAD_PERAPP) --i; + if (h2->flags & HEAD_PERAPP) ++i; + if (i) return i; - /* more than one window in its group (more than just this window) */ - if (client_has_group_siblings(c)) { - GSList *it; + if (h1->flags & HEAD_PARENT) --i; + if (h2->flags & HEAD_PARENT) ++i; + if (i) return i; - /* try on the client's desktop */ - for (it = c->group->members; it; it = g_slist_next(it)) { - ObClient *itc = it->data; - if (itc != c && - (itc->desktop == c->desktop || - itc->desktop == DESKTOP_ALL || c->desktop == DESKTOP_ALL)) - { - add_choice(choice, client_monitor(it->data)); - ob_debug("placement adding choice %d for group sibling\n", - client_monitor(it->data)); - } - } - - /* try on all desktops */ - for (it = c->group->members; it; it = g_slist_next(it)) { - ObClient *itc = it->data; - if (itc != c) { - add_choice(choice, client_monitor(it->data)); - ob_debug("placement adding choice %d for group sibling on " - "another desktop\n", client_monitor(it->data)); - } - } - } + if (h1->flags & HEAD_PLACED) --i; + if (h2->flags & HEAD_PLACED) ++i; + if (i) return i; - if (focus_client) { - add_choice(choice, client_monitor(focus_client)); - ob_debug("placement adding choice %d for focused window\n", - client_monitor(focus_client)); - } + if (h1->flags & HEAD_PRIMARY) --i; + if (h2->flags & HEAD_PRIMARY) ++i; + if (i) return i; - screen_pointer_pos(&px, &py); + if (h1->flags & HEAD_GROUP_DESK) --i; + if (h2->flags & HEAD_GROUP_DESK) ++i; + if (i) return i; - for (i = 0; i < screen_num_monitors; i++) - if (RECT_CONTAINS(*screen_physical_area_monitor(i), px, py)) { - add_choice(choice, i); - ob_debug("placement adding choice %d for mouse pointer\n", i); - break; - } + if (h1->flags & HEAD_GROUP) --i; + if (h2->flags & HEAD_GROUP) ++i; + if (i) return i; - /* add any leftover choices */ - for (i = 0; i < screen_num_monitors; ++i) - add_choice(choice, i); - - for (i = 0; i < screen_num_monitors; ++i) - area[i] = screen_area_monitor(c->desktop, choice[i]); - - return area; + return h1->monitor - h2->monitor; } -static gboolean place_random(ObClient *client, gint *x, gint *y) +gint cmp_background(const void *a, const void *b) { - gint l, r, t, b; - Rect **areas; - guint i; - - areas = pick_head(client); - i = g_random_int_range(0, screen_num_monitors); - - l = areas[i]->x; - t = areas[i]->y; - r = areas[i]->x + areas[i]->width - client->frame->area.width; - b = areas[i]->y + areas[i]->height - client->frame->area.height; - - if (r > l) *x = g_random_int_range(l, r + 1); - else *x = areas[i]->x; - if (b > t) *y = g_random_int_range(t, b + 1); - else *y = areas[i]->y; + const ObPlaceHead *h1 = a; + const ObPlaceHead *h2 = b; + gint i = 0; + + if (h1->monitor == h2->monitor) return 0; + + if (h1->flags & HEAD_PERAPP) --i; + if (h2->flags & HEAD_PERAPP) ++i; + if (i) return i; + + if (h1->flags & HEAD_PARENT) --i; + if (h2->flags & HEAD_PARENT) ++i; + if (i) return i; + + if (h1->flags & HEAD_GROUP_DESK || h2->flags & HEAD_GROUP_DESK) { + if (h1->flags & HEAD_GROUP_DESK) --i; + if (h2->flags & HEAD_GROUP_DESK) ++i; + if (i) return i; + if (h1->flags & HEAD_PRIMARY) --i; + if (h2->flags & HEAD_PRIMARY) ++i; + if (i) return i; + } - g_free(areas); + if (h1->flags & HEAD_GROUP || h2->flags & HEAD_GROUP) { + if (h1->flags & HEAD_GROUP) --i; + if (h2->flags & HEAD_GROUP) ++i; + if (i) return i; + if (h1->flags & HEAD_PRIMARY) --i; + if (h2->flags & HEAD_PRIMARY) ++i; + if (i) return i; + } - return TRUE; -} + if (h1->flags & HEAD_PRIMARY) --i; + if (h2->flags & HEAD_PRIMARY) ++i; + if (i) return i; -static GSList* area_add(GSList *list, Rect *a) -{ - Rect *r = g_new(Rect, 1); - *r = *a; - return g_slist_prepend(list, r); + return h1->monitor - h2->monitor; } -static GSList* area_remove(GSList *list, Rect *a) +/*! Pick a monitor to place a window on. */ +static Rect* choose_monitor(ObClient *c, gboolean client_to_be_foregrounded, + ObAppSettings *settings) { - GSList *sit; - GSList *result = NULL; - - for (sit = list; sit; sit = g_slist_next(sit)) { - Rect *r = sit->data; - - if (!RECT_INTERSECTS_RECT(*r, *a)) { - result = g_slist_prepend(result, r); - r = NULL; /* dont free it */ - } else { - Rect isect, extra; - - /* Use an intersection of a and r to determine the space - around r that we can use. - - NOTE: the spaces calculated can overlap. - */ - - RECT_SET_INTERSECTION(isect, *r, *a); - - if (RECT_LEFT(isect) > RECT_LEFT(*r)) { - RECT_SET(extra, r->x, r->y, - RECT_LEFT(isect) - r->x, r->height); - result = area_add(result, &extra); - } + Rect *area; + ObPlaceHead *choice; + guint i; + ObClient *p; + GSList *it; - if (RECT_TOP(isect) > RECT_TOP(*r)) { - RECT_SET(extra, r->x, r->y, - r->width, RECT_TOP(isect) - r->y + 1); - result = area_add(result, &extra); - } + choice = g_new(ObPlaceHead, screen_num_monitors); + for (i = 0; i < screen_num_monitors; ++i) { + choice[i].monitor = i; + choice[i].flags = 0; + } - if (RECT_RIGHT(isect) < RECT_RIGHT(*r)) { - RECT_SET(extra, RECT_RIGHT(isect) + 1, r->y, - RECT_RIGHT(*r) - RECT_RIGHT(isect), r->height); - result = area_add(result, &extra); - } + /* find monitors with group members */ + if (c->group) { + for (it = c->group->members; it; it = g_slist_next(it)) { + ObClient *itc = it->data; + if (itc != c) { + guint m = client_monitor(itc); - if (RECT_BOTTOM(isect) < RECT_BOTTOM(*r)) { - RECT_SET(extra, r->x, RECT_BOTTOM(isect) + 1, - r->width, RECT_BOTTOM(*r) - RECT_BOTTOM(isect)); - result = area_add(result, &extra); + if (m < screen_num_monitors) { + if (screen_compare_desktops(itc->desktop, c->desktop)) + choice[m].flags |= HEAD_GROUP_DESK; + else + choice[m].flags |= HEAD_GROUP; + } } } - - g_free(r); } - g_slist_free(list); - return result; -} -static gint area_cmp(gconstpointer p1, gconstpointer p2, gpointer data) -{ - ObClient *c = data; - Rect *carea = &c->frame->area; - const Rect *a1 = p1, *a2 = p2; - gboolean diffhead = FALSE; - guint i; - Rect *a; - - for (i = 0; i < screen_num_monitors; ++i) { - a = screen_physical_area_monitor(i); - if (RECT_CONTAINS(*a, a1->x, a1->y) && - !RECT_CONTAINS(*a, a2->x, a2->y)) - { - diffhead = TRUE; - break; - } + i = screen_monitor_primary(FALSE); + if (i < screen_num_monitors) { + choice[i].flags |= HEAD_PRIMARY; + if (config_place_monitor == OB_PLACE_MONITOR_PRIMARY) + choice[i].flags |= HEAD_PLACED; + if (settings && + settings->monitor_type == OB_PLACE_MONITOR_PRIMARY) + choice[i].flags |= HEAD_PERAPP; } - /* has to be more than me in the group */ - if (diffhead && client_has_group_siblings(c)) { - guint *num, most; - GSList *it; - - /* find how many clients in the group are on each monitor, use the - monitor with the most in it */ - num = g_new0(guint, screen_num_monitors); - for (it = c->group->members; it; it = g_slist_next(it)) - if (it->data != c) - ++num[client_monitor(it->data)]; - most = 0; - for (i = 1; i < screen_num_monitors; ++i) - if (num[i] > num[most]) - most = i; - - g_free(num); - - a = screen_physical_area_monitor(most); - if (RECT_CONTAINS(*a, a1->x, a1->y)) - return -1; - if (RECT_CONTAINS(*a, a2->x, a2->y)) - return 1; + i = screen_monitor_active(); + if (i < screen_num_monitors) { + if (config_place_monitor == OB_PLACE_MONITOR_ACTIVE) + choice[i].flags |= HEAD_PLACED; + if (settings && + settings->monitor_type == OB_PLACE_MONITOR_ACTIVE) + choice[i].flags |= HEAD_PERAPP; } - return MIN((a1->width - carea->width), (a1->height - carea->height)) - - MIN((a2->width - carea->width), (a2->height - carea->height)); -} - -typedef enum -{ - SMART_FULL, - SMART_GROUP, - SMART_FOCUSED -} ObSmartType; - -#define SMART_IGNORE(placer, c) \ - (placer == c || c->shaded || !c->frame->visible || \ - c->type == OB_CLIENT_TYPE_SPLASH || c->type == OB_CLIENT_TYPE_DESKTOP || \ - ((c->type == OB_CLIENT_TYPE_MENU || c->type == OB_CLIENT_TYPE_TOOLBAR) &&\ - client_has_parent(c)) || \ - (c->desktop != DESKTOP_ALL && \ - c->desktop != (placer->desktop == DESKTOP_ALL ? \ - screen_desktop : placer->desktop))) - -static gboolean place_smart(ObClient *client, gint *x, gint *y, - ObSmartType type, gboolean ignore_max) -{ - gboolean ret = FALSE; - GSList *spaces = NULL, *sit; - GList *it; - Rect **areas; - guint i; - - if (type == SMART_GROUP) { - /* has to be more than me in the group */ - if (!client_has_group_siblings(client)) - return FALSE; + i = screen_monitor_pointer(); + if (i < screen_num_monitors) { + if (config_place_monitor == OB_PLACE_MONITOR_MOUSE) + choice[i].flags |= HEAD_PLACED; + if (settings && + settings->monitor_type == OB_PLACE_MONITOR_MOUSE) + choice[i].flags |= HEAD_PERAPP; } - areas = pick_head(client); - - for (i = 0; i < screen_num_monitors && !ret; ++i) { - spaces = area_add(spaces, areas[i]); - - /* stay out from under windows in higher layers */ - for (it = stacking_list; it; it = g_list_next(it)) { - ObClient *c; - - if (WINDOW_IS_CLIENT(it->data)) { - c = it->data; - if (ignore_max && - (c->fullscreen || (c->max_vert && c->max_horz))) - continue; - } else - continue; - - if (c->layer > client->layer) { - if (!SMART_IGNORE(client, c)) - spaces = area_remove(spaces, &c->frame->area); - } else - break; - } - - if (type == SMART_FULL || type == SMART_FOCUSED) { - gboolean found_foc = FALSE, stop = FALSE; - ObClient *foc; - - foc = focus_order_find_first(client->desktop == DESKTOP_ALL ? - screen_desktop : client->desktop); - - for (; it && !stop; it = g_list_next(it)) { - ObClient *c; - - if (WINDOW_IS_CLIENT(it->data)) { - c = it->data; - if (ignore_max && - (c->fullscreen || (c->max_vert && c->max_horz))) - continue; - } else - continue; + if (settings) { + i = settings->monitor - 1; + if (i < screen_num_monitors) + choice[i].flags |= HEAD_PERAPP; + } - if (!SMART_IGNORE(client, c)) { - if (type == SMART_FOCUSED) - if (found_foc) - stop = TRUE; - if (!stop) - spaces = area_remove(spaces, &c->frame->area); - } + /* direct parent takes highest precedence */ + if ((p = client_direct_parent(c))) { + i = client_monitor(p); + if (i < screen_num_monitors) + choice[i].flags |= HEAD_PARENT; + } - if (c == foc) - found_foc = TRUE; - } - } else if (type == SMART_GROUP) { - for (sit = client->group->members; sit; sit = g_slist_next(sit)) { - ObClient *c = sit->data; - if (!SMART_IGNORE(client, c)) - spaces = area_remove(spaces, &c->frame->area); - } - } else - g_assert_not_reached(); - - spaces = g_slist_sort_with_data(spaces, area_cmp, client); - - for (sit = spaces; sit; sit = g_slist_next(sit)) { - Rect *r = sit->data; - - if (!ret) { - if (r->width >= client->frame->area.width && - r->height >= client->frame->area.height) { - ret = TRUE; - if (client->type == OB_CLIENT_TYPE_DIALOG || - type != SMART_FULL) - { - *x = r->x + (r->width - client->frame->area.width)/2; - *y = r->y + (r->height - client->frame->area.height)/2; - } else { - *x = r->x; - *y = r->y; - } - } - } + qsort(choice, screen_num_monitors, sizeof(ObPlaceHead), + client_to_be_foregrounded ? cmp_foreground : cmp_background); - g_free(r); - } - g_slist_free(spaces); - spaces = NULL; + /* save the areas of the monitors in order of their being chosen */ + for (i = 0; i < screen_num_monitors; ++i) + { + ob_debug("placement choice %d is monitor %d", i, choice[i].monitor); + if (choice[i].flags & HEAD_PARENT) + ob_debug(" - parent on monitor"); + if (choice[i].flags & HEAD_PLACED) + ob_debug(" - placement choice"); + if (choice[i].flags & HEAD_PRIMARY) + ob_debug(" - primary monitor"); + if (choice[i].flags & HEAD_GROUP_DESK) + ob_debug(" - group on same desktop"); + if (choice[i].flags & HEAD_GROUP) + ob_debug(" - group on other desktop"); } - g_free(areas); + area = screen_area(c->desktop, choice[0].monitor, NULL); + + g_free(choice); - return ret; + /* return the area for the chosen monitor */ + return area; } -static gboolean place_under_mouse(ObClient *client, gint *x, gint *y) +static gboolean place_under_mouse(ObClient *client, gint *x, gint *y, + Size frame_size) { + if (config_place_policy != OB_PLACE_POLICY_MOUSE) + return FALSE; + gint l, r, t, b; gint px, py; Rect *area; - area = pick_pointer_head(client); - screen_pointer_pos(&px, &py); + ob_debug("placing under mouse"); + + if (!screen_pointer_pos(&px, &py)) + return FALSE; + area = choose_pointer_monitor(client); l = area->x; t = area->y; - r = area->x + area->width - client->frame->area.width; - b = area->y + area->height - client->frame->area.height; + r = area->x + area->width - frame_size.width; + b = area->y + area->height - frame_size.height; - *x = px - client->area.width / 2 - client->frame->size.left; + *x = px - frame_size.width / 2; *x = MIN(MAX(*x, l), r); - *y = py - client->area.height / 2 - client->frame->size.top; + *y = py - frame_size.height / 2; *y = MIN(MAX(*y, t), b); + g_slice_free(Rect, area); + return TRUE; } -static gboolean place_per_app_setting(ObClient *client, gint *x, gint *y, - ObAppSettings *settings) +static gboolean place_per_app_setting_position(ObClient *client, Rect *screen, + gint *x, gint *y, + ObAppSettings *settings, + Size frame_size) { - Rect *screen = NULL; - - if (!settings || (settings && !settings->pos_given)) + if (!settings || !settings->pos_given) return FALSE; - /* Find which head the pointer is on */ - if (settings->monitor == 0) - screen = pick_pointer_head(client); - else if (settings->monitor > 0 && - (guint)settings->monitor <= screen_num_monitors) - screen = screen_area_monitor(client->desktop, - (guint)settings->monitor - 1); - else { - Rect **all = NULL; - all = pick_head(client); - screen = all[0]; - g_free(all); /* the areas themselves don't need to be freed */ - } + ob_debug("placing by per-app settings"); - if (settings->center_x) + if (settings->position.x.center) *x = screen->x + screen->width / 2 - client->area.width / 2; - else if (settings->opposite_x) - *x = screen->x + screen->width - client->frame->area.width - - settings->position.x; + else if (settings->position.x.opposite) + *x = screen->x + screen->width - frame_size.width - + settings->position.x.pos; else - *x = screen->x + settings->position.x; + *x = screen->x + settings->position.x.pos; + if (settings->position.x.denom) + *x = (*x * screen->width) / settings->position.x.denom; - if (settings->center_y) + if (settings->position.y.center) *y = screen->y + screen->height / 2 - client->area.height / 2; - else if (settings->opposite_y) - *y = screen->y + screen->height - client->frame->area.height - - settings->position.y; + else if (settings->position.y.opposite) + *y = screen->y + screen->height - frame_size.height - + settings->position.y.pos; else - *y = screen->y + settings->position.y; + *y = screen->y + settings->position.y.pos; + if (settings->position.y.denom) + *y = (*y * screen->height) / settings->position.y.denom; return TRUE; } -static gboolean place_transient_splash(ObClient *client, gint *x, gint *y) +static void place_per_app_setting_size(ObClient *client, Rect *screen, + gint *w, gint *h, + ObAppSettings *settings) +{ + if (!settings) + return; + + g_assert(settings->width_num >= 0); + g_assert(settings->width_denom >= 0); + g_assert(settings->height_num >= 0); + g_assert(settings->height_denom >= 0); + + if (settings->width_num) { + ob_debug("setting width by per-app settings"); + if (!settings->width_denom) + *w = settings->width_num; + else { + *w = screen->width * settings->width_num / settings->width_denom; + *w = MIN(*w, screen->width); + } + } + + if (settings->height_num) { + ob_debug("setting height by per-app settings"); + if (!settings->height_denom) + *h = settings->height_num; + else { + *h = screen->height * settings->height_num / settings->height_denom; + *h = MIN(*h, screen->height); + } + } +} + +static gboolean place_transient_splash(ObClient *client, Rect *area, + gint *x, gint *y, Size frame_size) { if (client->type == OB_CLIENT_TYPE_DIALOG) { GSList *it; gboolean first = TRUE; gint l, r, t, b; + + ob_debug("placing dialog"); + for (it = client->parents; it; it = g_slist_next(it)) { ObClient *m = it->data; if (!m->iconic) { @@ -472,8 +378,8 @@ static gboolean place_transient_splash(ObClient *client, gint *x, gint *y) } } if (!first) { - *x = ((r + 1 - l) - client->frame->area.width) / 2 + l; - *y = ((b + 1 - t) - client->frame->area.height) / 2 + t; + *x = ((r + 1 - l) - frame_size.width) / 2 + l; + *y = ((b + 1 - t) - frame_size.height) / 2 + t; return TRUE; } } @@ -482,42 +388,124 @@ static gboolean place_transient_splash(ObClient *client, gint *x, gint *y) if (client->type == OB_CLIENT_TYPE_DIALOG || client->type == OB_CLIENT_TYPE_SPLASH) { - Rect **areas; - - areas = pick_head(client); + ob_debug("placing dialog or splash"); - *x = (areas[0]->width - client->frame->area.width) / 2 + areas[0]->x; - *y = (areas[0]->height - client->frame->area.height) / 2 + areas[0]->y; - - g_free(areas); + *x = (area->width - frame_size.width) / 2 + area->x; + *y = (area->height - frame_size.height) / 2 + area->y; return TRUE; } return FALSE; } -/* Return TRUE if we want client.c to enforce on-screen-keeping */ -gboolean place_client(ObClient *client, gint *x, gint *y, - ObAppSettings *settings) +static gboolean place_least_overlap(ObClient *c, Rect *head, int *x, int *y, + Size frame_size) +{ + /* Assemble the list of windows that could overlap with @c in the user's + current view. */ + GSList* potential_overlap_clients = NULL; + gint n_client_rects = config_dock_hide ? 0 : 1; + + /* if we're "showing desktop", ignore all existing windows */ + if (!screen_showing_desktop) { + GList* it; + for (it = client_list; it != NULL; it = g_list_next(it)) { + ObClient* maybe_client = (ObClient*)it->data; + if (maybe_client == c) + continue; + if (maybe_client->iconic) + continue; + if (!client_occupies_space(maybe_client)) + continue; + if (c->desktop != DESKTOP_ALL) { + if (maybe_client->desktop != c->desktop && + maybe_client->desktop != DESKTOP_ALL) + continue; + } else { + if (maybe_client->desktop != screen_desktop && + maybe_client->desktop != DESKTOP_ALL) + continue; + } + + potential_overlap_clients = g_slist_prepend( + potential_overlap_clients, maybe_client); + n_client_rects += 1; + } + } + Rect client_rects[n_client_rects]; + + GSList* it; + guint i = 0; + if (!config_dock_hide) + dock_get_area(&client_rects[i++]); + for (it = potential_overlap_clients; it != NULL; it = g_slist_next(it)) { + ObClient* potential_overlap_client = (ObClient*)it->data; + client_rects[i] = potential_overlap_client->frame->area; + i += 1; + } + g_slist_free(potential_overlap_clients); + + Point result; + place_overlap_find_least_placement(client_rects, n_client_rects, head, + &frame_size, &result); + *x = result.x; + *y = result.y; + + return TRUE; +} + +static gboolean should_set_client_position(ObClient *client, + ObAppSettings *settings) { - gboolean ret = FALSE; - if (client->positioned) + gboolean has_position = settings && settings->pos_given; + gboolean has_forced_position = has_position && settings->pos_force; + + gboolean user_positioned = client->positioned & USPosition; + if (user_positioned && !has_forced_position) return FALSE; - if (place_transient_splash(client, x, y)) - ret = TRUE; - else if (!( - place_per_app_setting(client, x, y, settings) || - ((config_place_policy == OB_PLACE_POLICY_MOUSE) ? - place_under_mouse(client, x, y) : - place_smart(client, x, y, SMART_FULL, FALSE) || - place_smart(client, x, y, SMART_FULL, TRUE) || - place_smart(client, x, y, SMART_GROUP, FALSE) || - place_smart(client, x, y, SMART_GROUP, TRUE) || - place_smart(client, x, y, SMART_FOCUSED, TRUE) || - place_random(client, x, y)))) - g_assert_not_reached(); /* the last one better succeed */ + + gboolean program_positioned = client->positioned & PPosition; + if (program_positioned && !has_position) + return FALSE; + + return TRUE; +} + +gboolean place_client(ObClient *client, gboolean client_to_be_foregrounded, + Rect* client_area, ObAppSettings *settings) +{ + gboolean ret; + Rect *monitor_area; + int *x, *y, *w, *h; + Size frame_size; + + monitor_area = choose_monitor(client, client_to_be_foregrounded, settings); + + w = &client_area->width; + h = &client_area->height; + place_per_app_setting_size(client, monitor_area, w, h, settings); + + if (!should_set_client_position(client, settings)) + return FALSE; + + x = &client_area->x; + y = &client_area->y; + + SIZE_SET(frame_size, + *w + client->frame->size.left + client->frame->size.right, + *h + client->frame->size.top + client->frame->size.bottom); + + ret = + place_per_app_setting_position(client, monitor_area, x, y, settings, + frame_size) || + place_transient_splash(client, monitor_area, x, y, frame_size) || + place_under_mouse(client, x, y, frame_size) || + place_least_overlap(client, monitor_area, x, y, frame_size); + g_assert(ret); + + g_slice_free(Rect, monitor_area); + /* get where the client should be */ - frame_frame_gravity(client->frame, x, y, - client->area.width, client->area.height); - return ret; + frame_frame_gravity(client->frame, x, y); + return TRUE; }