summary refs log tree commit diff
path: root/Completion/Unix/Command/_tmux
blob: 93b5c7faa7e0ce4aea8f782402286d8091d9888f (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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
#compdef tmux

# tmux <http://tmux.github.io> completion for zsh <http://zsh.sf.net>.
#
# Configuration:
#
# - On some OSs, the directory for tmux's server sockets may not be
#   the default (which is /tmp/tmux-<uid>/), but say
#   /var/run/tmux/tmux-<uid>, in which case the completion for
#   'tmux -L <tab>' will not be able to find the sockets in the default
#   location (debian does this, for instance); tell _tmux the right place
#   to look:
#       % zstyle ':completion:*:*:tmux:*:sockets' socketdir "/var/run/tmux/tmux-${UID}"
#
# - tmux knows a *lot* of sub-commands, hence 'tmux <tab>' returns a lot
#   of possible completions. _tmux knows about all commands and their aliases.
#   By default, both are offered. If you do not care about the aliases, do this:
#       % zstyle ':completion:*:*:tmux:*:subcommands' mode 'commands'
#
#   The same can be done to only return aliases by setting the above style
#   to 'aliases'. The default value is 'both' (but actually every value
#   different from 'commands' and 'aliases' will have the same effect).
#
#   'lsw' is an alias for 'list-windows' for example; note that not all
#   commands have aliases. So probably, either the default 'both' or
#   'commands' makes most sense for this style.
#
# - For finer grained control over what is suggested as possible completions,
#   the 'ignored-patterns' style may be used; suppose you think that only
#   '*-window' or '*-windows' are worth being completed. You would get that
#   behaviour like this:
#       % zstyle ':completion:*:*:tmux:*:subcommands' ignored-patterns '^*-window(|s)'
#
#   Some tmux commands currently do not work if called from a shell prompt,
#   so it would make sense to ignore them per default (at the time of writing,
#   those commands are choose-{session,client,window}, confirm-before and
#   find-window. This would ignore them:
#       % zstyle ':completion:*:*:tmux:*:subcommands' ignored-patterns \
#                'choose-*' 'confirm-before' 'find-window'
#
# The configuration for subcommand completions may be done in
# this context: ':completion:*:*:tmux-<sub-command>:*:*'
#
# TODO:
#
#   - Implement __tmux-format
#   - Implement __tmux-style (possibly using existing helpers like
#     __tmux-attributes and __tmux-colours)
#   - in _tmux-list-panes, use __tmux-windows or __tmux-sessions
#     depending on -s is among the sub-commands current command line.

# Global variables; setup the first time _tmux is called.
# For $_tmux_commands[] generation, see the very end of this file.
typeset -ga _tmux_commands _tmux_aliases
typeset -gA _tmux_aliasmap

_tmux_aliasmap=(
    # clients and sessions
    attach      attach-session
    detach      detach-client
    has         has-session
    lockc       lock-client
    locks       lock-session
    lsc         list-clients
    lscm        list-commands
    ls          list-sessions
    new         new-session
    refresh     refresh-client
    rename      rename-session
    showmsgs    show-messages
    source      source-file
    start       start-server
    suspendc    suspend-client
    switchc     switch-client

    # windows and panes
    breakp      break-pane
    capturep    capture-pane
    displayp    display-panes
    findw       find-window
    joinp       join-pane
    killp       kill-pane
    killw       kill-window
    last        last-window
    lastp       last-pane
    linkw       link-window
    lsp         list-panes
    lsw         list-windows
    movep       move-pane
    movew       move-window
    neww        new-window
    nextl       next-layout
    next        next-window
    pipep       pipe-pane
    prev        previous-window
    prevl       previous-layout
    renamew     rename-window
    resizep     resize-pane
    respawnp    respawn-pane
    respawnw    respawn-window
    rotatew     rotate-window
    selectl     select-layout
    selectp     select-pane
    selectw     select-window
    splitw      split-window
    swapp       swap-pane
    swapw       swap-window
    unlinkw     unlink-window

    # key bindings
    bind        bind-key
    lsk         list-keys
    send        send-keys
    unbind      unbind-key

    # options
    set         set-option
    setw        set-window-option
    show        show-options
    showw       show-window-options

    # environment
    setenv      set-environment
    showenv     show-environment

    # status line
    confirm     confirm-before
    display     display-message

    # buffers
    clearhist   clear-history
    deleteb     delete-buffer
    lsb         list-buffers
    loadb       load-buffer
    pasteb      paste-buffer
    saveb       save-buffer
    setb        set-buffer
    showb       show-buffer

    # miscellaneous
    if          if-shell
    lock        lock-server
    run         run-shell
    info        server-info
    wait        wait-for
)

# --- Sub-command functions ---
# These *must* be called _tmux-*(); The description generation relies on
# them being names that way. *No* other functions may match that pattern.
# Other utility functions should be named __tmux-*() (see below).
#
# Another thing, the description generation needs, is handling of
# $tmux_describe: If that parameter is non-empty, the sub-command function
# should only print a description of the sub-command it handles and return
# immidiately after doing so.
#
# To add support for a new sub-command, you only have to add a new
# _tmux-<foo>() function below (preferably alphabetically sorted), that
# behaves like described above; and add a alias->command pair in the
# _tmux_aliasmap associative array above (if the comand in fact has an
# alias). The rest should just work[tm].

function _tmux-attach-session() {
    [[ -n ${tmux_describe} ]] && print "Attach or switch to a session" && return
    local -a args

    args=(
        '-c[specify working directory for the session]:directory:_path_files -g "*(-/)"'
        '-d[detach other clients attached to target session]'
        '-r[put the client into read-only mode]'
        '-t[choose a target session]:target session:__tmux-sessions'
    )
    _arguments : ${args}
}

function _tmux-bind-key() {
    [[ -n ${tmux_describe} ]] && print "Bind a key to a command" && return
    local curcontext="${curcontext}" state
    local -a args

    args=(
        '-c[bind to command mode instead of normal mode]'
        '-n[make the binding work without the need for the prefix key]'
        '-r[the key may repeat]'
        '-t[choose a key table for the binding]:key tables:__tmux-key-tables'
        '1: :->key'
        '*:: :->command_and_args'
    )
    _arguments -C : ${args} && return

    if [[ ${state} == 'key' ]]; then
        _message "key"
    else
        # quite cool, that this works. :-)
        _tmux
    fi
}

function _tmux-break-pane() {
    [[ -n ${tmux_describe} ]] && print "Break a pane from an existing into a new window" && return
    local -a args
    args=(
        '-d[do not make the new window become the active one]'
        '-F[specify format of output]:format:__tmux-format__tmux-format'
        '-P[print information of new window after it has been created]'
        '-t[choose a target pane]:panes:__tmux-panes'
    )
    _arguments : ${args}
}

function _tmux-capture-pane() {
    [[ -n ${tmux_describe} ]] && print "Capture the contents of a pane to a buffer" && return
    local -a args
    args=(
        '-a[use alternate screen]'
        '-b[choose target buffer]:target buffer:__tmux-buffers'
        '-C[escape non-printable characters as octal \\ooo]'
        '-e[include escape sequences for attributes etc]'
        '-E[specify last line to capture. - means last line of pane]'
        '-J[join wrapped lines and preserver trailing space]'
        '-q[ignore errors when trying to access alternate screen]'
        '-p[print data to stdout]'
        '-P[only capture that is the beginning of an as-yet incomplete esc seq]'
        '-S[specify start line to capture. - means first line of scrollback]'
        '-t[choose source pane]:source pane:__tmux-panes'
    )
    _arguments : ${args}
}

function _tmux-choose-buffer() {
    [[ -n ${tmux_describe} ]] && print "Put a window into buffer choice mode" && return
    local -a args
    args=(
        '-F[specify format of output]:format:__tmux-format'
        '-t[choose a target window]:sessions:__tmux-windows'
        '*:: :->tmpl'
    )
    _arguments : ${args} && return
}

function _tmux-choose-client() {
    [[ -n ${tmux_describe} ]] && print "Put a window into client choice mode" && return
    local -a args
    args=(
        '-F[specify format of output]:format:__tmux-format'
        '-t[choose a target window]:sessions:__tmux-windows'
        '*:: :->tmpl'
    )
    _arguments : ${args} && return
}

function _tmux-choose-session() {
    [[ -n ${tmux_describe} ]] && print "Put a window into session choice mode" && return
    local -a args
    args=(
        '-F[specify format of output]:format:__tmux-format'
        '-t[choose a target window]:sessions:__tmux-windows'
        '*:: :->tmpl'
    )
    _arguments : ${args} && return
}

function _tmux-choose-tree() {
    [[ -n ${tmux_describe} ]] && print "Put a window into tree choice mode" && return
    local -a args
    args=(
        '-b[override default session command]:session-command:'
        '-c[override default window command]:window-command:'
        '-S[specify session format]:session-format:__tmux-formats'
        '-s[choose among sessions]'
        '-t[choose a target window]:sessions:__tmux-windows'
        '-u[show generated tree uncollapsed at startup]'
        '-W[specify window format]:window-format:__tmux-formats'
        '-w[choose among windows]'
        '*:: :->tmpl'
    )
    _arguments : ${args} && return
}

function _tmux-choose-window() {
    [[ -n ${tmux_describe} ]] && print "Put a window into window choice mode" && return
    local -a args
    args=(
        '-F[specify format of output]:format:__tmux-format'
        '-t[choose a target window]:sessions:__tmux-windows'
        '*:: :->tmpl'
    )
    _arguments : ${args} && return
}

function _tmux-clear-history() {
    [[ -n ${tmux_describe} ]] && print "Remove and clear history for a pane" && return
    local -a args
    args=('-t[choose a target pane]:panes:__tmux-panes')
    _arguments : ${args}
}

function _tmux-clock-mode() {
    [[ -n ${tmux_describe} ]] && print "Enter clock mode" && return
    local -a args
    args=('-t[choose a target pane]:panes:__tmux-panes')
    _arguments : ${args}
}

function _tmux-command-prompt() {
    [[ -n ${tmux_describe} ]] && print "Open the tmux command prompt in a client" && return
    local state
    local -a args
    args=(
        '-I[comma separated list of initial inputs]:initial-text:->ilist'
        '-p[list of prompts]:prompts:->plist'
        '-t[choose a target client]:clients:__tmux-clients'
        '*:: :->tmpl'
    )
    _arguments -C : ${args} && return
    if [[ ${state} == 'plist' ]]; then
        _message "comma seperated list of prompts"
        return
    elif [[ ${state} == 'ilist' ]]; then
        _message "comma seperated list of initial text"
        return
    fi
    __tmux-lastarg ${state} 'tmpl' 1 "command template"
}

function _tmux-confirm-before() {
    [[ -n ${tmux_describe} ]] && print "Run a command but ask for confirmation before" && return
    local state
    local -a args
    args=(
        '-p[specify prompt]:prompt:->prompt'
        '-t[choose a target client]:clients:__tmux-clients'
        '*:: :->command_and_args'
    )
    _arguments -C : ${args} && return
    if [[ ${state} == 'prompt' ]]; then
        _message 'prompt string'
        return
    fi
    __tmux-lastarg ${state} 'command_and_args' 1 "command string"
}

function _tmux-copy-mode() {
    [[ -n ${tmux_describe} ]] && print "Enter copy mode" && return
    local -a args
    args=(
        '-t[choose a target pane]:panes:__tmux-panes'
        '-u[scroll up one page]'
    )
    _arguments : ${args}
}

function _tmux-delete-buffer() {
    [[ -n ${tmux_describe} ]] && print "Delete a paste buffer" && return
    local -a args
    args=('-b[choose a target buffer index]:buffers:__tmux-buffers')
    _arguments : ${args} && return
}

function _tmux-detach-client() {
    [[ -n ${tmux_describe} ]] && print "Detach a client from the server" && return
    local -a args
    args=(
        '-a[kill all clients except for the named by -t]'
        '-P[send SIGHUP to parent process]'
        '-s[choose a target session and kill its clients]:sessions:__tmux-sessions'
        '-t[choose a target client]:clients:__tmux-clients'
    )
    _arguments : ${args}
}

function _tmux-display-message() {
    [[ -n ${tmux_describe} ]] && print "Display a message in the status line" && return
    local -a args
    args=(
        '-c[choose a target client]:clients:__tmux-clients'
        '-p[print message to stdout]'
        '-t[choose a target client]:clients:__tmux-clients'
        '*:: :->msg'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'msg' 1 "message"
}

function _tmux-display-panes() {
    [[ -n ${tmux_describe} ]] && print "Display an indicator for each visible pane" && return
    local -a args
    args=('-t[choose a target client]:clients:__tmux-clients')
    _arguments : ${args}
}

function _tmux-find-window() {
    [[ -n ${tmux_describe} ]] && print "Search for a pattern in windows" && return
    local curcontext="${curcontext}" state
    local -a args
    args=(
        '-C[match visible contents]'
        '-F[specify format of output]:format:__tmux-format'
        '-N[match window name]'
        '-T[match window title]'
        '-t[choose a target window]:windows:__tmux-windows'
        '*:: :->pattern'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'pattern' 1 "window search pattern"
}

function _tmux-has-session() {
    [[ -n ${tmux_describe} ]] && print "Check and report if a session exists on the server" && return
    local -a args
    args=('-t[choose a target session]:sessions:__tmux-sessions')
    _arguments : ${args}
}

function _tmux-if-shell() {
    [[ -n ${tmux_describe} ]] && print "Execute a tmux command if a shell-command succeeded" && return
    local -a args
    args=(
        '-b[run shell command in background]'
        '-F[do not execute shell command but use it as a string-value]'
        '1:shell command:'
        '2:tmux command:'
    )
    _arguments : ${args}
}

function _tmux-join-pane() {
    [[ -n ${tmux_describe} ]] && print "Split a pane and move an existing one into the new space" && return
    local -a args
    args=(
        '-b[join source pane left of or above target pane]'
        '-d[do not make the new window become the active one]'
        '-h[split horizontally]'
        '-v[split vertically]'
        '-l[define new pane'\''s size]: :_guard "[0-9]#" "numeric value"'
        '-p[define new pane'\''s size in percent]: :_guard "[0-9]#" "numeric value"'
        '-s[choose source pane]:window:__tmux-panes'
        '-t[choose target pane]:window:__tmux-panes'
    )
    _arguments : ${args} && return
}

function _tmux-kill-pane() {
    [[ -n ${tmux_describe} ]] && print "Destroy a given pane" && return
    local -a args
    args=(
        '-a[kill all panes except the one specified by -t]'
        '-t[choose a target pane]:panes:__tmux-panes'
    )
    _arguments : ${args}
}

function _tmux-kill-server() {
    [[ -n ${tmux_describe} ]] && print "Kill clients, sessions and server" && return
    __tmux-nothing-else
}

function _tmux-kill-session() {
    [[ -n ${tmux_describe} ]] && print "Destroy a given session" && return
    local -a args
    args=(
        '-a[kill all session except the one specified by -t]'
        '-t[choose a target session]:sessions:__tmux-sessions'
    )
    _arguments : ${args}
}

function _tmux-kill-window() {
    [[ -n ${tmux_describe} ]] && print "Destroy a given window" && return
    local -a args
    args=(
        '-a[kill all windows except the one specified by -t]'
        '-t[choose a target window]:windows:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-last-pane() {
    [[ -n ${tmux_describe} ]] && print "Select the previously selected pane" && return
    local -a args
    args=(
        '-d[disable input to the pane]'
        '-e[enable input to the pane]'
        '-t[choose a session]:sessions:__tmux-sessions'
    )
    _arguments : ${args} && return
}

function _tmux-last-window() {
    [[ -n ${tmux_describe} ]] && print "Select the previously selected window" && return
    local -a args
    args=('-t[choose a session]:sessions:__tmux-sessions')
    _arguments : ${args} && return
}

function _tmux-link-window() {
    [[ -n ${tmux_describe} ]] && print "Link a window to another" && return
    local -a args
    args=(
        '-d[do not make the new window become the active one]'
        '-k[kill the target window if it exists]'
        '-s[choose source window]:window:__tmux-windows'
        '-t[choose destination window]:window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-list-buffers() {
    [[ -n ${tmux_describe} ]] && print "List paste buffers of a session" && return
    local -a args
    args=('-F[specify format of output]:format:__tmux-format')
    _arguments : ${args} && return
}

function _tmux-list-clients() {
    [[ -n ${tmux_describe} ]] && print "List clients attached to server" && return
    local -a args
    args=(
        '-F[specify format of output]:format:__tmux-format'
        '-t[choose a session]:sessions:__tmux-sessions'
    )
    _arguments : ${args} && return
}

function _tmux-list-commands() {
    [[ -n ${tmux_describe} ]] && print "List supported sub-commands" && return
    __tmux-nothing-else
}

function _tmux-list-keys() {
    [[ -n ${tmux_describe} ]] && print "List all key-bindings" && return
    local -a args
    args=('-t[choose a key table]:key table:__tmux-key-tables')
    _arguments : ${args} && return
}

function _tmux-list-panes() {
    [[ -n ${tmux_describe} ]] && print "List panes of a window" && return
    local -a args
    args=(
        '-a[list all panes the server possesses]'
        '-F[specify format of output]:format:__tmux-format'
        '-s[if specified, -t chooses a session]'
        # TODO: Use __tmux-windows or __tmux-sessions depending on -s.
        '-t[choose a window]:windows:__tmux-windows'
    )
    _arguments : ${args} && return
}

function _tmux-list-sessions() {
    [[ -n ${tmux_describe} ]] && print "List sessions managed by server" && return
    local -a args
    args=('-F[specify format of output]:format:__tmux-format')
    _arguments : ${args} && return
}

function _tmux-list-windows() {
    [[ -n ${tmux_describe} ]] && print "List windows of a session" && return
    local -a args
    args=(
        '-a[list all windows the tmux server possesses]'
        '-F[specify format of output]:format:__tmux-format'
        '-t[choose a session]:sessions:__tmux-sessions'
    )
    _arguments : ${args} && return
}

function _tmux-load-buffer() {
    [[ -n ${tmux_describe} ]] && print "Load a file into a paste buffer" && return
    local -a args

    args=(
        '-b[choose a target buffer index]:panes:__tmux-buffers'
        '1:file name:_files -g "*(-.)"'
    )
    _arguments : ${args} && return
}

function _tmux-lock-client() {
    [[ -n ${tmux_describe} ]] && print "Lock a client" && return
    local -a args
    args=('-t[choose a client]:clients:__tmux-clients')
    _arguments : ${args} && return
}

function _tmux-lock-server() {
    [[ -n ${tmux_describe} ]] && print "Lock all clients attached to the server" && return
    __tmux-nothing-else
}

function _tmux-lock-session() {
    [[ -n ${tmux_describe} ]] && print "Lock all clients attached to a session" && return
    local -a args
    args=('-t[choose a session]:sessions:__tmux-sessions')
    _arguments : ${args} && return
}

function _tmux-move-pane() {
    [[ -n ${tmux_describe} ]] && print "Move a pane into a new space" && return
    local -a args
    args=(
        '-b[join source pane left of or above target pane]'
        '-d[do not make the new window become the active one]'
        '-h[split horizontally]'
        '-v[split vertically]'
        '-l[define new pane'\''s size]: :_guard "[0-9]#" "numeric value"'
        '-p[define new pane'\''s size in percent]: :_guard "[0-9]#" "numeric value"'
        '-s[choose source pane]:window:__tmux-panes'
        '-t[choose target pane]:window:__tmux-panes'
    )
    _arguments : ${args} && return
}

function _tmux-move-window() {
    [[ -n ${tmux_describe} ]] && print "Move a window to another" && return
    local -a args
    args=(
        '-d[do not make the new window become the active one]'
        '-k[kill the target window if it exists]'
        '-s[choose source window]:window:__tmux-windows'
        '-r[renumber windows in session in sequential order]'
        '-t[choose destination window]:window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-new-session() {
    [[ -n ${tmux_describe} ]] && print "Create a new session" && return
    local -a args
    args=(
        '-A[attach to existing session if it already exists]'
        '-c[specify working directory for the session]:directory:_path_files -g "*(-/)"'
        '-d[do not attach new session to current terminal]'
        '-D[in case of -A behave like attach-session'\''s -d]'
        '-F[specify format of output]:format:__tmux-format'
        '-n[name the initial window]:window name'
        '-P[print information about new session after it is created]'
        '-s[name the session]:session name:__tmux-sessions'
        '-t[specify target session]:sessions:__tmux-sessions'
        '-x[specify width]:width:_guard "[0-9]#" "numeric value"'
        '-y[specify height]:height:_guard "[0-9]#" "numeric value"'
        '*:: :_cmdstring'
    )
    _arguments -s : ${args}
}

function _tmux-new-window() {
    [[ -n ${tmux_describe} ]] && print "Create a new window" && return
    local -a args
    args=(
        '-a[insert new window at next free index from -t]'
        '-c[specify working directory for the session]:directory:_path_files -g "*(-/)"'
        '-d[do not make the new window become the active one]'
        '-F[specify format of output]:format:__tmux-format'
        '-k[destroy it if the specified window exists]'
        '-n[specify a window name]:window name:'
        '-P[print information about new window after it is created]'
        '-t[specify target window]:windows:__tmux-windows'
        '*:: :_cmdstring'
    )
    _arguments : ${args}
}

function _tmux-next-layout() {
    [[ -n ${tmux_describe} ]] && print "Move a window to the next layout" && return
    local -a args
    args=('-t[choose target window]:window:__tmux-windows')
    _arguments : ${args}
}

function _tmux-next-window() {
    [[ -n ${tmux_describe} ]] && print "Move to the next window in a session" && return
    local -a args
    args=(
        '-a[move to the next window with an alert]'
        '-t[choose target session]:session:__tmux-sessions'
    )
    _arguments : ${args}
}

function _tmux-paste-buffer() {
    [[ -n ${tmux_describe} ]] && print "Insert a paste buffer into the window" && return
    local -a args
    args=(
        '-b[choose buffer]:source buffer:__tmux-buffers'
        '-d[remove buffer from stack after pasting]'
        '-p[use bracketed paste mode if the application requested it]'
        '-r[do not replace LF with CR when pasting]'
        '-s[specify separator]:separator:'
        '-t[choose target window]:window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-pipe-pane() {
    [[ -n ${tmux_describe} ]] && print "Pipe output from a pane to a shell command" && return
    local state
    args=(
        '-o[only open a pipe if none is currently opened]'
        '-t[choose target pane]:pane:__tmux-panes'
        '*:: :->cmd'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'cmd' 1 "command string"
}

function _tmux-previous-layout() {
    [[ -n ${tmux_describe} ]] && print "Move a window to the previous layout" && return
    local -a args
    args=('-t[choose target window]:window:__tmux-windows')
    _arguments : ${args}
}

function _tmux-previous-window() {
    [[ -n ${tmux_describe} ]] && print "Move to the previous window in a session" && return
    local -a args
    args=(
        '-a[move to the previous window with an alert]'
        '-t[choose target session]:session:__tmux-sessions'
    )
    _arguments : ${args}
}

function _tmux-refresh-client() {
    [[ -n ${tmux_describe} ]] && print "Refresh a client" && return
    local -a args
    args=(
        '-S[Only update the client'\''s status bar]'
        '-t[choose target client]:client:__tmux-clients'
    )
    _arguments : ${args}
}

function _tmux-rename-session() {
    [[ -n ${tmux_describe} ]] && print "Rename a session" && return
    local state
    args=(
        '-t[choose target session]:session:__tmux-sessions'
        '*:: :->name'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'name' 1 "new session name"
}

function _tmux-rename-window() {
    [[ -n ${tmux_describe} ]] && print "Rename a window" && return
    local state
    args=(
        '-t[choose target window]:window:__tmux-windows'
        '*:: :->name'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'name' 1 "new window name"
}

function _tmux-resize-pane() {
    [[ -n ${tmux_describe} ]] && print "Resize a pane" && return
    args=(
        '-D[resize downward]'
        '-L[resize to the left]'
        '-R[resize to the right]'
        '-U[resize upward]'
        '-t[choose target pane]:pane:__tmux-panes'
        '-x[specify width]:width:_guard "[0-9]#" "numeric value"'
        '-y[specify height]:height:_guard "[0-9]#" "numeric value"'
        '-Z[toggle zoom of pane]'
        '1::adjustment (defaults to one):_guard "[0-9]#" "numeric value"'
    )
    _arguments : ${args}
}

function _tmux-respawn-pane() {
    [[ -n ${tmux_describe} ]] && print "Reuse a pane in which a command has exited" && return
    local -a args
    args=(
        '-k[kill window if it is in use]'
        '-t[choose target pane]:window:__tmux-pane'
        '*::command:_cmdstring'
    )
    _arguments : ${args}
}

function _tmux-respawn-window() {
    [[ -n ${tmux_describe} ]] && print "Reuse a window in which a command has exited" && return
    local -a args
    args=(
        '-k[kill window if it is in use]'
        '-t[choose target window]:window:__tmux-windows'
        '*::command:_cmdstring'
    )
    _arguments : ${args}
}

function _tmux-rotate-window() {
    [[ -n ${tmux_describe} ]] && print "Rotate positions of panes in a window" && return
    local -a args
    args=(
        '-D[rotate downward]'
        '-U[rotate upward]'
        '-t[choose target window]:window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-run-shell() {
    [[ -n ${tmux_describe} ]] && print "Execute a command without creating a new window" && return
    local -a args
    args=(
        '-b[run shell command in background]'
        '-t[choose target pane]:pane:__tmux-panes'
        '*::command:_cmdstring'
    )
    _arguments : ${args}
}

function _tmux-save-buffer() {
    [[ -n ${tmux_describe} ]] && print "Save a paste buffer to a file" && return
    local -a args

    args=(
        '-a[append to rather than overwriting file]'
        '-b[choose a target buffer index]:buffer:__tmux-buffers'
    )
    _arguments : ${args} && return
}

function _tmux-select-layout() {
    [[ -n ${tmux_describe} ]] && print "Choose a layout for a window" && return
    args=(
        '-n[behave like next-layout]'
        '-p[behave like previous-layout]'
        '-t[choose a target window]:target window:__tmux-windows'
        '*::layout name:__tmux-layouts'
    )
    _arguments : ${args}
}

function _tmux-select-pane() {
    [[ -n ${tmux_describe} ]] && print "Make a pane the active one in the window" && return
    local -a args
    args=(
        '-D[Move to the pane down of this]'
        '-d[disable input to the pane]'
        '-e[enable input to the pane]'
        '-l[behave like last-pane]'
        '-L[Move to the pane left of this]'
        '-R[Move to the pane right of this]'
        '-U[Move to the pane above this]'
        '-t[choose a target pane]:panes:__tmux-panes'
    )
    _arguments : ${args} && return
}

function _tmux-select-window() {
    [[ -n ${tmux_describe} ]] && print "Select a window" && return
    local -a args
    args=(
        '-l[behave like last-window]'
        '-n[behave like next-window]'
        '-p[behave like previous-window]'
        '-T[if selected window is the current behave like last-window]'
        '-t[choose a target window]:windows:__tmux-windows'
    )
    _arguments : ${args} && return
}

function _tmux-send-keys() {
    [[ -n ${tmux_describe} ]] && print "Send key(s) to a window" && return
    local curcontext="${curcontext}" state
    local -a args
    args=(
        '-l[disable key name lookup and send data literally]'
        '-R[reset terminal state]'
        '-t[choose a target pane]:panes:__tmux-panes'
        '*:: :->key'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'key' 1 "key"
}

function _tmux-send-prefix() {
    [[ -n ${tmux_describe} ]] && print "Send the prefix key to a window" && return
    local -a args
    args=(
        '-2[send secondary prefix key]'
        '-t[choose a target pane]:panes:__tmux-panes'
    )
    _arguments : ${args}
}

function _tmux-server-info() {
    [[ -n ${tmux_describe} ]] && print "Show server information" && return
    __tmux-nothing-else
}

function _tmux-set-buffer() {
    [[ -n ${tmux_describe} ]] && print "Set contents of a paster buffer" && return
    local state
    local -a args
    args=(
        '-a[append to rather than overwriting target buffer]'
        '-b[choose a target buffer index]:panes:__tmux-buffer'
        '-n[specify new buffer name]:buffer-name:'
        '*:: :->data'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'data' 1 "data"
}

function _tmux-set-environment() {
    [[ -n ${tmux_describe} ]] && print "(Un)Set an environment variable" && return
    local state
    local -a args
    args=(
        '-g[modify global environment]'
        '-r[remove variable before starting new processes]'
        '-u[unset a variable]'
        '-t[choose a target session]:target session:__tmux-sessions'
        '*:: :->name_or_value'
    )
    _arguments -C : ${args}

    case ${state} in
        name_or_value)
            if (( CURRENT == 1 )); then
                _message 'name'
            elif (( CURRENT == 2 )); then
                _message 'value'
            else
                __tmux-nothing-else
            fi
            ;;
    esac
}

function _tmux-set-option() {
    [[ -n ${tmux_describe} ]] && print "Set a session option" && return
    local mode
    local -a args
    args=(
        '-a[append to string options]'
        '-g[set a global session option]'
        '-u[unset a non-global option]'
        '-w[change window (not session) options]'
        '-s[change server (not session) options]'
        '-t[choose a target session]:target session:__tmux-sessions'
        '*:: :->name_or_value'
    )
    if __tmux-got-option-already -w; then
        mode=window
    elif __tmux-got-option-already -s; then
        mode=server
    else
        mode=session
    fi
    _arguments -C : ${args}
    __tmux-options-complete ${mode} ${state}
}

function _tmux-set-window-option() {
    [[ -n ${tmux_describe} ]] && print "Set a window option" && return
    local -a args
    args=(
        '-a[append to string options]'
        '-g[set a global window option]'
        '-u[unset a non-global option]'
        '-t[choose a target window]:target window:__tmux-windows'
        '*:: :->name_or_value'
    )
    _arguments -C : ${args}
    __tmux-options-complete window ${state}
}

function _tmux-show-buffer() {
    [[ -n ${tmux_describe} ]] && print "Display the contents of a paste buffer" && return
    local -a args
    args=('-b[choose a target buffer index]:panes:->buffer')
    _arguments : ${args} && return
}

function _tmux-show-environment() {
    [[ -n ${tmux_describe} ]] && print "Display the environment" && return
    local -a args
    args=(
        '-g[show global environment]'
        '-t[choose a target session]:target session:__tmux-sessions'
    )
    _arguments : ${args}
}

function _tmux-show-messages() {
    [[ -n ${tmux_describe} ]] && print "Show client"\'"s message log" && return
    local -a args
    args=(
        '-I[show debugging information about the tmux server]'
        '-J[show debugging information about running jobs]'
        '-T[show debugging information about involved terminals]'
        '-t[choose target client]:client:__tmux-clients'
    )
    _arguments : ${args}
}

function _tmux-show-options() {
    [[ -n ${tmux_describe} ]] && print "Show session options" && return
    local -a args
    args=(
        '-g[show global options]'
        '-t[choose a target session]:target session:__tmux-sessions'
    )
    _arguments : ${args}
}

function _tmux-show-window-options() {
    [[ -n ${tmux_describe} ]] && print "Show window options" && return
    local -a args
    args=(
        '-g[show global options]'
        '-t[choose a target window]:target window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-source-file() {
    [[ -n ${tmux_describe} ]] && print "Execute tmux commands from a file" && return
    _files -g "*(-.)"
}

function _tmux-split-window() {
    [[ -n ${tmux_describe} ]] && print "Splits a pane into two" && return
    local -a args
    args=(
        '-b[create new pane left of or above target pane]'
        '-d[do not make the new window become the active one]'
        '-F[specify format of output]:format:__tmux-format'
        '-h[split horizontally]'
        '-v[split vertically]'
        '-l[define new pane'\''s size]: :_guard "[0-9]#" "numeric value"'
        '-p[define new pane'\''s size in percent]: :_guard "[0-9]#" "numeric value"'
        # Yes, __tmux-panes is correct here. The behaviour was changed
        # in recent tmux versions and makes more sense. Except that
        # changing the command's name might annoy users. So it stays like
        # this.
        '-t[choose target pane]:window:__tmux-panes'
        '*:: :_cmdstring'
    )
    _arguments : ${args} && return
}

function _tmux-start-server() {
    [[ -n ${tmux_describe} ]] && print "Start a tmux server" && return
    __tmux-nothing-else
}

function _tmux-suspend-client() {
    [[ -n ${tmux_describe} ]] && print "Suspend a client" && return
    local -a args
    args=('-t[choose destination client]:client:__tmux-clients')
    _arguments : ${args}
}

function _tmux-swap-pane() {
    [[ -n ${tmux_describe} ]] && print "Swap two panes" && return
    local -a args
    args=(
        '-D[move pane down]'
        '-U[move pane up]'
        '-d[do not change the active pane]'
        '-s[choose source pane]:pane:__tmux-panes'
        '-t[choose destination pane]:pane:__tmux-panes'
    )
    _arguments : ${args}
}

function _tmux-swap-window() {
    [[ -n ${tmux_describe} ]] && print "Swap two windows" && return
    local -a args
    args=(
        '-d[do not make the new window become the active one]'
        '-s[choose source window]:window:__tmux-windows'
        '-t[choose destination window]:window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-switch-client() {
    [[ -n ${tmux_describe} ]] && print "Switch the client to another session" && return
    local -a args
    args=(
        '-c[choose a target client]:client:__tmux-clients'
        '-l[move client to last session]'
        '-n[move client to next session]'
        '-p[move client to previous session]'
        '-r[toggle read-only flag of client]'
        '-t[choose a target window]:window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-unbind-key() {
    [[ -n ${tmux_describe} ]] && print "Unbind a key" && return
    local state keytable
    local -a args ow

    ow=( "${words[@]}" )
    args=(
        '-a[Remove all key bindings]'
        '-c[kill the window if it is only in one session]'
        '-n[remove a non-prefix binding]'
        '-t[choose a key table]:key table:__tmux-key-tables'
        '*:: :->boundkeys'
    )
    _arguments : ${args} && return
    [[ ${state} != 'boundkeys' ]] && return
    keytable="$(__tmux-get-optarg -t "${ow[@]}")"
    if [[ -n ${keytable} ]]; then
        __tmux-bound-keys -t ${keytable}
        return
    fi
    __tmux-bound-keys
}

function _tmux-unlink-window() {
    [[ -n ${tmux_describe} ]] && print "Unlink a window" && return
    local -a args
    args=(
        '-k[kill the window if it is only in one session]'
        '-t[choose a target window]:target window:__tmux-windows'
    )
    _arguments : ${args}
}

function _tmux-wait-for() {
    [[ -n ${tmux_describe} ]] && print "Wait for an event or trigger it" && return
    local state
    local -a args
    args=(
        '-L[lock the named channel]'
        '-S[send signal to channel]'
        '-U[unlock the named channel]'
        '*:: :->channel'
    )
    _arguments : ${args} && return
    __tmux-lastarg ${state} 'channel' 1 "event channel"
}

# --- Utility functions ---
# They should be called __tmux-*() and kept seperate from the
# sub-command functions.

function __tmux-attributes() {
    local -a attr already
    attr=( default bright bold dim underscore blink reverse hidden italics )
    compset -P '*,'
    already=(${(s<,>)IPREFIX})
    _describe -t tmux-attribute 'tmux attribute' attr -S, -F already -q
}

function __tmux-buffers() {
    local expl
    local -a buffers

    if [[ ${(t)bopts} != *array* ]]; then
        local -a bopts; bopts=()
    fi

    buffers=( ${${(f)"$(command tmux 2> /dev/null list-buffers "${bopts[@]}")"}/:[ $'\t']##/:} )
    _describe -t buffers 'buffers' buffers
}

function __tmux-bound-keys() {
    local expl
    local -a keys

    keys=( ${${${${(f)"$(command tmux 2> /dev/null list-keys "$@")"}/:[ $'\t']##/:}/(#s)[ $'\t']##/}/(#s):/\\:} )
    _describe -t keys 'keys' keys
}

function __tmux-clients() {
    local expl
    local -a clients
    clients=( ${${(f)"$(command tmux 2> /dev/null list-clients)"}/:[ $'\t']##/:} )
    _describe -t clients 'clients' clients
}

function __tmux-format() {
    _message 'not implemented yet'
}

function __tmux-colours() {
    local -a colnames
    colnames=( default black red green yellow blue magenta cyan white colourN:"replace N by a number between 0 and 255" )
    compset -P 'colour*'
    if [[ -z ${IPREFIX} ]]; then
        _describe -t tmux-colours 'colour' colnames
    else
        _message 'colour number 0..255'
    fi
}

function __tmux-get-optarg() {
    local opt="$1"
    local -i i
    shift

    for (( i = 1; i <= $#; i++ )); do
        if [[ ${argv[$i]} == ${opt} ]]; then
            if [[ ${argv[$(( i + 1 ))]} != -* ]]; then
                print -- ${argv[$(( i + 1 ))]}
            fi
            return
        fi
    done
}

function __tmux-got-option-already() {
    [[ -n ${(M)words:#$1} ]] && return 0
    return 1
}

function __tmux-key-tables() {
    local expl
    local -a tables
    tables=( vi-edit emacs-edit vi-choice emacs-choice vi-copy emacs-copy )
    _wanted keytable expl 'key tables' compadd ${expl} -- ${tables}
}

function __tmux-lastarg() {
    local got_state="$1" want_state="$2" pos="$3" msg="$4"

    if [[ ${want_state} == ${got_state} ]] && (( CURRENT == ${pos} )); then
        _message ${msg}
    else
        __tmux-nothing-else
    fi
}

function __tmux-layouts() {
    local expl
    local -a layouts
    layouts=( even-horizontal even-vertical main-horizontal main-vertical )
    _wanted layout expl 'layouts' compadd ${expl} -- ${layouts}
}

function __tmux-nothing-else() {
    _message "no further arguments"
}

function __tmux-option-guard() {
    local mode opt guard int_guard
    mode="$1"
    opt="$2"
    shift; shift
    local -a options desc
    int_guard='_guard "[0-9]#" "'${opt}': numeric value"'
    if [[ ${mode} == 'session' ]]; then
        options=(
            'assume-paste-time:'${int_guard}
            'base-index:'${int_guard}
            'bell-action:DESC:any none current other'
            'bell-on-alert:DESC:on off'
            'default-command:MSG:command string'
            'default-shell:MSG:shell executable'
            'destroy-unattached:DESC:on off'
            'detach-on-destroy:DESC:on off'
            'display-panes-colour:__tmux-colours'
            'display-panes-active-colour:__tmux-colours'
            'display-panes-time:'${int_guard}
            'display-time:'${int_guard}
            'history-limit:'${int_guard}
            'lock-after-time:'${int_guard}
            'lock-command:MSG:command string'
            'message-command-style:__tmux-style'
            'message-style:__tmux-style'
            'mouse:DESC:on off'
            'mouse-utf8:DESC:on off'
            'prefix:MSG:primary prefix key'
            'prefix2:MSG:secondary prefix key'
            'renumber-windows:DESC:on off'
            'repeat-time:'${int_guard}
            'set-remain-on-exit:DESC:on off'
            'set-titles:DESC:on off'
            'set-titles-string:MSG:title format string'
            'status:DESC:on off'
            'status-interval:'${int_guard}
            'status-justify:DESC:left centre right'
            'status-keys:DESC:vi emacs'
            'status-left:MSG:format string'
            'status-left-length:'${int_guard}
            'status-left-style:__tmux-style'
            'status-position:DESC:top bottom'
            'status-right:MSG:format string'
            'status-right-length:'${int_guard}
            'status-right-style:__tmux-style'
            'status-style:__tmux-style'
            'status-utf8:DESC:on off'
            'update-environment:MSG:string listing env. variables'
            'visual-activity:DESC:on off'
            'visual-bell:DESC:on off'
            'visual-silence:DESC:on off'
            'word-separators:MSG:separator string'
        )
    elif [[ ${mode} == 'server' ]]; then
        options=(
            'buffer-limit:'${int_guard}
            'default-terminal:MSG:terminal string'
            'escape-time:'${int_guard}
            'exit-unattached:DESC:on off'
            'focus-events:DESC:on off'
            'history-file:_path-files -g "*(-.)"'
            'message-limit:'${int_guard}
            'quiet:DESC:on off'
            'set-clipboard:DESC:on off'
            'terminal-overrides:MSG:overrides string'
        )
    else
        options=(
            'aggressive-resize:DESC:on off'
            'allow-rename:DESC:on off'
            'alternate-screen:DESC:on off'
            'automatic-rename:DESC:on off'
            'automatic-rename-format:DESC:__tmux-format'
            'clock-mode-colour:__tmux-colours'
            'clock-mode-style:DESC:12 24'
            'force-height:'${int_guard}
            'force-width:'${int_guard}
            'main-pane-height:'${int_guard}
            'main-pane-width:'${int_guard}
            'mode-keys:DESC:vi emacs'
            'mode-style:__tmux-style'
            'monitor-activity:DESC:on off'
            'monitor-silence:DESC:on off'
            'other-pane-height:'${int_guard}
            'other-pane-width:'${int_guard}
            'pane-active-border-style:__tmux-style'
            'pane-base-index:'${int_guard}
            'pane-border-style:__tmux-style'
            'remain-on-exit:DESC:on off'
            'synchronize-panes:DESC:on off'
            'utf8:DESC:on off'
            'window-active-style:__tmux-style'
            'window-status-activity-style:__tmux-style'
            'window-status-bell-style:__tmux-style'
            'window-status-current-format:MSG:status format string'
            'window-status-current-style:__tmux-style'
            'window-status-format:MSG:status format string'
            'window-status-last-style:__tmux-style'
            'window-status-separator:MSG:separator string'
            'window-status-style:__tmux-style'
            'window-style:__tmux-style'
            'wrap-seach:DESC:on off'
            'xterm-keys:DESC:on off'
        )
    fi

    guard=${(M)options:#$opt:*}
    if [[ -z ${guard} ]]; then
        _message "unknown ${mode} option: ${opt}"
        return
    fi
    _message "${mode} option value"
    guard=${guard#*:}
    case ${guard} in
        ('') ;;
        (MSG:*)
            _message ${guard#*:}
            ;;
        (DESC:*)
            eval "desc=( ${guard#*:} )"
            _describe -t "tmux-${mode}-option-value" "${opt}" desc
            ;;
        (*)
            eval ${guard}
            ;;
    esac
}

function __tmux-session-options() {
    local -a tmux_session_options
    tmux_session_options=(
        'assume-paste-time:assume keys are pasted instead of typed if this fast'
        'base-index:define where to start numbering'
        'bell-action:set action on window bell'
        'bell-on-alert:ring the terminal bell when an alert occurs'
        'default-command:default command for new windows'
        'default-shell:default shell executable'
        'destroy-unattached:destroy session if no client is attached'
        'detach-on-destroy:detach client if attached session is destroyed'
        'display-panes-colour:colour used for display-panes'
        'display-panes-active-colour:colour for active pane in display-panes'
        'display-panes-time:time (in msecs) of display-panes output'
        'display-time:time (in msecs) messages are displayed'
        'history-limit:number of copy-mode lines per window'
        'lock-after-time:lock sessions after N seconds'
        'lock-command:command to run for locking a client'
        'message-command-style:status line message command style'
        'message-style:status line message style'
        'mouse:enable mouse support'
        'mouse-utf8:request utf8 mouse support'
        'prefix:primary prefix key'
        'prefix2:secondary prefix key'
        'renumber-windows:renumber windows if a window is closed'
        'repeat-time:time for multiple commands without prefix-key presses'
        'set-remain-on-exit:set remain-on-exit window option'
        'set-titles:try to set xterm window titles'
        'set-titles-string:format used by set-titles'
        'status:show or hide the status bar'
        'status-interval:interval (in seconds) for status bar updates'
        'status-justify:position of the window list in status bar'
        'status-keys:mode to use in status bar modes (vi/emacs)'
        'status-left:format to use left in status bar'
        'status-left-length:maximum length of the left part of the status bar'
        'status-left-style:style of left part of status line'
        'status-position:status line position'
        'status-right:format to use right in status bar'
        'status-right-length:maximum length of the right part of the status bar'
        'status-right-style:style of right part of status line'
        'status-style:style status line'
        'status-utf8:assume UTF-8 sequences to appear in status bar'
        'update-environment:list of variables to be copied to a session'\''s environment'
        'visual-activity:display status line messages upon activity'
        'visual-bell:use visual bell instead of audible'
        'visual-silence:print a message if monitor-silence is on'
        'word-separators:string of characters considered word separators'
    )
    _describe -t tmux-options 'tmux session option' tmux_session_options
}

function __tmux-options-complete() {
    local mode="$1" state="$2"

    case ${state} in
        name_or_value)
            if (( CURRENT == 1 )) && [[ ${mode} == 'session' ]]; then
                __tmux-session-options
            elif (( CURRENT == 1 )) && [[ ${mode} == 'server' ]]; then
                __tmux-server-options
            elif (( CURRENT == 1 )) && [[ ${mode} == 'window' ]]; then
                __tmux-window-options
            elif (( CURRENT == 2 )); then
                __tmux-option-guard ${mode} ${words[1]}
            else
                __tmux-nothing-else
            fi
            ;;
    esac
}

function __tmux-panes() {
    local expl line
    local -i num
    local -a panes opts

    compset -P '*.'
    if [[ -n ${IPREFIX} ]]; then
        opts=( -t "${IPREFIX%.}" )
    else
        opts=( )
    fi
    num=0
    command tmux 2> /dev/null list-panes "${opts[@]}" | while IFS= read -r line; do
        panes+=( $(( num++ )):${line//:/} )
    done
    _describe -t panes 'panes' panes "$@"
    if [[ ${IPREFIX} != *. ]]; then
        _wanted windows expl 'windows' __tmux-windows -S.
    fi
}

function __tmux-server-options() {
    local -a tmux_server_options
    tmux_server_options=(
        'buffer-limit:number of buffers kept per session'
        'default-terminal:default terminal definition string'
        'escape-time:set timeout to detect single escape characters (in msecs)'
        'exit-unattached:make server exit if it has no attached clients'
        'focus-events:request focus events from terminal'
        'history-file:tmux command history file name'
        'message-limit:set size of message log per client'
        'quiet:enable/disable the display of various informational messages'
        'set-clipboard:use esc sequences to set terminal clipboard'
        'terminal-overrides:override terminal descriptions'
    )
    _describe -t tmux-server-options 'tmux server option' tmux_server_options
}

function __tmux-sessions() {
    local expl
    local -a sessions
    sessions=( ${${(f)"$(command tmux 2> /dev/null list-sessions)"}/:[ $'\t']##/:} )
    _describe -t sessions 'sessions' sessions "$@"
}

function __tmux-socket-name() {
    local expl sdir
    local curcontext="${curcontext}"
    local -a socks
    zstyle -s ":completion:${curcontext}:sockets" socketdir sdir || sdir="/tmp/tmux-${UID}"
    socks=(${sdir}/*(=:t))
    _wanted socket expl 'socket name' compadd ${expl} -- ${socks}
}

function __tmux-style() {
    _message 'not implemented yet'
}

function __tmux-window-options() {
    local -a tmux_window_options
    tmux_window_options=(
        'aggressive-resize:aggressively resize windows'
        'allow-rename:allow programs to change window titles'
        'alternate-screen:allow alternate screen feature to be used'
        'automatic-rename:attempt to automatically rename windows'
        'automatic-rename-format:format for automatic renames'
        'clock-mode-colour:set clock colour'
        'clock-mode-style:set clock hour format (12/24)'
        'force-height:force a windows to a certain height'
        'force-width:force a windows to a certain width'
        'main-pane-height:set height for main-* layouts'
        'main-pane-width:set width for main-* layouts'
        'mode-keys:mode to use in copy and choice modes (vi/emacs)'
        'mode-style:set window modes style'
        'monitor-activity:monitor window activity'
        'monitor-silence:monitor window for inactivity'
        'other-pane-height:height of other panes'
        'other-pane-width:width of other panes'
        'pane-active-border-style:style of border of active pane'
        'pane-base-index:integer at which to start indexing panes'
        'pane-border-style:style of border pane'
        'remain-on-exit:do not destroy windows after the program exits'
        'synchronize-panes:send input to all panes of a window'
        'utf8:assume UTF-8 sequences to appear in a window'
        'window-active-style:style of active window'
        'window-status-activity-style:style of status bar activity tag'
        'window-status-bell-style:style of status bar bell tag'
        'window-status-current-format:set status line format for active window'
        'window-status-current-style:style of current window in status bar'
        'window-status-format:set status line format for all but the active window'
        'window-status-last-style:style of last window in status bar'
        'window-status-separator:separator drawn between windows in status line'
        'window-status-style:general status bar style'
        'window-style:style of window'
        'wrap-search:search wrap around at the end of a pane'
        'xterm-keys:generate xterm-style function key sequences'
    )
    _describe -t tmux-window-options 'tmux window option' tmux_window_options
}

function __tmux-windows() {
    local expl
    local -a wins opts

    compset -P '*:'
    if [[ -n ${IPREFIX} ]]; then
        opts=( -t "${IPREFIX%:}" )
    else
        opts=( )
    fi
    wins=( ${${(M)${(f)"$(command tmux 2> /dev/null list-windows "${opts[@]}")"}:#<->*}/:[ $'\t']##/:} )
    _describe -t windows 'windows' wins "$@"
    if [[ ${IPREFIX} != *: ]]; then
        _wanted sessions expl 'sessions' __tmux-sessions -S:
    fi
}

# And here is the actual _tmux(), that puts it all together:
function _tmux() {
    local curcontext="${curcontext}"
    local mode state ret=1
    local -a args
    local tmuxcommand
    local tmux_describe=

    args=(
        '-2[force using 256 colours]'
        '-8[force using 88 colours]'
        '-c[execute a shell command]:command name:_command_names'
        '-C[start tmux in control mode. -CC disables echo]'
        '-f[specify configuration file]:tmux config file:_files -g "*(-.)"'
        '-l[behave like a login shell]'
        '-L[specify socket name]:socket name:__tmux-socket-name'
        '-S[specify socket path]:server socket:_path_files -g "*(=,/)"'
        '-u[force using UTF-8]'
        '-v[request verbose logging]'
        '-V[report tmux version]'
        '*:: :->subcommand_or_options'
    )
    _arguments -C -s -w : ${args} && ret=0

    if [[ ${state} == "subcommand_or_options" ]]; then
        if (( CURRENT == 1 )) ; then
            zstyle -s ":completion:${curcontext}:subcommands" mode mode || mode='both'
            if [[ ${mode} == 'commands' ]]; then
                _describe -t subcommands 'tmux commands' _tmux_commands && ret=0
            elif [[ ${mode} == 'aliases' ]]; then
                _describe -t subcommands 'tmux aliases' _tmux_aliases && ret=0
            else
                _describe -t subcommands 'tmux commands and aliases' _tmux_commands -- _tmux_aliases && ret=0
            fi
        else
            if (( ${+commands[tmux]} == 0 )); then
                _message '`tmux'\'' not found in $path; sub-cmd completions disabled.'
                return
            fi
            tmuxcommand="${words[1]}"
            if [[ -n ${_tmux_aliasmap[$tmuxcommand]} ]] ; then
                tmuxcommand="${_tmux_aliasmap[$tmuxcommand]}"
            fi
            if ! (( ${+functions[_tmux-$tmuxcommand]} )); then
              local low high
              low=$_tmux_commands[(i)$tmuxcommand*]
              high=$_tmux_commands[(I)$tmuxcommand*]
              if (( low == high )); then
                tmuxcommand=${_tmux_commands[low]%%:*}
              elif (( low < high )); then
                _message -e "Ambiguous command $tmuxcommand"
              else
                _message -e "Subcommand $tmuxcommand not known"
              fi
            fi
            curcontext="${curcontext%:*:*}:tmux-${tmuxcommand}:"
            _call_function ret _tmux-${tmuxcommand}
        fi
    fi
    return ret
}

# description generation follows; only done on 1st _tmux call.
local f desc
local -A rev
local tmux_describe
tmux_describe='yes, please'
for f in ${(k)_tmux_aliasmap} ; do
    rev+=( ${_tmux_aliasmap[$f]} $f )
done
for f in ${(M)${(k)functions}:#_tmux-*} ; do
    desc="$($f)"
    _tmux_commands+=( "${f#_tmux-}${desc:+:$desc}" )
    [[ -n ${rev[${f#_tmux-}]} ]] && _tmux_aliases+=( "${rev[${f#_tmux-}]}${desc:+:$desc}" )
done

_tmux "$@"