aboutsummaryrefslogtreecommitdiff
path: root/completions/zsh/_riverctl
blob: d2cf8eef90dbcd1e7e39460cd89b337c08447698 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
#compdef riverctl
#
# Completion script for riverctl, part of river <https://github.com/riverwm/river>

# This is the list of all riverctl first argument, i.e `riverctl <first_arg>`.
# If a command doesn't need completion for subcommands then you just need
# to add a line to this list.
# Format is '<command-name>:<description>'
_riverctl_commands()
{
    local -a riverctl_commands

    riverctl_commands=(
        # Actions
        'close:Close the focused view'
        'exit:Exit the compositor, terminating the Wayland session'
        'focus-output:Focus the next or previous output'
        'focus-view:Focus the next or previous view in the stack'
        'move:Move the focused view in the specified direction'
        'resize:Resize the focused view along the given axis'
        'snap:Snap the focused view to the specified screen edge'
        'send-to-output:Send the focused view to the next or the previous output'
        'spawn:Run shell_command using /bin/sh -c'
        'swap:Swap the focused view with the next/previous visible non-floating view'
        'toggle-float:Toggle the floating state of the focused view'
        'toggle-fullscreen:Toggle the fullscreen state of the focused view'
        'zoom:Bump the focused view to the top of the layout stack'
        'default-layout:Set the layout namespace to be used by all outputs by default.'
        'output-layout:Set the layout namespace of currently focused output.'
        'send-layout-cmd:Send command to the layout generator on the currently focused output with matching namespace'
        # Tag management
        'set-focused-tags:Show views with tags corresponding to the set bits of tags'
        'set-view-tags:Assign the currently focused view the tags corresponding to the set bits of tags'
        'toggle-focused-tags:Toggle visibility of views with tags corresponding to the set bits of tags'
        'toggle-view-tags:Toggle the tags of the currently focused view'
        'spawn-tagmask:Set a tagmask to filter the tags assigned to newly spawned views on the focused output'
        'focus-previous-tags:Sets tags to their previous value on the focused output'
        'send-to-previous-tags:Assign the currently focused view the previous tags of the focused output'
        # Mappings
        'declare-mode:Create a new mode'
        'enter-mode:Switch to given mode if it exists'
        'map:Run command when key is pressed while modifiers are held down and in the specified mode'
        'map-pointer:Move or resize views or run command when button and modifiers are held down while in the specified mode'
        'map-switch:Run command when river receives a switch event in the specified mode'
        'unmap:Remove the mapping defined by the arguments'
        'unmap-pointer:Remove the pointer mapping defined by the arguments'
        'unmap-switch:Remove the switch mapping defined by the arguments'
        # Rules
        'rule-add:Apply an action to matching views'
        'rule-del:Delete a rule added with rule-add'
        'list-rules:Print rules in a given list'
        # Configuration
        'attach-mode:Configure where new views should attach to the view stack'
        'background-color:Set the background color'
        'border-color-focused:Set the border color of focused views'
        'border-color-unfocused:Set the border color of unfocused views'
        'border-color-urgent:Set the border color of urgent views'
        'border-width:Set the border width to pixels'
        'focus-follows-cursor:Configure the focus behavior when moving cursor'
        'hide-cursor:Hide cursor when typing or after inactivity'
        'set-repeat:Set the keyboard repeat rate and repeat delay'
        'set-cursor-warp:Set the cursor warp mode.'
        'xcursor-theme:Set the xcursor theme'
        # Keyboard groups
        'keyboard-group-create:Create a keyboard group'
        'keyboard-group-destroy:Destroy a keyboard group'
        'keyboard-group-add:Add a keyboard to a keyboard group'
        'keyboard-group-remove:Remove a keyboard from a keyboard group'
        'keyboard-layout:Set the keyboard layout'
        # Input
        'input:Configure input devices'
        'list-inputs:List all input devices'
        'list-input-configs:List all input configurations'
    )

    _describe -t command 'command' riverctl_commands
}

# This is the function called for the completion. Commands added in the
# riverctl_commands above are generated in the `commands` case, there is
# nothing more to do for this. If a command has a subcommand then a new case
# need to be added in `args`.
# If this is a simple subcommand with simple multi choice, the easier way to
# do it is:
#   <command-name>) _alternative 'arguments:args:(<choice1 choice2)' ;;
# If the subcommand also has subcommands then, good luck...
# This is really complex, the easiest example to look at is the `hide-cursor` one.
_riverctl()
{
    local state line

    _arguments -C \
        '1: :->commands' \
        '*:: :->args'

    case "$state" in
        commands) _alternative 'common-commands:common:_riverctl_commands' ;;
        args)
            case "$line[1]" in
                focus-output) _alternative 'arguments:args:(next previous)' ;;
                focus-view) _alternative 'arguments:args:(next previous up down left right)' ;;
                input)
                    _arguments '1: :->name' '2: :->commands' ':: :->args'

                    case "$state" in
                        name)  _alternative "arguments:args:($(riverctl list-inputs | grep -e '^[^[:space:]]'))" ;;
                        commands)
                            local -a input_subcommands
                            input_subcommands=(
                                'events:Configure whether the input devices events will be used by river'
                                'accel-profile:Set the pointer acceleration profile'
                                'pointer-accel:Set the pointer acceleration factor'
                                'click-method:Set the click method'
                                'drag:Enable or disable the tap-and-drag functionality'
                                'drag-lock:Enable or disable the drag lock functionality'
                                'disable-while-typing:Enable or disable the disable-while-typing functionality'
                                'middle-emulation:Enable or disable the middle click emulation functionality'
                                'natural-scroll:Enable or disable the natural scroll functionality'
                                'left-handed:Enable or disable the left handed mode'
                                'tap:Enable or disable the tap functionality'
                                'tap-button-map:Configure the button mapping for tapping'
                                'scroll-method:Set the scroll method'
                                'scroll-button:Set the scroll button'
                            )

                        _describe -t command 'command' input_subcommands
                        ;;
                        args)
                            case "$line[2]" in
                                events) _alternative 'input-cmds:args:(enabled disabled disabled-on-external-mouse)' ;;
                                accel-profile) _alternative 'input-cmds:args:(none flat adaptive)' ;;
                                click-method) _alternative 'input-cmds:args:(none button-area clickfinger)' ;;
                                drag) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                drag-lock) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                disable-while-typing) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                middle-emulation) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                natural-scroll) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                left-handed) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                tap) _alternative 'input-cmds:args:(enabled disabled)' ;;
                                tap-button-map) _alternative 'input-cmds:args:(left-right-middle left-middle-right)' ;;
                                scroll-method) _alternative 'input-cmds:args:(none two-finger edge button)' ;;
                                *) return 0 ;;
                            esac
                        ;;
                    esac
                ;;
                move) _alternative 'arguments:args:(up down left right)' ;;
                resize) _alternative 'arguments:args:(horizontal vertical)' ;;
                snap) _alternative 'arguments:args:(up down left right)' ;;
                send-to-output) _alternative 'arguments:args:(next previous)' ;;
                swap) _alternative 'arguments:args:(next previous up down left right)' ;;
                map) _alternative 'arguments:optional:(-release -repeat -layout)' ;;
                unmap) _alternative 'arguments:optional:(-release)' ;;
                attach-mode) _alternative 'arguments:args:(top bottom)' ;;
                focus-follows-cursor) _alternative 'arguments:args:(disabled normal always)' ;;
                set-cursor-warp) _alternative 'arguments:args:(disabled on-output-change on-focus-change)' ;;
                hide-cursor)
                    _arguments '1: :->commands' ':: :->args'

                    case "$state" in
                        commands)
                            local -a hide_cursor_subcommands
                            hide_cursor_subcommands=(
                                "timeout:Hide cursor if it wasn\'t moved in the last X millisecond, until it is moved again"
                                'when-typing:Enable or disable whether the cursor should be hidden when pressing any non-modifier key'
                            )

                            _describe -t command 'command' hide_cursor_subcommands
                            ;;
                        args)
                            case "$line[1]" in
                                when-typing) _alternative 'hide-cursor-cmds:args:(enabled disabled)' ;;
                                *) return 0 ;;
                            esac
                        ;;
                    esac
                ;;
                rule-add | rule-del)
                    # This is not perfect as it only complete if there is
                    # either '-app-id' or '-title'.
                    # The empty action(2) mean that we need an argument
                    # but we don't generate anything for it.
                    # In case of a new rule added in river, we just need
                    # to add it to the third option between '()',
                    # i.e (float no-float <new-option>)
                    _arguments '1: :(-app-id -title)' '2: : ' ':: :(float no-float ssd csd tag output)'
                ;;
                list-rules) _alternative 'arguments:args:(float ssd tag output)' ;;
                *) return 0 ;;
            esac
        ;;
    esac
}

_riverctl "$@"