Unmapping a tiled view leads to the tile being in detached state. Detached tiles
are tiles that do not belong to a layout. In general we want to avoid such tiles
to exist for a longer period of time (e.g. during resetting). Also unmapping all
the views from a layout will lead to the destruction of the layout.
In general, having detached tiles presented to the user will lead to surprising
effects, like being able to reset the geometry on a view that has no apparent
overriding geometry. This should be avoided.
Currently the best approach to deal with this is to just completely destroy the
tile. This also leads to overwriting the original geometry of the view leading
to some sort of "memory loss" for views that behave like that. This makes them a
bad candidate for tiling anyway.
Relative output positioning does not take the usable area x and y coordinates
into account. This leads to views positioned with an offset of that area when
using relative positioning.
Public views are used to populate the lock screen to display additional
information, they should never display sensitive information.
Even hidden are displayed. This uses a `force` flag that overrides visibility
that is set in mode enter and reset on mode exit.
Introducing `lock` mode. This turns the screen locker into a mode which
adds some more modularity to the code.
Visible views on sheet 0 are also displayed on the lock screen allowing
for a customizable setup without the needs for extra plugins.
An indicator adds feedback for typing and verification.
Since `map` and `unmap` are now handled by views these functions now also need
to handle group assignment. An unmmapped view needs to be removed from its group
which might result in the group's deallocation. In case it's getting mapped
again we need to reload the view configuration to re-allocate the group.
This is done by factoring out the view configuration routine from the
configuration module and centralize view configuration in the view module via
`hikari_view_configure`. Configuration values are applied in this function
rather than in the resolve function for the `view_autoconf`. This also allows
for group allocation and deallocation in the `map` and `unmap` functions for
views.
It currently can happen that an unmapped view can be shown on the workspace. If
the user switches to a sheet with an unmapped view, all linked sheet views get
shown, problematically this also applies to unmmaped views. There is no
distinction between `managed` an `mapped` state here so if a view gets unmapped
but not destroyed right away, it still happens to be managed by the sheet.
This patch separates the notion of `managed` and `mapped`. `unmapped` views get
removed from all the relevant lists to prevent the situation we are describing
in the previous paragraph.
`map` and `unmap` should be separate operations.
Currently split configurations are referenced using a pointer to that split.
Those get invalidated when a configuration gets reloaded though. This patch
creates a deep copy of the split configuration on layout creation.
Migrating a view has to happen instantly. Once a view leaves an output it needs
to be remove from all lists regarding that output and inserted into all of the
lists on the output we are migrating to. This operation should not be buffered
because otherwise the view can be somewhere in limbo between some outputs in a
state where one should not issue an operation on it. Anyway, if we are moving
the view via mouse it will never lose focus and therefore we could potentially
issue any operation violating invariants like that the focus view should never
be hidden.
By making the transition instant these "limbo states" cannot be achieved.
During move mode we should not draw the indicator when the view is hidden for a
short amount of time during the transition to another output. Otherwise this
leads to the indicator being drawn on the wrong spot at the other monitor.
Configuration and autostart script are checked for permissions during startup.
Also the order in which the configuration is loaded.
* explicit configuration overrides all others and stops if it can not be used
* otherwise fallback to `XDG_CONFIG_HOME`
* otherwise use default configuration
Options should also be parsed and handled before the backend starts up.
We can reduce the amount of code running with privileges to the few calls that
are needed to initialize the `wlroots` backend. These calls are now part of
`hikari_server_prepare_privileged`. After this everything is running with the
users privileges again.
This adds a default wallpaper to `hikari` and uses default output configuration
to make use of it. The path to the wallpaper is spliced into the default
configuration view `sed` during installation.
This patch enables to change the default configuration value for outputs and
pointer by defining a configuration for "*". Values defined in this object
override unconfigured values.
This patch tries to focus the last `focus_view` during cycling. If that view is
no longer visible the first sheet view gets focused. This patch also makes
`hikari` focus the `focus_view` of a workspace when entering it with the cursor.
`focus_view` is no longer set to `NULL` when leaving a workspace.
How a view is hidden during migration depends on the way we migrate it. When
doing it during mouse movement we do not want to lose focus that's why we only
re-organize the stack. This is why we only need the call the `hikari_view_hide`
in `pin_migrate`.
Focusing the first sheet view excludes borrowed views. The idea is that views on
sheet 0 should not become a fallback when the workspace is otherwise empty.
Views on that sheet are supposed to take a background role.
This patch reworks how views are ordered. A new ordering is introduced for all
views present on all visible workspaces. This makes cycling views with multiple
workspaces less confusing because the ordering is server-wide and not just
workspace-wide. Also showing views now calls the `raise_view` function to bring
the view to the front of all relevant lists and not just the workspace.
raichoo
timothee.floure