X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Ffloating.c;h=90e5024e8dc11773cd5711ef902b001368c3e497;hb=c36042dfb1c3556dafd6dc7f0bfdb2bfe26104b7;hp=2ba08330c3c218982bb3eb27dd27105cc896c945;hpb=42db9de7ec1c0b82ced3fa08abd238c5ba12d844;p=i3%2Fi3

diff --git a/src/floating.c b/src/floating.c
index 2ba08330..90e5024e 100644
--- a/src/floating.c
+++ b/src/floating.c
@@ -2,22 +2,22 @@
  * vim:ts=4:sw=4:expandtab
  *
  * i3 - an improved dynamic tiling window manager
+ * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
  *
- * © 2009-2010 Michael Stapelberg and contributors
- *
- * See file LICENSE for license information.
- *
- * src/floating.c: contains all functions for handling floating clients
+ * floating.c: Floating windows.
  *
  */
-
-
 #include "all.h"
 
 extern xcb_connection_t *conn;
 
 void floating_enable(Con *con, bool automatic) {
-    bool set_focus = true;
+    bool set_focus = (con == focused);
+
+    if (con->parent && con->parent->type == CT_DOCKAREA) {
+        LOG("Container is a dock window, not enabling floating mode.\n");
+        return;
+    }
 
     if (con_is_floating(con)) {
         LOG("Container is already in floating mode, not doing anything.\n");
@@ -80,16 +80,17 @@ void floating_enable(Con *con, bool automatic) {
     /* we need to set the parent afterwards instead of passing it as an
      * argument to con_new() because nc would be inserted into the tiling layer
      * otherwise. */
-    nc->parent = con_get_workspace(con);
+    Con *ws = con_get_workspace(con);
+    nc->parent = ws;
 
     /* check if the parent container is empty and close it if so */
     if ((con->parent->type == CT_CON || con->parent->type == CT_FLOATING_CON) && con_num_children(con->parent) == 0) {
         DLOG("Old container empty after setting this child to floating, closing\n");
-        tree_close(con->parent, DONT_KILL_WINDOW, false);
+        tree_close(con->parent, DONT_KILL_WINDOW, false, false);
     }
 
     char *name;
-    asprintf(&name, "[i3 con] floatingcon around %p", con);
+    sasprintf(&name, "[i3 con] floatingcon around %p", con);
     x_set_name(nc, name);
     free(name);
 
@@ -97,6 +98,7 @@ void floating_enable(Con *con, bool automatic) {
     int deco_height = config.font.height + 5;
 
     DLOG("Original rect: (%d, %d) with %d x %d\n", con->rect.x, con->rect.y, con->rect.width, con->rect.height);
+    DLOG("Geometry = (%d, %d) with %d x %d\n", con->geometry.x, con->geometry.y, con->geometry.width, con->geometry.height);
     Rect zero = { 0, 0, 0, 0 };
     nc->rect = con->geometry;
     /* If the geometry was not set (split containers), we need to determine a
@@ -116,22 +118,12 @@ void floating_enable(Con *con, bool automatic) {
     /* add pixels for the decoration */
     /* TODO: don’t add them when the user automatically puts new windows into
      * 1pixel/borderless mode */
-    nc->rect.height += deco_height + 4;
+    nc->rect.height += deco_height + 2;
     nc->rect.width += 4;
-    DLOG("Floating rect: (%d, %d) with %d x %d\n", nc->rect.x, nc->rect.y, nc->rect.width, nc->rect.height);
-    nc->orientation = NO_ORIENTATION;
-    nc->type = CT_FLOATING_CON;
-    TAILQ_INSERT_TAIL(&(nc->parent->floating_head), nc, floating_windows);
-    TAILQ_INSERT_TAIL(&(nc->parent->focus_head), nc, focused);
-
-    /* 3: attach the child to the new parent container */
-    con->parent = nc;
-    con->percent = 1.0;
-    con->floating = FLOATING_USER_ON;
 
-    /* 4: set the border style as specified with new_float */
-    if (automatic)
-        con->border_style = config.default_floating_border;
+    /* Honor the X11 border */
+    nc->rect.height += con->border_width * 2;
+    nc->rect.width += con->border_width * 2;
 
     /* Some clients (like GIMP’s color picker window) get mapped
      * to (0, 0), so we push them to a reasonable position
@@ -145,12 +137,41 @@ void floating_enable(Con *con, bool automatic) {
             nc->rect.y = leader->rect.y + (leader->rect.height / 2) - (nc->rect.height / 2);
         } else {
             /* center the window on workspace as fallback */
-            Con *ws = nc->parent;
             nc->rect.x = ws->rect.x + (ws->rect.width / 2) - (nc->rect.width / 2);
             nc->rect.y = ws->rect.y + (ws->rect.height / 2) - (nc->rect.height / 2);
         }
     }
 
+    /* Sanity check: Are the coordinates on the appropriate output? If not, we
+     * need to change them */
+    Output *current_output = get_output_containing(nc->rect.x, nc->rect.y);
+    Con *correct_output = con_get_output(ws);
+    if (!current_output || current_output->con != correct_output) {
+        DLOG("This floating window is on the wrong output, fixing coordinates (currently (%d, %d))\n",
+             nc->rect.x, nc->rect.y);
+        /* Take the relative coordinates of the current output, then add them
+         * to the coordinate space of the correct output */
+        uint32_t rel_x = (nc->rect.x - (current_output ? current_output->con->rect.x : 0));
+        uint32_t rel_y = (nc->rect.y - (current_output ? current_output->con->rect.y : 0));
+        nc->rect.x = correct_output->rect.x + rel_x;
+        nc->rect.y = correct_output->rect.y + rel_y;
+    }
+
+    DLOG("Floating rect: (%d, %d) with %d x %d\n", nc->rect.x, nc->rect.y, nc->rect.width, nc->rect.height);
+    nc->orientation = NO_ORIENTATION;
+    nc->type = CT_FLOATING_CON;
+    TAILQ_INSERT_TAIL(&(ws->floating_head), nc, floating_windows);
+    TAILQ_INSERT_TAIL(&(ws->focus_head), nc, focused);
+
+    /* 3: attach the child to the new parent container */
+    con->parent = nc;
+    con->percent = 1.0;
+    con->floating = FLOATING_USER_ON;
+
+    /* 4: set the border style as specified with new_float */
+    if (automatic)
+        con->border_style = config.default_floating_border;
+
     TAILQ_INSERT_TAIL(&(nc->nodes_head), con, nodes);
     TAILQ_INSERT_TAIL(&(nc->focus_head), con, focused);
 
@@ -158,7 +179,6 @@ void floating_enable(Con *con, bool automatic) {
     render_con(nc, false);
     render_con(con, false);
 
-    // TODO: don’t influence focus handling when Con was not focused before.
     if (set_focus)
         con_focus(con);
 
@@ -172,7 +192,6 @@ void floating_enable(Con *con, bool automatic) {
         return;
 
     ELOG("No output found at destination coordinates, centering floating window on current ws\n");
-    Con *ws = nc->parent;
     nc->rect.x = ws->rect.x + (ws->rect.width / 2) - (nc->rect.width / 2);
     nc->rect.y = ws->rect.y + (ws->rect.height / 2) - (nc->rect.height / 2);
 }
@@ -192,7 +211,7 @@ void floating_disable(Con *con, bool automatic) {
     /* 2: kill parent container */
     TAILQ_REMOVE(&(con->parent->parent->floating_head), con->parent, floating_windows);
     TAILQ_REMOVE(&(con->parent->parent->focus_head), con->parent, focused);
-    tree_close(con->parent, DONT_KILL_WINDOW, false);
+    tree_close(con->parent, DONT_KILL_WINDOW, false, false);
 
     /* 3: re-attach to the parent of the currently focused con on the workspace
      * this floating con was on */
@@ -271,13 +290,13 @@ bool floating_maybe_reassign_ws(Con *con) {
     Con *content = output_get_content(output->con);
     Con *ws = TAILQ_FIRST(&(content->focus_head));
     DLOG("Moving con %p / %s to workspace %p / %s\n", con, con->name, ws, ws->name);
-    con_move_to_workspace(con, ws);
+    con_move_to_workspace(con, ws, false, true);
     con_focus(con_descend_focused(con));
     return true;
 }
 
 DRAGGING_CB(drag_window_callback) {
-    struct xcb_button_press_event_t *event = extra;
+    const struct xcb_button_press_event_t *event = extra;
 
     /* Reposition the client correctly while moving */
     con->rect.x = old_rect->x + (new_x - event->root_x);
@@ -298,7 +317,7 @@ DRAGGING_CB(drag_window_callback) {
  * Calls the drag_pointer function with the drag_window callback
  *
  */
-void floating_drag_window(Con *con, xcb_button_press_event_t *event) {
+void floating_drag_window(Con *con, const xcb_button_press_event_t *event) {
     DLOG("floating_drag_window\n");
 
     /* Push changes before dragging, so that the window gets raised now and not
@@ -318,14 +337,14 @@ void floating_drag_window(Con *con, xcb_button_press_event_t *event) {
  *
  */
 struct resize_window_callback_params {
-    border_t corner;
-    bool proportional;
-    xcb_button_press_event_t *event;
+    const border_t corner;
+    const bool proportional;
+    const xcb_button_press_event_t *event;
 };
 
 DRAGGING_CB(resize_window_callback) {
-    struct resize_window_callback_params *params = extra;
-    xcb_button_press_event_t *event = params->event;
+    const struct resize_window_callback_params *params = extra;
+    const xcb_button_press_event_t *event = params->event;
     border_t corner = params->corner;
 
     int32_t dest_x = con->rect.x;
@@ -378,8 +397,8 @@ DRAGGING_CB(resize_window_callback) {
  * Calls the drag_pointer function with the resize_window callback
  *
  */
-void floating_resize_window(Con *con, bool proportional,
-                            xcb_button_press_event_t *event) {
+void floating_resize_window(Con *con, const bool proportional,
+                            const xcb_button_press_event_t *event) {
     DLOG("floating_resize_window\n");
 
     /* corner saves the nearest corner to the original click. It contains
@@ -407,8 +426,8 @@ void floating_resize_window(Con *con, bool proportional,
  * the event and the new coordinates (x, y).
  *
  */
-void drag_pointer(Con *con, xcb_button_press_event_t *event, xcb_window_t
-                confine_to, border_t border, callback_t callback, void *extra)
+void drag_pointer(Con *con, const xcb_button_press_event_t *event, xcb_window_t
+                confine_to, border_t border, callback_t callback, const void *extra)
 {
     uint32_t new_x, new_y;
     Rect old_rect;
@@ -496,31 +515,6 @@ void drag_pointer(Con *con, xcb_button_press_event_t *event, xcb_window_t
 }
 
 #if 0
-/*
- * Changes focus in the given direction for floating clients.
- *
- * Changing to the left/right means going to the previous/next floating client,
- * changing to top/bottom means cycling through the Z-index.
- *
- */
-void floating_focus_direction(xcb_connection_t *conn, Client *currently_focused, direction_t direction) {
-        DLOG("floating focus\n");
-
-        if (direction == D_LEFT || direction == D_RIGHT) {
-                /* Go to the next/previous floating client */
-                Client *client;
-
-                while ((client = (direction == D_LEFT ? TAILQ_PREV(currently_focused, floating_clients_head, floating_clients) :
-                                                        TAILQ_NEXT(currently_focused, floating_clients))) !=
-                       TAILQ_END(&(currently_focused->workspace->floating_clients))) {
-                        if (!client->floating)
-                                continue;
-                        set_focus(conn, client, true);
-                        return;
-                }
-        }
-}
-
 /*
  * Moves the client 10px to the specified direction.
  *