toggle-column-stack stacks the windows of the focused column in one
window slot, or spreads the focused stack out into a column with a
window in each slot, whichever the focused column is. A stack is what
a tabbed column already is, so this is the same thing seen from the
other side: existing stacks stay stacks, consume and expel make split
columns, and this switches either kind.
Stacking keeps the order of the windows and the one that had focus is
the one that shows. Spreading out puts the tabs in the order of the
tabs, with focus on the window that had it, and puts every window that
was out of sight where it is shown, the one that stays in its slot as
much as the ones that go to slots of their own. Focus stays on the
column while that is done, so that stacking and spreading out again
leaves the strip where it was. The column keeps its width. Heights that
its slots were given are not remembered for toggling back, which needs
more memory than a column keeps.
The stack is the stack of every layout, so cycle-stack, focus-stack-
window and stack work on it, and unstack takes the window that has
focus off into a column of its own to the right, which a test checks.
Like consume and expel it only does anything in the Scrolling layout.
The parking and restoring of windows is the code that stacks already
use, and was not seen on a screen. A test has no screen, so what would
be restored is recorded, and two tests check that every window of a
spread out stack is and that the strip stays put.
A container goes from one workspace to another by being taken out of
one and put into the other, with nothing between them that both could
be asked, so a window that was moved started again with the default
width, as did one moved to another monitor.
Taking a container out of a workspace now says what its column was
given, which komorebi_layouts::scrolling keeps, and the strip of the
workspace that has the container next finds it there the first time it
sees it, before it is made to match the list. So the window is a column
of its own as wide as the column it left, whichever way it got there,
and a window that moves on takes what it has where it is. Nothing is
remembered for a container that no strip had been asked about.
The heights that the model can give the tiles of a column are now
reachable. Resizing a vertical edge makes the focused window taller or
shorter by half of the resize delta, as a horizontal edge does for a
column, and the others in its column share what it leaves. No window is
made shorter than 100 pixels, and retile puts heights back as well as
widths.
A window that is alone in its column fills it, so all of this does
nothing for it, and the other layouts are not affected.
The strip's tiles are the workspace's containers, in the order of the
list, so a column is a run of the list and every container still gets
one rectangle: the layout pass, latest_layout, drag and the borders are
as they were. Everything that changes the order of the containers does
it on the list, and the strip is made to match on the next pass.
- consume left|right and expel make and unmake columns of several
windows, and only do anything in the Scrolling layout for now
- focus left and right go to the neighbouring column and to the window
in it that had focus last, and up and down go between the windows of
the column and carry on to another monitor at the ends, as before
- move left and right move the whole column, and up and down swap the
window with the one above or below it, past which the list changes
- a new window goes after the last window of the focused column and
not after the focused window, so that it is a column of its own and
does not split the one it was opened next to
- the strip is no longer thrown away when the layout is not Scrolling,
so that widths come back when it is again
Heights are equal and there is no command to change them yet. A window
that is moved to another workspace or monitor starts again with the
default width.
Many apps will not make a window narrower than some width. The layout
placed the next column as if the window had the width it was given, and
so placed it on top of the window that had not.
What the arrival module has been told, the layout picks up at the start
of the next pass: a column is never narrower than the window in it
needs, plus the padding and border around it and capped at the width of
the screen, and the columns after it are placed where it ends. A limit
only ever goes up, so that a column does not bounce between two widths,
and a stack takes the widest of its windows.
With animations off the layout asks every window that it resized what
it is, with a timeout, and places everything once more if one refused.
With animations on the animator says so when a journey ends, so a
window that refuses is noticed then as well.
The model could take the full width, fill the room that the columns in
view leave, and centre a column, but nothing called it. These commands
do, the first in the scrolling-layout family that
scrolling-layout-columns started, and the others named plainly,
center-focus to match promote-focus:
- scrolling-layout-full-width
- expand
- center-focus
Each is about the container that has focus now, even if focus moved
since the last layout, and does nothing until there is a strip, or in
another layout. A column made the full width of the screen takes the
gaps into account, so that it fills the screen exactly. expand makes the
focused column as wide as it can be without moving another column out of
view, which is the full width of the screen when it is the only one in
view or when the focused column is always centred, and does nothing when
there is no room.
Nothing changes in the shared layouts crate, so Windows is not affected.
retile already forgot the resize adjustments of the layouts that are
made of splits, and the widths of the columns of the Scrolling layout
are the same kind of thing. The focused workspace of each monitor
gets its columns back to what scrolling-layout-columns gives, and the
focused column stays where it is unless it has to scroll.
The variant of retile that keeps resize dimensions keeps the widths.
Add a page on the Scrolling layout: how column widths work, when the
screen scrolls, what closing a window focuses, how resizing works, where
windows that are out of view go and why, and what is not done yet.
Describe the duration, style and fps options, per-animation settings, and what
to expect from the animator: windows stay in step with each other, apps that are
slow to resize are sent sizes less often, and a window that is grabbed is let
go of.