lisp/term/xterm.el

   1 ;;; xterm.el --- define function key sequences and standard colors for xterm  -*- lexical-binding: t -*-
   2
   3 ;; Copyright (C) 1995, 2001-2015 Free Software Foundation, Inc.
   4
   5 ;; Author: FSF
   6 ;; Keywords: terminals
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24
  25 ;;; Code:
  26
  27 (defgroup xterm nil
  28   "XTerm support."
  29   :version "24.1"
  30   :group 'terminals)
  31
  32 (defconst xterm--extra-capabilities-type
  33   ;; NOTE: If you add entries here, make sure to update
  34   ;; `terminal-init-xterm' as well.
  35   '(set (const :tag "modifyOtherKeys support" modifyOtherKeys)
  36         (const :tag "report background" reportBackground)
  37         (const :tag "get X selection" getSelection)
  38         (const :tag "set X selection" setSelection)))
  39
  40 (defcustom xterm-extra-capabilities 'check
  41   "Whether Xterm supports some additional, more modern, features.
  42 If nil, just assume that it does not.
  43 If `check', try to check if it does.
  44 If a list, assume that the listed features are supported, without checking.
  45
  46 The relevant features are:
  47   modifyOtherKeys  -- if supported, more key bindings work (e.g., \"\\C-,\")
  48   reportBackground -- if supported, Xterm reports its background color
  49   getSelection     -- if supported, Xterm yanks text from the X selection
  50   setSelection     -- if supported, Xterm saves killed text to the X selection"
  51   :version "24.1"
  52   :type `(choice (const :tag "Check" check)
  53                  ,xterm--extra-capabilities-type))
  54
  55 (defcustom xterm-max-cut-length 100000
  56   "Maximum number of bytes to cut into xterm using the OSC 52 sequence.
  57
  58 The OSC 52 sequence requires a terminator byte.  Some terminals will ignore or
  59 mistreat a terminated sequence that is longer than a certain size, usually to
  60 protect users from runaway sequences.
  61
  62 This variable allows you to tweak the maximum number of bytes that will be sent
  63 using the OSC 52 sequence.
  64
  65 If you select a region larger than this size, it won't be copied to your system
  66 clipboard.  Since clipboard data is base 64 encoded, the actual number of
  67 string bytes that can be copied is 3/4 of this value."
  68   :type 'integer)
  69
  70 (defconst xterm-paste-ending-sequence "\e[201~"
  71   "Characters send by the terminal to end a bracketed paste.")
  72
  73 (defun xterm-paste ()
  74   "Handle the start of a terminal paste operation."
  75   (interactive)
  76   (let* ((end-marker-length (length xterm-paste-ending-sequence))
  77          (pasted-text (with-temp-buffer
  78                         (set-buffer-multibyte nil)
  79                         (while (not (search-backward
  80                                      xterm-paste-ending-sequence
  81                                      (- (point) end-marker-length) t))
  82                           (let ((event (read-event
  83                                         nil nil
  84                                         ;; Use finite timeout to avoid
  85                                         ;; glomming the event onto
  86                                         ;; this-command-keys.
  87                                         most-positive-fixnum)))
  88                             (when (eql event ?\r)
  89                               (setf event ?\n))
  90                             (insert event)))
  91                         (let ((last-coding-system-used))
  92                           (decode-coding-region
  93                            (point-min) (point)
  94                            (keyboard-coding-system) t))))
  95          (interprogram-paste-function (lambda () pasted-text)))
  96     (yank)))
  97
  98 (define-key global-map [xterm-paste] #'xterm-paste)
  99
 100 (defvar xterm-rxvt-function-map
 101   (let ((map (make-sparse-keymap)))
 102     (define-key map "\e[2~" [insert])
 103     (define-key map "\e[3~" [delete])
 104     (define-key map "\e[4~" [select])
 105     (define-key map "\e[5~" [prior])
 106     (define-key map "\e[6~" [next])
 107
 108     (define-key map "\e[15~" [f5])
 109     (define-key map "\e[17~" [f6])
 110     (define-key map "\e[18~" [f7])
 111     (define-key map "\e[19~" [f8])
 112     (define-key map "\e[20~" [f9])
 113     (define-key map "\e[21~" [f10])
 114
 115     (define-key map "\e[2;2~" [S-insert])
 116
 117     ;; Other versions of xterm might emit these.
 118     (define-key map "\e[A" [up])
 119     (define-key map "\e[B" [down])
 120     (define-key map "\e[C" [right])
 121     (define-key map "\e[D" [left])
 122
 123     (define-key map "\e[11~" [f1])
 124     (define-key map "\e[12~" [f2])
 125     (define-key map "\e[13~" [f3])
 126     (define-key map "\e[14~" [f4])
 127
 128     ;; Recognize the start of a bracketed paste sequence.  The handler
 129     ;; internally recognizes the end.
 130     (define-key map "\e[200~" [xterm-paste])
 131
 132     map)
 133   "Keymap of escape sequences, shared between xterm and rxvt support.")
 134
 135 (defvar xterm-function-map
 136   (let ((map (make-sparse-keymap)))
 137     (set-keymap-parent map xterm-rxvt-function-map)
 138
 139     ;; xterm from X.org 6.8.2 uses these key definitions.
 140     (define-key map "\eOP" [f1])
 141     (define-key map "\eOQ" [f2])
 142     (define-key map "\eOR" [f3])
 143     (define-key map "\eOS" [f4])
 144     (define-key map "\e[23~" [f11])
 145     (define-key map "\e[24~" [f12])
 146
 147     (define-key map "\eO2P" [S-f1])
 148     (define-key map "\eO2Q" [S-f2])
 149     (define-key map "\eO2R" [S-f3])
 150     (define-key map "\eO2S" [S-f4])
 151     (define-key map "\e[1;2P" [S-f1])
 152     (define-key map "\e[1;2Q" [S-f2])
 153     (define-key map "\e[1;2R" [S-f3])
 154     (define-key map "\e[1;2S" [S-f4])
 155     (define-key map "\e[15;2~" [S-f5])
 156     (define-key map "\e[17;2~" [S-f6])
 157     (define-key map "\e[18;2~" [S-f7])
 158     (define-key map "\e[19;2~" [S-f8])
 159     (define-key map "\e[20;2~" [S-f9])
 160     (define-key map "\e[21;2~" [S-f10])
 161     (define-key map "\e[23;2~" [S-f11])
 162     (define-key map "\e[24;2~" [S-f12])
 163
 164     (define-key map "\eO5P" [C-f1])
 165     (define-key map "\eO5Q" [C-f2])
 166     (define-key map "\eO5R" [C-f3])
 167     (define-key map "\eO5S" [C-f4])
 168     (define-key map "\e[15;5~" [C-f5])
 169     (define-key map "\e[17;5~" [C-f6])
 170     (define-key map "\e[18;5~" [C-f7])
 171     (define-key map "\e[19;5~" [C-f8])
 172     (define-key map "\e[20;5~" [C-f9])
 173     (define-key map "\e[21;5~" [C-f10])
 174     (define-key map "\e[23;5~" [C-f11])
 175     (define-key map "\e[24;5~" [C-f12])
 176
 177     (define-key map "\eO6P" [C-S-f1])
 178     (define-key map "\eO6Q" [C-S-f2])
 179     (define-key map "\eO6R" [C-S-f3])
 180     (define-key map "\eO6S" [C-S-f4])
 181     (define-key map "\e[15;6~" [C-S-f5])
 182     (define-key map "\e[17;6~" [C-S-f6])
 183     (define-key map "\e[18;6~" [C-S-f7])
 184     (define-key map "\e[19;6~" [C-S-f8])
 185     (define-key map "\e[20;6~" [C-S-f9])
 186     (define-key map "\e[21;6~" [C-S-f10])
 187     (define-key map "\e[23;6~" [C-S-f11])
 188     (define-key map "\e[24;6~" [C-S-f12])
 189
 190     (define-key map "\eO3P" [M-f1])
 191     (define-key map "\eO3Q" [M-f2])
 192     (define-key map "\eO3R" [M-f3])
 193     (define-key map "\eO3S" [M-f4])
 194     (define-key map "\e[15;3~" [M-f5])
 195     (define-key map "\e[17;3~" [M-f6])
 196     (define-key map "\e[18;3~" [M-f7])
 197     (define-key map "\e[19;3~" [M-f8])
 198     (define-key map "\e[20;3~" [M-f9])
 199     (define-key map "\e[21;3~" [M-f10])
 200     (define-key map "\e[23;3~" [M-f11])
 201     (define-key map "\e[24;3~" [M-f12])
 202
 203     (define-key map "\eO4P" [M-S-f1])
 204     (define-key map "\eO4Q" [M-S-f2])
 205     (define-key map "\eO4R" [M-S-f3])
 206     (define-key map "\eO4S" [M-S-f4])
 207     (define-key map "\e[15;4~" [M-S-f5])
 208     (define-key map "\e[17;4~" [M-S-f6])
 209     (define-key map "\e[18;4~" [M-S-f7])
 210     (define-key map "\e[19;4~" [M-S-f8])
 211     (define-key map "\e[20;4~" [M-S-f9])
 212     (define-key map "\e[21;4~" [M-S-f10])
 213     (define-key map "\e[23;4~" [M-S-f11])
 214     (define-key map "\e[24;4~" [M-S-f12])
 215
 216     (define-key map "\eOA" [up])
 217     (define-key map "\eOB" [down])
 218     (define-key map "\eOC" [right])
 219     (define-key map "\eOD" [left])
 220     (define-key map "\eOF" [end])
 221     (define-key map "\eOH" [home])
 222
 223     (define-key map "\e[1;2A" [S-up])
 224     (define-key map "\e[1;2B" [S-down])
 225     (define-key map "\e[1;2C" [S-right])
 226     (define-key map "\e[1;2D" [S-left])
 227     (define-key map "\e[1;2F" [S-end])
 228     (define-key map "\e[1;2H" [S-home])
 229
 230     (define-key map "\e[1;4A" [M-S-up])
 231     (define-key map "\e[1;4B" [M-S-down])
 232     (define-key map "\e[1;4C" [M-S-right])
 233     (define-key map "\e[1;4D" [M-S-left])
 234     (define-key map "\e[1;4F" [M-S-end])
 235     (define-key map "\e[1;4H" [M-S-home])
 236
 237     (define-key map "\e[1;5A" [C-up])
 238     (define-key map "\e[1;5B" [C-down])
 239     (define-key map "\e[1;5C" [C-right])
 240     (define-key map "\e[1;5D" [C-left])
 241     (define-key map "\e[1;5F" [C-end])
 242     (define-key map "\e[1;5H" [C-home])
 243
 244     (define-key map "\e[1;6A" [C-S-up])
 245     (define-key map "\e[1;6B" [C-S-down])
 246     (define-key map "\e[1;6C" [C-S-right])
 247     (define-key map "\e[1;6D" [C-S-left])
 248     (define-key map "\e[1;6F" [C-S-end])
 249     (define-key map "\e[1;6H" [C-S-home])
 250
 251     (define-key map "\e[1;7A" [C-M-up])
 252     (define-key map "\e[1;7B" [C-M-down])
 253     (define-key map "\e[1;7C" [C-M-right])
 254     (define-key map "\e[1;7D" [C-M-left])
 255     (define-key map "\e[1;7F" [C-M-end])
 256     (define-key map "\e[1;7H" [C-M-home])
 257
 258     (define-key map "\e[1;8A" [C-M-S-up])
 259     (define-key map "\e[1;8B" [C-M-S-down])
 260     (define-key map "\e[1;8C" [C-M-S-right])
 261     (define-key map "\e[1;8D" [C-M-S-left])
 262     (define-key map "\e[1;8F" [C-M-S-end])
 263     (define-key map "\e[1;8H" [C-M-S-home])
 264
 265     (define-key map "\e[1;3A" [M-up])
 266     (define-key map "\e[1;3B" [M-down])
 267     (define-key map "\e[1;3C" [M-right])
 268     (define-key map "\e[1;3D" [M-left])
 269     (define-key map "\e[1;3F" [M-end])
 270     (define-key map "\e[1;3H" [M-home])
 271
 272     (define-key map "\e[3;2~" [S-delete])
 273     (define-key map "\e[5;2~" [S-prior])
 274     (define-key map "\e[6;2~" [S-next])
 275
 276     (define-key map "\e[2;4~" [M-S-insert])
 277     (define-key map "\e[3;4~" [M-S-delete])
 278     (define-key map "\e[5;4~" [M-S-prior])
 279     (define-key map "\e[6;4~" [M-S-next])
 280
 281     (define-key map "\e[2;5~" [C-insert])
 282     (define-key map "\e[3;5~" [C-delete])
 283     (define-key map "\e[5;5~" [C-prior])
 284     (define-key map "\e[6;5~" [C-next])
 285
 286     (define-key map "\e[2;6~" [C-S-insert])
 287     (define-key map "\e[3;6~" [C-S-delete])
 288     (define-key map "\e[5;6~" [C-S-prior])
 289     (define-key map "\e[6;6~" [C-S-next])
 290
 291     (define-key map "\e[2;7~" [C-M-insert])
 292     (define-key map "\e[3;7~" [C-M-delete])
 293     (define-key map "\e[5;7~" [C-M-prior])
 294     (define-key map "\e[6;7~" [C-M-next])
 295
 296     (define-key map "\e[2;8~" [C-M-S-insert])
 297     (define-key map "\e[3;8~" [C-M-S-delete])
 298     (define-key map "\e[5;8~" [C-M-S-prior])
 299     (define-key map "\e[6;8~" [C-M-S-next])
 300
 301     (define-key map "\e[2;3~" [M-insert])
 302     (define-key map "\e[3;3~" [M-delete])
 303     (define-key map "\e[5;3~" [M-prior])
 304     (define-key map "\e[6;3~" [M-next])
 305
 306     (define-key map "\e[29~" [print])
 307
 308     (define-key map "\eOj" [kp-multiply])
 309     (define-key map "\eOk" [kp-add])
 310     (define-key map "\eOl" [kp-separator])
 311     (define-key map "\eOm" [kp-subtract])
 312     (define-key map "\eOo" [kp-divide])
 313     (define-key map "\eOp" [kp-0])
 314     (define-key map "\eOq" [kp-1])
 315     (define-key map "\eOr" [kp-2])
 316     (define-key map "\eOs" [kp-3])
 317     (define-key map "\eOt" [kp-4])
 318     (define-key map "\eOu" [kp-5])
 319     (define-key map "\eOv" [kp-6])
 320     (define-key map "\eOw" [kp-7])
 321     (define-key map "\eOx" [kp-8])
 322     (define-key map "\eOy" [kp-9])
 323
 324     (define-key map "\eO2j" [S-kp-multiply])
 325     (define-key map "\eO2k" [S-kp-add])
 326     (define-key map "\eO2l" [S-kp-separator])
 327     (define-key map "\eO2m" [S-kp-subtract])
 328     (define-key map "\eO2o" [S-kp-divide])
 329     (define-key map "\eO2p" [S-kp-0])
 330     (define-key map "\eO2q" [S-kp-1])
 331     (define-key map "\eO2r" [S-kp-2])
 332     (define-key map "\eO2s" [S-kp-3])
 333     (define-key map "\eO2t" [S-kp-4])
 334     (define-key map "\eO2u" [S-kp-5])
 335     (define-key map "\eO2v" [S-kp-6])
 336     (define-key map "\eO2w" [S-kp-7])
 337     (define-key map "\eO2x" [S-kp-8])
 338     (define-key map "\eO2y" [S-kp-9])
 339
 340     (define-key map "\eO4j" [M-S-kp-multiply])
 341     (define-key map "\eO4k" [M-S-kp-add])
 342     (define-key map "\eO4l" [M-S-kp-separator])
 343     (define-key map "\eO4m" [M-S-kp-subtract])
 344     (define-key map "\eO4o" [M-S-kp-divide])
 345     (define-key map "\eO4p" [M-S-kp-0])
 346     (define-key map "\eO4q" [M-S-kp-1])
 347     (define-key map "\eO4r" [M-S-kp-2])
 348     (define-key map "\eO4s" [M-S-kp-3])
 349     (define-key map "\eO4t" [M-S-kp-4])
 350     (define-key map "\eO4u" [M-S-kp-5])
 351     (define-key map "\eO4v" [M-S-kp-6])
 352     (define-key map "\eO4w" [M-S-kp-7])
 353     (define-key map "\eO4x" [M-S-kp-8])
 354     (define-key map "\eO4y" [M-S-kp-9])
 355
 356     (define-key map "\eO6j" [C-S-kp-multiply])
 357     (define-key map "\eO6k" [C-S-kp-add])
 358     (define-key map "\eO6l" [C-S-kp-separator])
 359     (define-key map "\eO6m" [C-S-kp-subtract])
 360     (define-key map "\eO6o" [C-S-kp-divide])
 361     (define-key map "\eO6p" [C-S-kp-0])
 362     (define-key map "\eO6q" [C-S-kp-1])
 363     (define-key map "\eO6r" [C-S-kp-2])
 364     (define-key map "\eO6s" [C-S-kp-3])
 365     (define-key map "\eO6t" [C-S-kp-4])
 366     (define-key map "\eO6u" [C-S-kp-5])
 367     (define-key map "\eO6v" [C-S-kp-6])
 368     (define-key map "\eO6w" [C-S-kp-7])
 369     (define-key map "\eO6x" [C-S-kp-8])
 370     (define-key map "\eO6y" [C-S-kp-9])
 371
 372     (define-key map "\eO8j" [C-M-S-kp-multiply])
 373     (define-key map "\eO8k" [C-M-S-kp-add])
 374     (define-key map "\eO8l" [C-M-S-kp-separator])
 375     (define-key map "\eO8m" [C-M-S-kp-subtract])
 376     (define-key map "\eO8o" [C-M-S-kp-divide])
 377     (define-key map "\eO8p" [C-M-S-kp-0])
 378     (define-key map "\eO8q" [C-M-S-kp-1])
 379     (define-key map "\eO8r" [C-M-S-kp-2])
 380     (define-key map "\eO8s" [C-M-S-kp-3])
 381     (define-key map "\eO8t" [C-M-S-kp-4])
 382     (define-key map "\eO8u" [C-M-S-kp-5])
 383     (define-key map "\eO8v" [C-M-S-kp-6])
 384     (define-key map "\eO8w" [C-M-S-kp-7])
 385     (define-key map "\eO8x" [C-M-S-kp-8])
 386     (define-key map "\eO8y" [C-M-S-kp-9])
 387
 388     ;; These keys are available in xterm starting from version 216
 389     ;; if the modifyOtherKeys resource is set to 1.
 390     (dolist (bind '((5 9   [C-tab])
 391                     (5 13  [C-return])
 392                     (5 39  [?\C-\'])
 393                     (5 44  [?\C-,])
 394                     (5 45  [?\C--])
 395                     (5 46  [?\C-.])
 396                     (5 47  [?\C-/])
 397                     (5 48  [?\C-0])
 398                     (5 49  [?\C-1])
 399                     ;; Not all C-DIGIT keys have a distinct binding.
 400                     (5 57  [?\C-9])
 401                     (5 59  [?\C-\;])
 402                     (5 61  [?\C-=])
 403                     (5 92  [?\C-\\])
 404
 405                     (6 33  [?\C-!])
 406                     (6 34  [?\C-\"])
 407                     (6 35  [?\C-#])
 408                     (6 36  [?\C-$])
 409                     (6 37  [?\C-%])
 410                     (6 38  [?\C-&])
 411                     (6 40  [?\C-\(])
 412                     (6 41  [?\C-\)])
 413                     (6 42  [?\C-*])
 414                     (6 43  [?\C-+])
 415                     (6 58  [?\C-:])
 416                     (6 60  [?\C-<])
 417                     (6 62  [?\C->])
 418                     (6 63  [(control ??)])
 419
 420                     ;; These are the strings emitted for various C-M-
 421                     ;; combinations for keyboards whose Meta and Alt
 422                     ;; modifiers are on the same key (usually labeled "Alt").
 423                     (13 9  [C-M-tab])
 424                     (13 13 [C-M-return])
 425
 426                     (13 39 [?\C-\M-\'])
 427                     (13 44 [?\C-\M-,])
 428                     (13 45 [?\C-\M--])
 429                     (13 46 [?\C-\M-.])
 430                     (13 47 [?\C-\M-/])
 431                     (13 48 [?\C-\M-0])
 432                     (13 49 [?\C-\M-1])
 433                     (13 50 [?\C-\M-2])
 434                     (13 51 [?\C-\M-3])
 435                     (13 52 [?\C-\M-4])
 436                     (13 53 [?\C-\M-5])
 437                     (13 54 [?\C-\M-6])
 438                     (13 55 [?\C-\M-7])
 439                     (13 56 [?\C-\M-8])
 440                     (13 57 [?\C-\M-9])
 441                     (13 59 [?\C-\M-\;])
 442                     (13 61 [?\C-\M-=])
 443                     (13 92 [?\C-\M-\\])
 444
 445                     (14 33  [?\C-\M-!])
 446                     (14 34  [?\C-\M-\"])
 447                     (14 35  [?\C-\M-#])
 448                     (14 36  [?\C-\M-$])
 449                     (14 37  [?\C-\M-%])
 450                     (14 38  [?\C-\M-&])
 451                     (14 40  [?\C-\M-\(])
 452                     (14 41  [?\C-\M-\)])
 453                     (14 42  [?\C-\M-*])
 454                     (14 43  [?\C-\M-+])
 455                     (14 58  [?\C-\M-:])
 456                     (14 60  [?\C-\M-<])
 457                     (14 62  [?\C-\M->])
 458                     (14 63  [(control meta ??)])
 459
 460                     (7 9  [C-M-tab])
 461                     (7 13 [C-M-return])
 462
 463                     (7 32 [?\C-\M-\s])
 464                     (7 39 [?\C-\M-\'])
 465                     (7 44 [?\C-\M-,])
 466                     (7 45 [?\C-\M--])
 467                     (7 46 [?\C-\M-.])
 468                     (7 47 [?\C-\M-/])
 469                     (7 48 [?\C-\M-0])
 470                     (7 49 [?\C-\M-1])
 471                     (7 50 [?\C-\M-2])
 472                     (7 51 [?\C-\M-3])
 473                     (7 52 [?\C-\M-4])
 474                     (7 53 [?\C-\M-5])
 475                     (7 54 [?\C-\M-6])
 476                     (7 55 [?\C-\M-7])
 477                     (7 56 [?\C-\M-8])
 478                     (7 57 [?\C-\M-9])
 479                     (7 59 [?\C-\M-\;])
 480                     (7 61 [?\C-\M-=])
 481                     (7 92 [?\C-\M-\\])
 482
 483                     (8 33  [?\C-\M-!])
 484                     (8 34  [?\C-\M-\"])
 485                     (8 35  [?\C-\M-#])
 486                     (8 36  [?\C-\M-$])
 487                     (8 37  [?\C-\M-%])
 488                     (8 38  [?\C-\M-&])
 489                     (8 40  [?\C-\M-\(])
 490                     (8 41  [?\C-\M-\)])
 491                     (8 42  [?\C-\M-*])
 492                     (8 43  [?\C-\M-+])
 493                     (8 58  [?\C-\M-:])
 494                     (8 60  [?\C-\M-<])
 495                     (8 62  [?\C-\M->])
 496                     (8 63  [(control meta ??)])
 497
 498                     (2 9   [S-tab])
 499                     (2 13  [S-return])
 500
 501                     (6 9   [C-S-tab])
 502                     (6 13  [C-S-return])))
 503       (define-key map
 504         (format "\e[27;%d;%d~" (nth 0 bind) (nth 1 bind)) (nth 2 bind))
 505       ;; For formatOtherKeys=1, the sequence is a bit shorter (bug#13839).
 506       (define-key map
 507         (format "\e[%d;%du" (nth 1 bind) (nth 0 bind)) (nth 2 bind)))
 508
 509     ;; Other versions of xterm might emit these.
 510     (define-key map "\e[1~" [home])
 511
 512     (define-key map "\eO2A" [S-up])
 513     (define-key map "\eO2B" [S-down])
 514     (define-key map "\eO2C" [S-right])
 515     (define-key map "\eO2D" [S-left])
 516     (define-key map "\eO2F" [S-end])
 517     (define-key map "\eO2H" [S-home])
 518
 519     (define-key map "\eO5A" [C-up])
 520     (define-key map "\eO5B" [C-down])
 521     (define-key map "\eO5C" [C-right])
 522     (define-key map "\eO5D" [C-left])
 523     (define-key map "\eO5F" [C-end])
 524     (define-key map "\eO5H" [C-home])
 525
 526     map)
 527   "Function key map overrides for xterm.")
 528
 529 (defvar xterm-alternatives-map
 530   (let ((map (make-sparse-keymap)))
 531     ;; The terminal initialization C code file might have initialized
 532     ;; function keys F13->F60 from the termcap/terminfo information.
 533     ;; On a PC-style keyboard these keys correspond to
 534     ;; MODIFIER-FUNCTION_KEY, where modifier is S-, C, A-, C-S-.  The code
 535     ;; here substitutes the corresponding definitions in function-key-map.
 536     ;; The mapping from escape sequences to Fn is done in input-decode-map
 537     ;; whereas this here mapping is done in local-function-key-map so that
 538     ;; bindings to f45 still work, in case your keyboard really has an f45
 539     ;; key rather than C-S-f9.
 540     (define-key map [f13] [S-f1])
 541     (define-key map [f14] [S-f2])
 542     (define-key map [f15] [S-f3])
 543     (define-key map [f16] [S-f4])
 544     (define-key map [f17] [S-f5])
 545     (define-key map [f18] [S-f6])
 546     (define-key map [f19] [S-f7])
 547     (define-key map [f20] [S-f8])
 548     (define-key map [f21] [S-f9])
 549     (define-key map [f22] [S-f10])
 550     (define-key map [f23] [S-f11])
 551     (define-key map [f24] [S-f12])
 552
 553     (define-key map [f25] [C-f1])
 554     (define-key map [f26] [C-f2])
 555     (define-key map [f27] [C-f3])
 556     (define-key map [f28] [C-f4])
 557     (define-key map [f29] [C-f5])
 558     (define-key map [f30] [C-f6])
 559     (define-key map [f31] [C-f7])
 560     (define-key map [f32] [C-f8])
 561     (define-key map [f33] [C-f9])
 562     (define-key map [f34] [C-f10])
 563     (define-key map [f35] [C-f11])
 564     (define-key map [f36] [C-f12])
 565
 566     (define-key map [f37] [C-S-f1])
 567     (define-key map [f38] [C-S-f2])
 568     (define-key map [f39] [C-S-f3])
 569     (define-key map [f40] [C-S-f4])
 570     (define-key map [f41] [C-S-f5])
 571     (define-key map [f42] [C-S-f6])
 572     (define-key map [f43] [C-S-f7])
 573     (define-key map [f44] [C-S-f8])
 574     (define-key map [f45] [C-S-f9])
 575     (define-key map [f46] [C-S-f10])
 576     (define-key map [f47] [C-S-f11])
 577     (define-key map [f48] [C-S-f12])
 578
 579     (define-key map [f49] [M-f1])
 580     (define-key map [f50] [M-f2])
 581     (define-key map [f51] [M-f3])
 582     (define-key map [f52] [M-f4])
 583     (define-key map [f53] [M-f5])
 584     (define-key map [f54] [M-f6])
 585     (define-key map [f55] [M-f7])
 586     (define-key map [f56] [M-f8])
 587     (define-key map [f57] [M-f9])
 588     (define-key map [f58] [M-f10])
 589     (define-key map [f59] [M-f11])
 590     (define-key map [f60] [M-f12])
 591
 592     map)
 593   "Keymap of possible alternative meanings for some keys.")
 594
 595 ;; Set up colors, for those versions of xterm that support it.
 596 (defvar xterm-standard-colors
 597   ;; The names in the comments taken from XTerm-col.ad in the xterm
 598   ;; distribution, see ftp://dickey.his.com/xterm/.  RGB values are
 599   ;; from rgb.txt.
 600   '(("black"          0 (  0   0   0))  ; black
 601     ("red"            1 (205   0   0))  ; red3
 602     ("green"          2 (  0 205   0))  ; green3
 603     ("yellow"         3 (205 205   0))  ; yellow3
 604     ("blue"           4 (  0   0 238))  ; blue2
 605     ("magenta"        5 (205   0 205))  ; magenta3
 606     ("cyan"           6 (  0 205 205))  ; cyan3
 607     ("white"          7 (229 229 229))  ; gray90
 608     ("brightblack"    8 (127 127 127))  ; gray50
 609     ("brightred"      9 (255   0   0))  ; red
 610     ("brightgreen"   10 (  0 255   0))  ; green
 611     ("brightyellow"  11 (255 255   0))  ; yellow
 612     ("brightblue"    12 (92   92 255))  ; rgb:5c/5c/ff
 613     ("brightmagenta" 13 (255   0 255))  ; magenta
 614     ("brightcyan"    14 (  0 255 255))  ; cyan
 615     ("brightwhite"   15 (255 255 255))) ; white
 616   "Names of 16 standard xterm/aixterm colors, their numbers, and RGB values.")
 617
 618 (defun xterm--report-background-handler ()
 619   (let ((str "")
 620         chr)
 621     ;; The reply should be: \e ] 11 ; rgb: NUMBER1 / NUMBER2 / NUMBER3 \e \\
 622     (while (and (setq chr (read-event nil nil 2)) (not (equal chr ?\\)))
 623       (setq str (concat str (string chr))))
 624     (when (string-match
 625            "rgb:\\([a-f0-9]+\\)/\\([a-f0-9]+\\)/\\([a-f0-9]+\\)" str)
 626       (let ((recompute-faces
 627              (xterm-maybe-set-dark-background-mode
 628               (string-to-number (match-string 1 str) 16)
 629               (string-to-number (match-string 2 str) 16)
 630               (string-to-number (match-string 3 str) 16))))
 631
 632         ;; Recompute faces here in case the background mode was
 633         ;; set to dark.  We used to call
 634         ;; `tty-set-up-initial-frame-faces' only once, but that
 635         ;; caused the light background faces to be computed
 636         ;; incorrectly.  See:
 637         ;; http://permalink.gmane.org/gmane.emacs.devel/119627
 638         (when recompute-faces
 639           (tty-set-up-initial-frame-faces))))))
 640
 641 (defun xterm--version-handler ()
 642   (let ((str "")
 643         chr)
 644     ;; The reply should be: \e [ > NUMBER1 ; NUMBER2 ; NUMBER3 c
 645     ;; If the timeout is completely removed for read-event, this
 646     ;; might hang for terminals that pretend to be xterm, but don't
 647     ;; respond to this escape sequence.  RMS' opinion was to remove
 648     ;; it completely.  That might be right, but let's first try to
 649     ;; see if by using a longer timeout we get rid of most issues.
 650     (while (and (setq chr (read-event nil nil 2)) (not (equal chr ?c)))
 651       (setq str (concat str (string chr))))
 652     ;; Since xterm-280, the terminal type (NUMBER1) is now 41 instead of 0.
 653     (when (string-match "\\([0-9]+\\);\\([0-9]+\\);0" str)
 654       (let ((version (string-to-number (match-string 2 str))))
 655         (when (and (> version 2000) (equal (match-string 1 str) "1"))
 656           ;; Hack attack!  bug#16988: gnome-terminal reports "1;NNNN;0"
 657           ;; with a large NNNN but is based on a rather old xterm code.
 658           ;; Gnome terminal 3.6.1 reports 1;3406;0
 659           ;; Gnome terminal 2.32.1 reports 1;2802;0
 660           (setq version 200))
 661         (when (equal (match-string 1 str) "83")
 662           ;; `screen' (which returns 83;40003;0) seems to also lack support for
 663           ;; some of these (bug#17607, bug#20356).
 664           ;; Note: this code path should normally not be used any more
 665           ;; since term/screen.el now binds xterm-extra-capabilities
 666           ;; to a fixed value, rather than using the dynamic checking.
 667           (setq version 200))
 668         ;; If version is 242 or higher, assume the xterm supports
 669         ;; reporting the background color (TODO: maybe earlier
 670         ;; versions do too...)
 671         (when (>= version 242)
 672           (xterm--query "\e]11;?\e\\"
 673                         '(("\e]11;" .  xterm--report-background-handler))))
 674
 675         ;; If version is 216 (the version when modifyOtherKeys was
 676         ;; introduced) or higher, initialize the
 677         ;; modifyOtherKeys support.
 678         (when (>= version 216)
 679           (xterm--init-modify-other-keys))
 680         ;; In version 203 support for accessing the X selection was
 681         ;; added.  Hterm reports itself as version 256 and supports it
 682         ;; as well.  gnome-terminal doesn't and is excluded by this
 683         ;; test.
 684         (when (>= version 203)
 685           ;; Most xterms seem to have it disabled by default, and if it's
 686           ;; disabled, C-y will incur a timeout, so we only use it if the user
 687           ;; explicitly requests it.
 688           ;;(xterm--init-activate-get-selection)
 689           (xterm--init-activate-set-selection))))))
 690
 691 (defvar xterm-query-timeout 2
 692   "Seconds to wait for an answer from the terminal.
 693 Can be nil to mean \"no timeout\".")
 694
 695 (defun xterm--query (query handlers &optional no-async)
 696   "Send QUERY string to the terminal and watch for a response.
 697 HANDLERS is an alist with elements of the form (STRING . FUNCTION).
 698 We run the first FUNCTION whose STRING matches the input events."
 699   ;; We used to query synchronously, but the need to use `discard-input' is
 700   ;; rather annoying (bug#6758).  Maybe we could always use the asynchronous
 701   ;; approach, but it's less tested.
 702   ;; FIXME: Merge the two branches.
 703   (let ((register
 704          (lambda (handlers)
 705            (dolist (handler handlers)
 706              (define-key input-decode-map (car handler)
 707                (lambda (&optional _prompt)
 708                  ;; Unregister the handler, since we don't expect
 709                  ;; further answers.
 710                  (dolist (handler handlers)
 711                    (define-key input-decode-map (car handler) nil))
 712                  (funcall (cdr handler))
 713                  []))))))
 714     (if (and (or (null xterm-query-timeout) (input-pending-p))
 715              (not no-async))
 716         (progn
 717           (funcall register handlers)
 718           (send-string-to-terminal query))
 719       ;; Pending input can be mistakenly returned by the calls to
 720       ;; read-event below: discard it.
 721       (discard-input)
 722       (send-string-to-terminal query)
 723       (while handlers
 724         (let ((handler (pop handlers))
 725               (i 0))
 726           (while (and (< i (length (car handler)))
 727                       (let ((evt (read-event nil nil xterm-query-timeout)))
 728                         (if (and (null evt) (= i 0) (not no-async))
 729                             ;; Timeout on the first event: fallback on async.
 730                             (progn
 731                               (funcall register (cons handler handlers))
 732                               (setq handlers nil)
 733                               nil)
 734                           (or (eq evt (aref (car handler) i))
 735                               (progn (if evt (push evt unread-command-events))
 736                                      nil))))
 737                       (setq i (1+ i)))
 738             (if (= i (length (car handler)))
 739                 (progn (setq handlers nil)
 740                        (funcall (cdr handler)))
 741               (while (> i 0)
 742                 (push (aref (car handler) (setq i (1- i)))
 743                       unread-command-events)))))))))
 744
 745 (defun xterm--push-map (map basemap)
 746   ;; Use inheritance to let the main keymaps override those defaults.
 747   ;; This way we don't override terminfo-derived settings or settings
 748   ;; made in the init file.
 749   (set-keymap-parent
 750    basemap
 751    (make-composed-keymap map (keymap-parent basemap))))
 752
 753 (defun terminal-init-xterm ()
 754   "Terminal initialization function for xterm."
 755   ;; rxvt terminals sometimes set the TERM variable to "xterm", but
 756   ;; rxvt's keybindings are incompatible with xterm's. It is
 757   ;; better in that case to use rxvt's initialization function.
 758   (if (and (getenv "COLORTERM" (selected-frame))
 759            (string-match "\\`rxvt" (getenv "COLORTERM" (selected-frame))))
 760       (tty-run-terminal-initialization (selected-frame) "rxvt")
 761
 762       (xterm--push-map xterm-alternatives-map local-function-key-map)
 763       (xterm--push-map xterm-function-map     input-decode-map))
 764
 765   (xterm-register-default-colors xterm-standard-colors)
 766   (tty-set-up-initial-frame-faces)
 767
 768   (if (eq xterm-extra-capabilities 'check)
 769       ;; Try to find out the type of terminal by sending a "Secondary
 770       ;; Device Attributes (DA)" query.
 771       (xterm--query "\e[>0c"
 772                     ;; Some terminals (like OS X's Terminal.app) respond to
 773                     ;; this query as if it were a "Primary Device Attributes"
 774                     ;; query instead, so we should handle that too.
 775                     '(("\e[?" . xterm--version-handler)
 776                       ("\e[>" . xterm--version-handler)))
 777
 778     (when (memq 'reportBackground xterm-extra-capabilities)
 779       (xterm--query "\e]11;?\e\\"
 780                     '(("\e]11;" .  xterm--report-background-handler))))
 781
 782     (when (memq 'modifyOtherKeys xterm-extra-capabilities)
 783       (xterm--init-modify-other-keys))
 784
 785     (when (memq 'getSelection xterm-extra-capabilities)
 786       (xterm--init-activate-get-selection))
 787     (when (memq 'setSelection xterm-extra-capabilities)
 788       (xterm--init-activate-set-selection)))
 789
 790   ;; Unconditionally enable bracketed paste mode: terminals that don't
 791   ;; support it just ignore the sequence.
 792   (xterm--init-bracketed-paste-mode)
 793
 794   (run-hooks 'terminal-init-xterm-hook))
 795
 796 (defun xterm--init-modify-other-keys ()
 797   "Terminal initialization for xterm's modifyOtherKeys support."
 798   (send-string-to-terminal "\e[>4;1m")
 799   (push "\e[>4m" (terminal-parameter nil 'tty-mode-reset-strings))
 800   (push "\e[>4;1m" (terminal-parameter nil 'tty-mode-set-strings)))
 801
 802 (defun xterm--init-bracketed-paste-mode ()
 803   "Terminal initialization for bracketed paste mode."
 804   (send-string-to-terminal "\e[?2004h")
 805   (push "\e[?2004l" (terminal-parameter nil 'tty-mode-reset-strings))
 806   (push "\e[?2004h" (terminal-parameter nil 'tty-mode-set-strings)))
 807
 808 (defun xterm--init-activate-get-selection ()
 809   "Terminal initialization for `gui-get-selection'."
 810   (set-terminal-parameter nil 'xterm--get-selection t))
 811
 812 (defun xterm--init-activate-set-selection ()
 813   "Terminal initialization for `gui-set-selection'."
 814   (set-terminal-parameter nil 'xterm--set-selection t))
 815
 816 (defun xterm--selection-char (type)
 817   (pcase type
 818     ('PRIMARY "p")
 819     ('CLIPBOARD "c")
 820     (_ (error "Invalid selection type: %S" type))))
 821
 822 (cl-defmethod gui-backend-get-selection
 823     (type data-type
 824      &context (window-system (eql nil))
 825               ;; Only applies to terminals which have it enabled.
 826               ((terminal-parameter nil 'xterm--get-selection) (eql t)))
 827   (unless (eq data-type 'STRING)
 828     (error "Unsupported data type %S" data-type))
 829   (let* ((screen (eq (terminal-parameter nil 'terminal-initted)
 830                      'terminal-init-screen))
 831          (query (concat "\e]52;" (xterm--selection-char type) ";")))
 832     (with-temp-buffer
 833       (set-buffer-multibyte nil)
 834       (xterm--query
 835        (concat (when screen "\eP") query "?\a" (when screen "\e\\"))
 836        (list (cons query (lambda ()
 837                            (while (let ((char (read-char)))
 838                                     (unless (eq char ?\a)
 839                                       (insert char)
 840                                       t))))))
 841        'no-async)
 842       (base64-decode-region (point-min) (point-max))
 843       (decode-coding-region (point-min) (point-max) 'utf-8-unix t))))
 844
 845 (cl-defmethod gui-backend-set-selection
 846     (type data
 847      &context (window-system (eql nil))
 848               ;; Only applies to terminals which have it enabled.
 849               ((terminal-parameter nil 'xterm--set-selection) (eql t)))
 850   "Copy DATA to the X selection using the OSC 52 escape sequence.
 851
 852 TYPE specifies which selection to set; it must be either
 853 `PRIMARY' or `CLIPBOARD'.  DATA must be a string.
 854
 855 This can be used as a `gui-set-selection' method for
 856 xterm-compatible terminal emulators.  Then your system clipboard
 857 will be updated whenever you copy a region of text in Emacs.
 858
 859 If the resulting OSC 52 sequence would be longer than
 860 `xterm-max-cut-length', then the TEXT is not sent to the system
 861 clipboard.
 862
 863 This function either sends a raw OSC 52 sequence or wraps the OSC
 864 52 in a Device Control String sequence.  This way, it will work
 865 on a bare terminal emulators as well as inside the screen
 866 program.  When inside the screen program, this function also
 867 chops long DCS sequences into multiple smaller ones to avoid
 868 hitting screen's max DCS length."
 869   (let* ((screen (eq (terminal-parameter nil 'terminal-initted)
 870                      'terminal-init-screen))
 871          (bytes (encode-coding-string data 'utf-8-unix))
 872          (base-64 (if screen
 873                       (replace-regexp-in-string
 874                        "\n" "\e\\\eP"
 875                        (base64-encode-string bytes)
 876                        :fixedcase :literal)
 877                     (base64-encode-string bytes :no-line-break)))
 878          (length (length base-64)))
 879     (if (> length xterm-max-cut-length)
 880         (progn
 881           (warn "Selection too long to send to terminal: %d bytes" length)
 882           (sit-for 2))
 883       (send-string-to-terminal
 884        (concat
 885         (when screen "\eP")
 886         "\e]52;" (xterm--selection-char type) ";" base-64 "\a"
 887         (when screen "\e\\"))))))
 888
 889 (defun xterm-rgb-convert-to-16bit (prim)
 890   "Convert an 8-bit primary color value PRIM to a corresponding 16-bit value."
 891   (logior prim (lsh prim 8)))
 892
 893 (defun xterm-register-default-colors (colors)
 894   "Register the default set of colors for xterm or compatible emulator.
 895
 896 This function registers the number of colors returned by `display-color-cells'
 897 for the currently selected frame.  The first (16) colors are taken from
 898 COLORS, which see, while the rest are computed assuming
 899 either the 88- or 256-color standard color scheme supported by latest
 900 versions of xterm."
 901   (let* ((ncolors (display-color-cells))
 902          (color (car colors)))
 903     (if (> ncolors 0)
 904         ;; Clear the 8 default tty colors registered by startup.el
 905         (tty-color-clear))
 906     ;; Only register as many colors as are supported by the display.
 907     (while (and (> ncolors 0) colors)
 908       (tty-color-define (car color) (cadr color)
 909                         (mapcar #'xterm-rgb-convert-to-16bit
 910                                 (car (cddr color))))
 911       (setq colors (cdr colors)
 912             color (car colors)
 913             ncolors (1- ncolors)))
 914     ;; We've exhausted the colors from `colors'.  If there
 915     ;; are more colors to support, compute them now.
 916     (when (> ncolors 0)
 917       (cond
 918        ((= ncolors 240) ; 256-color xterm
 919         ;; 216 non-gray colors first
 920         (let ((r 0) (g 0) (b 0))
 921           (while (> ncolors 24)
 922             ;; This and other formulas taken from 256colres.pl and
 923             ;; 88colres.pl in the xterm distribution.
 924             (tty-color-define (format "color-%d" (- 256 ncolors))
 925                               (- 256 ncolors)
 926                               (mapcar #'xterm-rgb-convert-to-16bit
 927                                       (list (if (zerop r) 0 (+ (* r 40) 55))
 928                                             (if (zerop g) 0 (+ (* g 40) 55))
 929                                             (if (zerop b) 0 (+ (* b 40) 55)))))
 930
 931             (setq b (1+ b))
 932             (if (> b 5)
 933                 (setq g (1+ g)
 934                       b 0))
 935             (if (> g 5)
 936                 (setq r (1+ r)
 937                       g 0))
 938             (setq ncolors (1- ncolors))))
 939         ;; Now the 24 gray colors
 940         (while (> ncolors 0)
 941           (setq color (xterm-rgb-convert-to-16bit (+ 8 (* (- 24 ncolors) 10))))
 942           (tty-color-define (format "color-%d" (- 256 ncolors))
 943                             (- 256 ncolors)
 944                             (list color color color))
 945           (setq ncolors (1- ncolors))))
 946        ((= ncolors 72)  ; 88-color xterm
 947         ;; 64 non-gray colors
 948         (let ((levels '(0 139 205 255))
 949               (r 0) (g 0) (b 0))
 950           (while (> ncolors 8)
 951             (tty-color-define (format "color-%d" (- 88 ncolors))
 952                               (- 88 ncolors)
 953                               (mapcar #'xterm-rgb-convert-to-16bit
 954                                       (list (nth r levels)
 955                                             (nth g levels)
 956                                             (nth b levels))))
 957             (setq b (1+ b))
 958             (if (> b 3)
 959                 (setq g (1+ g)
 960                       b 0))
 961             (if (> g 3)
 962                 (setq r (1+ r)
 963                       g 0))
 964             (setq ncolors (1- ncolors))))
 965         ;; Now the 8 gray colors
 966         (while (> ncolors 0)
 967           (setq color (xterm-rgb-convert-to-16bit
 968                        (floor
 969                         (if (= ncolors 8)
 970                             46.36363636
 971                           (+ (* (- 8 ncolors) 23.18181818) 69.54545454)))))
 972           (tty-color-define (format "color-%d" (- 88 ncolors))
 973                             (- 88 ncolors)
 974                             (list color color color))
 975           (setq ncolors (1- ncolors))))
 976        (t (error "Unsupported number of xterm colors (%d)" (+ 16 ncolors)))))
 977     ;; Modifying color mappings means realized faces don't use the
 978     ;; right colors, so clear them.
 979     (clear-face-cache)))
 980
 981 (defun xterm-maybe-set-dark-background-mode (redc greenc bluec)
 982   ;; Use the heuristic in `frame-set-background-mode' to decide if a
 983   ;; frame is dark.
 984   (when (< (+ redc greenc bluec) (* .6 (+ 65535 65535 65535)))
 985     (set-terminal-parameter nil 'background-mode 'dark)
 986     t))
 987
 988 (provide 'xterm)                        ;Backward compatibility.
 989 (provide 'term/xterm)
 990 ;;; xterm.el ends here