Add a new "completions" command which takes a supported shell as an
argument. This command outputs a completions file to stdout, which can
be redirected to a file.
This commit migrates the komorebi-bar from komorebi for Windows. Mostly
lifting and shifting code, exposing stuff we need in komorebi-client
etc.
A few widgets will need to be reworked completely so they have been
removed for now.
Mouse and command stuff also needs updating a little so that has also
been removed for now.
This commit implements the komorebic quickstart command, adds a sample
komorebi.json and a sample skhdrc file which get built into the
komorebic binary, and updates the default config path on macOS to
$HOME/.config/komorebi
This commit adds a docgen command to generate markdown documentation
files of all of the CLI commands, and a justfile target to generate
JSONSchema files.
I think this is the last SocketMessage variant I'll be bringing over
before working on docs. Haven't tested this one but it should work
pretty much the same as on Windows.
This commit implements the komorebic display-index-preference command
for updating display index preferences, however the monitor
reconciliator module has not been reimplemented completely yet so these
values will not have any effect.
In implementing these two I'm diverging from how komorebi for Windows
handles these a little by tracking the window IDs of manually unmanaged
applications in a global vec UNMANAGED_WINDOW_IDS.
This is due to other changes in how Show and Destroy are handled in
komorebi for macOS which means we can't just piggy-back on those
handlers like we used to.
This commit implements the Stop and StopIgnoreRestore SocketMessage
variants and sends them from the komorebic stop command. The ctrl-c
handler in main.rs now exits with code 130, while the Stop handlers will
exit cleanly with code 0.
This commit adds in the ability for users to subscribe to notifications
via a Unix domain socket. Code was mostly just migrated from komorebi.
Tested with "nc -vklU $(komorebic datadir)/test.sock" to create the
socket and listen and then "komorebic subscribe-socket test.sock" to
subscribe for notifications.
Starting to think about documentation and adding in commands to generate
JSON schemas for the ApplicationSpecificConfiguration, SocketSchema and
StaticConfig.
schemars 0.8 > 0.9 has way too many breaking changes for me to care
about right now, let around 0.8 > 1.0. I'm happy being pinned on 0.8 for
now.
I think this is all of the config commands migrated to komorebic now.
I still need to look in to the ManageFocusedWindow and
UnmanageFocusedWindow SocketMessage variants, as well as everything to
do with monitor reconciliation, but next I think I'll focus on trying to
generate the schemas.
This commit migrates a whole bunch of interactive runtime configuration
komorebic commands and implements their corresponding SocketMessage
variants.
Largely lifted as-is from komorebi for Windows.
This commit implements a whole bunch of commands around runtime
manipulation of ignore rules, manage rules and workspace rules. Mostly
lifted straight from komorebi.
To give me a better idea of how the quest for komorebic command parity
is going, I have copied over the entire SubCommand enum from the Windows
repo and commented out anything not yet implemented.
This commit migrates a bunch of code from komorebi that deals with how
new windows should be handled according to the various floating and
container behaviour overrides.
To help test this functionality I also finished migrating the
SessionFloatRule, SessionFloatRules and ClearSessionFloatRules
SocketMessage variants.
This commit adds logs written to files in the app's datadir, which can
then be tailed by the komorebic log command. temp_dir() was being weird
so I just stuck with DATA_DIR.
This commit does some wrangling of the ioreg output to enrich monitors
with product names and serial number IDs, the latter of which is very
important to maintain compatibility with komorebi for Windows.
I can't get the equivalent of device and device_id on macOS, but these
are legacy things in komorebi for Windows so I think I'll leave them
out.
To verify monitor information, SocketMessage::MonitorInformation has
been implemented.
This commit implements the State, GlobalState and VisibleWindows
SocketMessage variants. These are the first of the SocketMessage
variants send by komorebic which receive a reply which is printed out to
the console.
I think the next thing to do will probably be to get the extended
display info so that the MonitorInformation variant can be handled too.
This commit implements the CycleFocusWindow, CycleMoveWindow, StackAll,
UnstackAll, FocusStackWindow and CycleStackIndex SocketMessage variants.
Largely a code migration from komorebi.
This commit implements the MoveContainerToLastWorkspace,
SendContainerToLastWorkspace, MoveContainerToMonitorNumber,
CycleMoveContainerToMonitor, MoveContainerToWorkspaceNumber,
MoveContainerToNamedWorkspace, CycleMoveContainerToWorkspace,
SendContainerToMonitorNumber, CycleSendContainerToMonitor,
SendContainerToWorkspaceNumber, CycleSendContainerToWorkspace,
SendContainerToMonitorWorkspaceNumber,
MoveContainerToMonitorWorkspaceNumber, SendContainerToNamedWorkspace,
CycleMoveWorkspaceToMonitor, MoveWorkspaceToMonitorNumber, and
SwapWorkspacesToMonitorNumber SocketMessage variants.
This is primarily a lift-and-shift from komorebi.
I still have no idea if the monitor-related stuff works as expected.
I need to figure out how to construct a light Window from a window_id to
be able to call move_to_area() when moving a container to another
monitor.
This commit implements the CycleFocusMonitor, CycleFocusWorkspace,
CycleFocusEmptyWorkspace, FocusMonitorNumber, FocusMonitorAtCursor,
FocusLastWorkspace, CloseWorkspace, FocusWorkspaceNumbers,
FocusMonitorWorkspaceNumber and FocusNamedWorkspace SocketMessage
variants.
Largely a lift-and-shift from komorebi.
Had to implement some utility functions in MacosApi to retrieve a
monitor ID from the current cursor position.
None of the monitor-related system code has been tested on macOS since I
only have a single monitor to work with right now.
This commit implements the ToggleWorkspaceWindowContainerBehaviour,
ToggleWorkspaceFloatOverride, ToggleLock, ToggleFloat, ToggleMonocle,
ToggleWindowContainerBehaviour, ToggleFloatOverride,
ToggleCrossMonitorMoveBehaviour, ToggleTiling and
ToggleWindowBasedWorkAreaOffset SocketMessage variants.
Again mostly a lift-and-shift from komorebi.
ToggleMaximizeWindow can be implemented later once I figure out how
maximized windows are handled in macOS.
Another lift and shift from komorebi to add support for the CycleLayout
and FlipLayout SocketMessage variants. Trying to get through all of the
main workspace-related interactive commands.
This commit migrates the code from komorebi required to implement the
ResizeWindowEdge, ResizeWindowAxis, Retile and
RetileWithResizeDimensions SocketMessage variants, as well as the
related komorebic commands to emit those SocketMessages.
This commit implements some of the basic plumbing needed to handle
SocketMessage::ToggleWorkspaceLayer and SocketMessage::ToggleFloat.
I've commented out a bunch of the raise/lower functions for now because
I haven't had time to learn about how changing z-ordering on macOS works
yet.
Even so, this is fairly functional, and it's possible to move floating
windows across workspaces, toggle the workspace layer, move floating
windows by the resize delta, and change focus between floating windows.
I ended up moving the window restore positions to a global map because
storing/updating this kind of state on the Window properly will be a
pain because hide/restore now require mut self refs and that leads to
needing to clone sometimes.
This commit migrates the code around Monocle containers from komorebi
and implements everything needed to handle SocketMessage::ToggleMonocle
in the wm and send the SocketMessage from komorebic.
I think I should spend time implementing as many Workspace features as I
can before I turn my attention to anything else, because hunting for
where to re-introduce the monocle code I had previously omitted to get
everything compiling was quite tedious and I'm sure I've probably missed
things.
This commit migrates the code needed from komorebi to implement basic
workspace support.
The FocusWorkspaceNumber, MoveContainerToWorkspaceNumber and
SendContainerToWorkspaceNumber SocketMessage variants have been
implemented in process_command, and the commands to emit those
SocketMessage variants have been added to komorebic.
I took a stab at improving the code for hiding the windows by moving
them as off-screen as possible by taking inspiration of Aerospace's
approach of trying to leave only 1px of them visible.
Right now this always looks to put the hidden windows off-screen on the
left side of the screen.
This commit adds support for the StackWindow, UnstackWindow and
CycleStack SocketCommands. The code is largely just migrated from
komorebi.
It looks like there isn't a public API which can be used to hide
individual windows, either via AXUIElement or something constructed
using the window id.
For now I'm just moving the stacked window off the screen and this works
well enough. I also added some cleanup which ensures that when the
process exits, windows which are off-screen will be restored to their
last known position.
This commit migrates another bunch of code from komorebi to start
implementing inter-process communication using Unix domain sockets.
For this commit a small subsection of the SocketMessage with maximum
utility has been migrated: FocusWindow, MoveWindow, ChangeLayout, and
TogglePause.
This includes migrating their handlers in process_command, and setting
up a UnixListener when creating a WindowManager instance.
To be able to test this functionality I also implemented a basic
skeleton of komorebic and migrated the komorebi-client library.
There are some random fixes included here now that we are listening to a
UnixListener on a separate thread, which includes wrapping structs from
the objc2 crate which don't have Send and Sync implemented, so that they
can be implemented in the komorebi lib.
I also took the time to figure out how to calculate a monitor's work
area size, excluding the dock and the menu bar, and started to split out
Workspace and Monitor into their own modules.
It looks like a lot of changes but most if this is just pulling in stuff
from the Windows implementation.