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