lib/libcurses/keyname.c

   1 /*      $NetBSD: keyname.c,v 1.6 2008/04/28 20:23:01 martin Exp $       */
   2
   3 /*-
   4  * Copyright (c) 2003 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Julian Coleman.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 __RCSID("$NetBSD: keyname.c,v 1.6 2008/04/28 20:23:01 martin Exp $");
  35 #endif                          /* not lint */
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 #include "curses.h"
  41 #include "curses_private.h"
  42
  43 #define KEYNAMEMAX (size_t) 14  /* "KEY_BACKSPACE\0" */
  44 static char name[KEYNAMEMAX + 1];
  45
  46 /*
  47  * keyname --
  48  *      Return name of key or NULL;
  49  */
  50 char *
  51 keyname(int key)
  52 {
  53 /* We don't bother with the large keyname table if SMALL is defined. */
  54 #ifdef SMALL
  55         strcpy(name, "-1\0");
  56         return name;
  57 #else
  58         if (key < 0) {
  59                 strcpy(name, "-1\0");
  60                 return name;
  61         }
  62
  63         /* No name. */
  64         if (key == 0x100) {
  65                 strcpy(name, "-1\0");
  66                 return name;
  67         }
  68
  69         /* Control codes */
  70         if (key < 0x20) {
  71                 name[0] = '^';
  72                 name[1] = (char) (key + 64);    /* Offset of '@' */
  73                 name[2] = '\0';
  74                 return name;
  75         }
  76
  77         /* "Normal" keys */
  78         if (key < 0x7F) {
  79                 name[0] = (char) key;
  80                 name[1] = '\0';
  81                 return name;
  82         }
  83
  84         /* Delete key */
  85         if (key == 0x7F) {
  86                 strcpy(name, "^?\0");
  87                 return name;
  88         }
  89
  90         /* Meta + control codes */
  91         if (key < 0x9F) {
  92                 strcpy(name, "M-^");
  93                 name[3] = (char) (key - 64);    /* Offset of '@' */
  94                 name[4] = '\0';
  95                 return name;
  96         }
  97
  98         /* Meta + "normal" keys */
  99         if (key < 0xFF) {
 100                 strcpy (name, "M-");
 101                 name[2] = (char) (key - 128);
 102                 name[3] = '\0';
 103                 return name;
 104         }
 105
 106         /* Meta + delete key */
 107         if (key == 0xFF) {
 108                 strcpy(name, "M-^?\0");
 109                 return name;
 110         }
 111
 112         /* Key names.  Synchronise this with curses.h. */
 113         if (key == 0x101) {
 114                 strncpy(name, "KEY_BREAK\0", KEYNAMEMAX);
 115                 return name;
 116         }
 117         if (key == 0x102) {
 118                 strncpy(name, "KEY_DOWN\0", KEYNAMEMAX);
 119                 return name;
 120         }
 121         if (key == 0x103) {
 122                 strncpy(name, "KEY_UP\0", KEYNAMEMAX);
 123                 return name;
 124         }
 125         if (key == 0x104) {
 126                 strncpy(name, "KEY_LEFT\0", KEYNAMEMAX);
 127                 return name;
 128         }
 129         if (key == 0x105) {
 130                 strncpy(name, "KEY_RIGHT\0", KEYNAMEMAX);
 131                 return name;
 132         }
 133         if (key == 0x106) {
 134                 strncpy(name, "KEY_HOME\0", KEYNAMEMAX);
 135                 return name;
 136         }
 137         if (key == 0x107) {
 138                 strncpy(name, "KEY_BACKSPACE\0", KEYNAMEMAX);
 139                 return name;
 140         }
 141         /* Function key block (64 keys). */
 142         if (key < 0x148) {
 143                 int i;
 144
 145                 strcpy(name, "KEY_F(");
 146                 i = snprintf(&name[6], (size_t) 3, "%d", key - 0x108);
 147                 name[6 + i] = ')';
 148                 name[7 + i] = '\0';
 149                 return name;
 150         }
 151         if (key == 0x148) {
 152                 strncpy(name, "KEY_DL\0", KEYNAMEMAX);
 153                 return name;
 154         }
 155         if (key == 0x149) {
 156                 strncpy(name, "KEY_IL\0", KEYNAMEMAX);
 157                 return name;
 158         }
 159         if (key == 0x14A) {
 160                 strncpy(name, "KEY_DC\0", KEYNAMEMAX);
 161                 return name;
 162         }
 163         if (key == 0x14B) {
 164                 strncpy(name, "KEY_IC\0", KEYNAMEMAX);
 165                 return name;
 166         }
 167         if (key == 0x14C) {
 168                 strncpy(name, "KEY_EIC\0", KEYNAMEMAX);
 169                 return name;
 170         }
 171         if (key == 0x14D) {
 172                 strncpy(name, "KEY_CLEAR\0", KEYNAMEMAX);
 173                 return name;
 174         }
 175         if (key == 0x14E) {
 176                 strncpy(name, "KEY_EOS\0", KEYNAMEMAX);
 177                 return name;
 178         }
 179         if (key == 0x14F) {
 180                 strncpy(name, "KEY_EOL\0", KEYNAMEMAX);
 181                 return name;
 182         }
 183         if (key == 0x150) {
 184                 strncpy(name, "KEY_SF\0", KEYNAMEMAX);
 185                 return name;
 186         }
 187         if (key == 0x151) {
 188                 strncpy(name, "KEY_SR\0", KEYNAMEMAX);
 189                 return name;
 190         }
 191         if (key == 0x152) {
 192                 strncpy(name, "KEY_NPAGE\0", KEYNAMEMAX);
 193                 return name;
 194         }
 195         if (key == 0x153) {
 196                 strncpy(name, "KEY_PPAGE\0", KEYNAMEMAX);
 197                 return name;
 198         }
 199         if (key == 0x154) {
 200                 strncpy(name, "KEY_STAB\0", KEYNAMEMAX);
 201                 return name;
 202         }
 203         if (key == 0x155) {
 204                 strncpy(name, "KEY_CTAB\0", KEYNAMEMAX);
 205                 return name;
 206         }
 207         if (key == 0x156) {
 208                 strncpy(name, "KEY_CATAB\0", KEYNAMEMAX);
 209                 return name;
 210         }
 211         if (key == 0x157) {
 212                 strncpy(name, "KEY_ENTER\0", KEYNAMEMAX);
 213                 return name;
 214         }
 215         if (key == 0x158) {
 216                 strncpy(name, "KEY_SRESET\0", KEYNAMEMAX);
 217                 return name;
 218         }
 219         if (key == 0x159) {
 220                 strncpy(name, "KEY_RESET\0", KEYNAMEMAX);
 221                 return name;
 222         }
 223         if (key == 0x15A) {
 224                 strncpy(name, "KEY_PRINT\0", KEYNAMEMAX);
 225                 return name;
 226         }
 227         if (key == 0x15B) {
 228                 strncpy(name, "KEY_LL\0", KEYNAMEMAX);
 229                 return name;
 230         }
 231         if (key == 0x15C) {
 232                 strncpy(name, "KEY_A1\0", KEYNAMEMAX);
 233                 return name;
 234         }
 235         if (key == 0x15D) {
 236                 strncpy(name, "KEY_A3\0", KEYNAMEMAX);
 237                 return name;
 238         }
 239         if (key == 0x15E) {
 240                 strncpy(name, "KEY_B2\0", KEYNAMEMAX);
 241                 return name;
 242         }
 243         if (key == 0x15F) {
 244                 strncpy(name, "KEY_C1\0", KEYNAMEMAX);
 245                 return name;
 246         }
 247         if (key == 0x160) {
 248                 strncpy(name, "KEY_C3\0", KEYNAMEMAX);
 249                 return name;
 250         }
 251         if (key == 0x161) {
 252                 strncpy(name, "KEY_BTAB\0", KEYNAMEMAX);
 253                 return name;
 254         }
 255         if (key == 0x162) {
 256                 strncpy(name, "KEY_BEG\0", KEYNAMEMAX);
 257                 return name;
 258         }
 259         if (key == 0x163) {
 260                 strncpy(name, "KEY_CANCEL\0", KEYNAMEMAX);
 261                 return name;
 262         }
 263         if (key == 0x164) {
 264                 strncpy(name, "KEY_CLOSE\0", KEYNAMEMAX);
 265                 return name;
 266         }
 267         if (key == 0x165) {
 268                 strncpy(name, "KEY_COMMAND\0", KEYNAMEMAX);
 269                 return name;
 270         }
 271         if (key == 0x166) {
 272                 strncpy(name, "KEY_COPY\0", KEYNAMEMAX);
 273                 return name;
 274         }
 275         if (key == 0x167) {
 276                 strncpy(name, "KEY_CREATE\0", KEYNAMEMAX);
 277                 return name;
 278         }
 279         if (key == 0x168) {
 280                 strncpy(name, "KEY_END\0", KEYNAMEMAX);
 281                 return name;
 282         }
 283         if (key == 0x169) {
 284                 strncpy(name, "KEY_EXIT\0", KEYNAMEMAX);
 285                 return name;
 286         }
 287         if (key == 0x16A) {
 288                 strncpy(name, "KEY_FIND\0", KEYNAMEMAX);
 289                 return name;
 290         }
 291         if (key == 0x16B) {
 292                 strncpy(name, "KEY_HELP\0", KEYNAMEMAX);
 293                 return name;
 294         }
 295         if (key == 0x16C) {
 296                 strncpy(name, "KEY_MARK\0", KEYNAMEMAX);
 297                 return name;
 298         }
 299         if (key == 0x16D) {
 300                 strncpy(name, "KEY_MESSAGE\0", KEYNAMEMAX);
 301                 return name;
 302         }
 303         if (key == 0x16E) {
 304                 strncpy(name, "KEY_MOVE\0", KEYNAMEMAX);
 305                 return name;
 306         }
 307         if (key == 0x16F) {
 308                 strncpy(name, "KEY_NEXT\0", KEYNAMEMAX);
 309                 return name;
 310         }
 311         if (key == 0x170) {
 312                 strncpy(name, "KEY_OPEN\0", KEYNAMEMAX);
 313                 return name;
 314         }
 315         if (key == 0x171) {
 316                 strncpy(name, "KEY_OPTIONS\0", KEYNAMEMAX);
 317                 return name;
 318         }
 319         if (key == 0x172) {
 320                 strncpy(name, "KEY_PREVIOUS\0", KEYNAMEMAX);
 321                 return name;
 322         }
 323         if (key == 0x173) {
 324                 strncpy(name, "KEY_REDO\0", KEYNAMEMAX);
 325                 return name;
 326         }
 327         if (key == 0x174) {
 328                 strncpy(name, "KEY_REFERENCE\0", KEYNAMEMAX);
 329                 return name;
 330         }
 331         if (key == 0x175) {
 332                 strncpy(name, "KEY_REFRESH\0", KEYNAMEMAX);
 333                 return name;
 334         }
 335         if (key == 0x176) {
 336                 strncpy(name, "KEY_REPLACE\0", KEYNAMEMAX);
 337                 return name;
 338         }
 339         if (key == 0x177) {
 340                 strncpy(name, "KEY_RESTART\0", KEYNAMEMAX);
 341                 return name;
 342         }
 343         if (key == 0x178) {
 344                 strncpy(name, "KEY_RESUME\0", KEYNAMEMAX);
 345                 return name;
 346         }
 347         if (key == 0x179) {
 348                 strncpy(name, "KEY_SAVE\0", KEYNAMEMAX);
 349                 return name;
 350         }
 351         if (key == 0x17A) {
 352                 strncpy(name, "KEY_SBEG\0", KEYNAMEMAX);
 353                 return name;
 354         }
 355         if (key == 0x17B) {
 356                 strncpy(name, "KEY_SCANCEL\0", KEYNAMEMAX);
 357                 return name;
 358         }
 359         if (key == 0x17C) {
 360                 strncpy(name, "KEY_SCOMMAND\0", KEYNAMEMAX);
 361                 return name;
 362         }
 363         if (key == 0x17D) {
 364                 strncpy(name, "KEY_SCOPY\0", KEYNAMEMAX);
 365                 return name;
 366         }
 367         if (key == 0x17E) {
 368                 strncpy(name, "KEY_SCREATE\0", KEYNAMEMAX);
 369                 return name;
 370         }
 371         if (key == 0x17F) {
 372                 strncpy(name, "KEY_SDC\0", KEYNAMEMAX);
 373                 return name;
 374         }
 375         if (key == 0x180) {
 376                 strncpy(name, "KEY_SDL\0", KEYNAMEMAX);
 377                 return name;
 378         }
 379         if (key == 0x181) {
 380                 strncpy(name, "KEY_SELECT\0", KEYNAMEMAX);
 381                 return name;
 382         }
 383         if (key == 0x182) {
 384                 strncpy(name, "KEY_SEND\0", KEYNAMEMAX);
 385                 return name;
 386         }
 387         if (key == 0x183) {
 388                 strncpy(name, "KEY_SEOL\0", KEYNAMEMAX);
 389                 return name;
 390         }
 391         if (key == 0x184) {
 392                 strncpy(name, "KEY_SEXIT\0", KEYNAMEMAX);
 393                 return name;
 394         }
 395         if (key == 0x185) {
 396                 strncpy(name, "KEY_SFIND\0", KEYNAMEMAX);
 397                 return name;
 398         }
 399         if (key == 0x186) {
 400                 strncpy(name, "KEY_SHELP\0", KEYNAMEMAX);
 401                 return name;
 402         }
 403         if (key == 0x187) {
 404                 strncpy(name, "KEY_SHOME\0", KEYNAMEMAX);
 405                 return name;
 406         }
 407         if (key == 0x188) {
 408                 strncpy(name, "KEY_SIC\0", KEYNAMEMAX);
 409                 return name;
 410         }
 411         if (key == 0x189) {
 412                 strncpy(name, "KEY_SLEFT\0", KEYNAMEMAX);
 413                 return name;
 414         }
 415         if (key == 0x18A) {
 416                 strncpy(name, "KEY_SMESSAGE\0", KEYNAMEMAX);
 417                 return name;
 418         }
 419         if (key == 0x18B) {
 420                 strncpy(name, "KEY_SMOVE\0", KEYNAMEMAX);
 421                 return name;
 422         }
 423         if (key == 0x18C) {
 424                 strncpy(name, "KEY_SNEXT\0", KEYNAMEMAX);
 425                 return name;
 426         }
 427         if (key == 0x18D) {
 428                 strncpy(name, "KEY_SOPTIONS\0", KEYNAMEMAX);
 429                 return name;
 430         }
 431         if (key == 0x18E) {
 432                 strncpy(name, "KEY_SPREVIOUS\0", KEYNAMEMAX);
 433                 return name;
 434         }
 435         if (key == 0x18F) {
 436                 strncpy(name, "KEY_SPRINT\0", KEYNAMEMAX);
 437                 return name;
 438         }
 439         if (key == 0x190) {
 440                 strncpy(name, "KEY_SREDO\0", KEYNAMEMAX);
 441                 return name;
 442         }
 443         if (key == 0x191) {
 444                 strncpy(name, "KEY_SREPLACE\0", KEYNAMEMAX);
 445                 return name;
 446         }
 447         if (key == 0x192) {
 448                 strncpy(name, "KEY_SRIGHT\0", KEYNAMEMAX);
 449                 return name;
 450         }
 451         if (key == 0x193) {
 452                 strncpy(name, "KEY_SRSUME\0", KEYNAMEMAX);
 453                 return name;
 454         }
 455         if (key == 0x194) {
 456                 strncpy(name, "KEY_SSAVE\0", KEYNAMEMAX);
 457                 return name;
 458         }
 459         if (key == 0x195) {
 460                 strncpy(name, "KEY_SSUSPEND\0", KEYNAMEMAX);
 461                 return name;
 462         }
 463         if (key == 0x196) {
 464                 strncpy(name, "KEY_SUNDO\0", KEYNAMEMAX);
 465                 return name;
 466         }
 467         if (key == 0x197) {
 468                 strncpy(name, "KEY_SUSPEND\0", KEYNAMEMAX);
 469                 return name;
 470         }
 471         if (key == 0x198) {
 472                 strncpy(name, "KEY_UNDO\0", KEYNAMEMAX);
 473                 return name;
 474         }
 475         if (key == 0x199) {
 476                 strncpy(name, "KEY_MOUSE\0", KEYNAMEMAX);
 477                 return name;
 478         }
 479         if (key == 0x200) {
 480                 strncpy(name, "KEY_RESIZE\0", KEYNAMEMAX);
 481                 return name;
 482         }
 483         /* No more names. */
 484         strncpy(name, "UNKOWN KEY\0", KEYNAMEMAX);
 485         return name;
 486 #endif
 487 }
 488 /*
 489  * key_name --
 490  *      Return name of key or NULL;
 491  */
 492 char *
 493 key_name(wchar_t key)
 494 {
 495 #ifndef HAVE_WCHAR
 496         return NULL;
 497 #else
 498         (void) keyname((int) key);
 499
 500         if (!strncmp(name, "M-", 2)) {
 501                 /* Remove the "M-" */
 502                 name[0] = name[2];
 503                 name[1] = '\0';
 504         }
 505         return name;
 506 #endif /* HAVE_WCHAR */
 507 }
 508