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