X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fscratchpad.c;h=17df77dde624804e642a0934c9157a06bef07e18;hb=9ee26a608e329ceea583950fcc92bc5a28f6cf55;hp=16e26ceebe32b0964380b039e8a710fabe9274c8;hpb=9c3ece56d20db392610ae3106d570ee47c5831e8;p=i3%2Fi3 diff --git a/src/scratchpad.c b/src/scratchpad.c index 16e26cee..17df77dd 100644 --- a/src/scratchpad.c +++ b/src/scratchpad.c @@ -4,7 +4,7 @@ * vim:ts=4:sw=4:expandtab * * i3 - an improved dynamic tiling window manager - * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE) + * © 2009-2013 Michael Stapelberg and contributors (see also: LICENSE) * * scratchpad.c: Moving windows to the scratchpad and making them visible again. * @@ -39,15 +39,26 @@ void scratchpad_move(Con *con) { return; } - /* 1: Ensure the window is floating. From now on, we deal with the - * CT_FLOATING_CON. We use automatic == false because the user made the - * choice that this window should be a scratchpad (and floating). */ - floating_enable(con, false); - con = con->parent; + /* If the current con is in fullscreen mode, we need to disable that, + * as a scratchpad window should never be in fullscreen mode */ + if (focused && focused->type != CT_WORKSPACE && focused->fullscreen_mode != CF_NONE) { + con_toggle_fullscreen(focused, CF_OUTPUT); + } + + /* 1: Ensure the window or any parent is floating. From now on, we deal + * with the CT_FLOATING_CON. We use automatic == false because the user + * made the choice that this window should be a scratchpad (and floating). + */ + Con *maybe_floating_con = con_inside_floating(con); + if (maybe_floating_con == NULL) { + floating_enable(con, false); + con = con->parent; + } else { + con = maybe_floating_con; + } /* 2: Send the window to the __i3_scratch workspace, mainting its * coordinates and not warping the pointer. */ - Con *focus_next = con_next_focused(con); con_move_to_workspace(con, __i3_scratch, true, true); /* 3: If this is the first time this window is used as a scratchpad, we set @@ -55,13 +66,14 @@ void scratchpad_move(Con *con) { * adjusted in size according to what the user specifies. */ if (con->scratchpad_state == SCRATCHPAD_NONE) { DLOG("This window was never used as a scratchpad before.\n"); - con->scratchpad_state = SCRATCHPAD_FRESH; + if (con == maybe_floating_con) { + DLOG("It was in floating mode before, set scratchpad state to changed.\n"); + con->scratchpad_state = SCRATCHPAD_CHANGED; + } else { + DLOG("It was in tiling mode before, set scratchpad state to fresh.\n"); + con->scratchpad_state = SCRATCHPAD_FRESH; + } } - - /* 4: Fix focus. Normally, when moving a window to a different output, the - * destination output gets focused. In this case, we don’t want that. */ - if (con_get_workspace(focus_next) == con_get_workspace(focused)) - con_focus(focus_next); } /* @@ -78,16 +90,6 @@ void scratchpad_show(Con *con) { Con *__i3_scratch = workspace_get("__i3_scratch", NULL); Con *floating; - /* If the current con or any of its parents are in fullscreen mode, we - * first need to disable it before showing the scratchpad con. */ - Con *fs = focused; - while (fs && fs->fullscreen_mode == CF_NONE) - fs = fs->parent; - - if (fs->type != CT_WORKSPACE) { - con_toggle_fullscreen(focused, CF_OUTPUT); - } - /* If this was 'scratchpad show' without criteria, we check if the * currently focused window is a scratchpad window and should be hidden * again. */ @@ -99,6 +101,58 @@ void scratchpad_show(Con *con) { return; } + /* If the current con or any of its parents are in fullscreen mode, we + * first need to disable it before showing the scratchpad con. */ + Con *fs = focused; + while (fs && fs->fullscreen_mode == CF_NONE) + fs = fs->parent; + + if (fs && fs->type != CT_WORKSPACE) { + con_toggle_fullscreen(fs, CF_OUTPUT); + } + + /* If this was 'scratchpad show' without criteria, we check if there is a + * unfocused scratchpad on the current workspace and focus it */ + Con *walk_con; + Con *focused_ws = con_get_workspace(focused); + TAILQ_FOREACH(walk_con, &(focused_ws->floating_head), floating_windows) { + if (!con && (floating = con_inside_floating(walk_con)) && + floating->scratchpad_state != SCRATCHPAD_NONE && + floating != con_inside_floating(focused)) { + DLOG("Found an unfocused scratchpad window on this workspace\n"); + DLOG("Focusing it: %p\n", walk_con); + /* use con_descend_tiling_focused to get the last focused + * window inside this scratch container in order to + * keep the focus the same within this container */ + con_focus(con_descend_tiling_focused(walk_con)); + return; + } + } + + /* If this was 'scratchpad show' without criteria, we check if there is a + * visible scratchpad window on another workspace. In this case we move it + * to the current workspace. */ + focused_ws = con_get_workspace(focused); + TAILQ_FOREACH(walk_con, &all_cons, all_cons) { + Con *walk_ws = con_get_workspace(walk_con); + if (!con && walk_ws && + !con_is_internal(walk_ws) && focused_ws != walk_ws && + (floating = con_inside_floating(walk_con)) && + floating->scratchpad_state != SCRATCHPAD_NONE) { + DLOG("Found a visible scratchpad window on another workspace,\n"); + DLOG("moving it to this workspace: con = %p\n", walk_con); + con_move_to_workspace(walk_con, focused_ws, true, false); + return; + } + } + + /* If this was 'scratchpad show' with criteria, we check if the window + * is actually in the scratchpad */ + if (con && con->parent->scratchpad_state == SCRATCHPAD_NONE) { + DLOG("Window is not in the scratchpad, doing nothing.\n"); + return; + } + /* If this was 'scratchpad show' with criteria, we check if it matches a * currently visible scratchpad window and hide it. */ Con *active = con_get_workspace(focused); @@ -127,6 +181,10 @@ void scratchpad_show(Con *con) { LOG("Use 'move scratchpad' to move a window to the scratchpad.\n"); return; } + } else { + /* We used a criterion, so we need to do what follows (moving, + * resizing) on the floating parent. */ + con = con_inside_floating(con); } /* 1: Move the window from __i3_scratch to the current workspace. */ @@ -138,11 +196,11 @@ void scratchpad_show(Con *con) { Con *output = con_get_output(con); con->rect.width = output->rect.width * 0.5; con->rect.height = output->rect.height * 0.75; + floating_check_size(con); con->rect.x = output->rect.x + ((output->rect.width / 2.0) - (con->rect.width / 2.0)); con->rect.y = output->rect.y + ((output->rect.height / 2.0) - (con->rect.height / 2.0)); - con->scratchpad_state = SCRATCHPAD_CHANGED; } /* Activate active workspace if window is from another workspace to ensure @@ -212,8 +270,24 @@ void scratchpad_fix_resolution(void) { new_height = _lcm(new_height, output->rect.height); } } + + Rect old_rect = __i3_output->rect; + DLOG("new width = %d, new height = %d\n", new_width, new_height); __i3_output->rect.width = new_width; __i3_output->rect.height = new_height; + + Rect new_rect = __i3_output->rect; + + if (memcmp(&old_rect, &new_rect, sizeof(Rect)) == 0) { + DLOG("Scratchpad size unchanged.\n"); + return; + } + + DLOG("Fixing coordinates of scratchpad windows\n"); + Con *con; + TAILQ_FOREACH(con, &(__i3_scratch->floating_head), floating_windows) { + floating_fix_coordinates(con, &old_rect, &new_rect); + } }