alpine/keymenu.c

   1 #if !defined(lint) && !defined(DOS)
   2 static char rcsid[] = "$Id: keymenu.c 1074 2008-06-04 00:08:43Z hubert@u.washington.edu $";
   3 #endif
   4
   5 /*
   6  * ========================================================================
   7  * Copyright 2013-2014 Eduardo Chappa
   8  * Copyright 2006-2008 University of Washington
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *     http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * ========================================================================
  17  */
  18
  19 #include "headers.h"
  20 #include "keymenu.h"
  21 #include "mailcmd.h"
  22 #include "signal.h"
  23 #include "status.h"
  24 #include "../pith/bitmap.h"
  25 #include "../pith/conf.h"
  26 #include "../pith/state.h"
  27
  28
  29 /*
  30  * We put all of the keymenu definitions here so that it is easy to
  31  * share them. The names are in keymenu.h, as well. Some of these
  32  * aren't easily shareable because we modify them dynamically but
  33  * here they are anyway. It's not altogether clear that this is a good idea.
  34  * Perhaps it would be better to just define the keymenus multiple times
  35  * in different source files even though they are the same, with static
  36  * declarations.
  37  *
  38  * The key numbers are sometimes used symbolically, like OTHER_KEY. Those
  39  * are in keymenu.h, too, and are hard to use. If you change a menu here
  40  * be sure to check those key numbers that go with it in keymenu.h.
  41  */
  42
  43 #ifdef _WINDOWS
  44 void configure_menu_items (struct key_menu *, bitmap_t);
  45 #endif
  46
  47
  48 /*
  49  * Macro to simplify instantiation of key_menu structs from key structs
  50  */
  51 #define INST_KEY_MENU(X, Y)     struct key_menu X = \
  52                                         {sizeof(Y)/(sizeof(Y[0])*12), 0, 0, Y}
  53
  54 struct key cancel_keys[] =
  55        {HELP_MENU,
  56         {"^C",N_("Cancel"),{MC_NONE},KS_NONE},
  57         NULL_MENU,
  58         NULL_MENU,
  59         NULL_MENU,
  60         NULL_MENU,
  61         NULL_MENU,
  62         NULL_MENU,
  63         NULL_MENU,
  64         NULL_MENU,
  65         NULL_MENU,
  66         NULL_MENU};
  67 INST_KEY_MENU(cancel_keymenu, cancel_keys);
  68
  69
  70 /*
  71  * A bunch of these are NULL_MENU because we want to change them dynamically.
  72  */
  73 struct key ab_keys[] =
  74        {HELP_MENU,
  75         NULL_MENU,
  76         NULL_MENU,
  77         NULL_MENU,
  78         /* TRANSLATORS: go to Previous Entry */
  79         {"P", N_("PrevEntry"), {MC_PREVITEM,1,{'p'}}, KS_NONE},
  80         /* TRANSLATORS: go to Next Entry */
  81         {"N", N_("NextEntry"), {MC_NEXTITEM,1,{'n'}}, KS_NONE},
  82         PREVPAGE_MENU,
  83         NEXTPAGE_MENU,
  84         NULL_MENU,
  85         NULL_MENU,
  86         NULL_MENU,
  87         WHEREIS_MENU,
  88
  89         HELP_MENU,
  90         OTHER_MENU,
  91         QUIT_MENU,
  92         NULL_MENU,
  93         LISTFLD_MENU,
  94         GOTO_MENU,
  95         INDEX_MENU,
  96         RCOMPOSE_MENU,
  97         PRYNTTXT_MENU,
  98         NULL_MENU,
  99         SAVE_MENU,
 100         FORWARD_MENU,
 101
 102         HELP_MENU,
 103         OTHER_MENU,
 104         /* TRANSLATORS: Select this Entry */
 105         {";",N_("Select"),{MC_SELECT,1,{';'}},KS_NONE},
 106         /* TRANSLATORS: Apply a command to several objects at once */
 107         {"A",N_("Apply"),{MC_APPLY,1,{'a'}},KS_APPLY},
 108         /* TRANSLATORS: Select Current entry */
 109         {":",N_("SelectCur"),{MC_SELCUR,1,{':'}},KS_SELECTCUR},
 110         /* TRANSLATORS: Zoom refers to zooming in on a smaller set of
 111            items, like with a camera zoom lense */
 112         {"Z",N_("ZoomMode"),{MC_ZOOM,1,{'z'}},KS_NONE},
 113         NULL_MENU,
 114         NULL_MENU,
 115         NULL_MENU,
 116         NULL_MENU,
 117         NULL_MENU,
 118         NULL_MENU,
 119         NULL_MENU};
 120 INST_KEY_MENU(ab_keymenu, ab_keys);
 121
 122
 123 struct key abook_select_keys[] =
 124        {HELP_MENU,
 125         NULL_MENU,
 126         {"E", N_("Exit"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 127         {"S", "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
 128         /* TRANSLATORS: go to Previous entry */
 129         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
 130         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
 131         PREVPAGE_MENU,
 132         NEXTPAGE_MENU,
 133         HOMEKEY_MENU,
 134         ENDKEY_MENU,
 135         NULL_MENU,
 136         WHEREIS_MENU};
 137 INST_KEY_MENU(abook_select_km, abook_select_keys);
 138
 139
 140 struct key abook_view_keys[] =
 141        {HELP_MENU,
 142         OTHER_MENU,
 143         /* TRANSLATORS: Abook is an abbreviation for Address Book */
 144         {"<",N_("Abook"),{MC_EXIT,2,{'<',','}},KS_NONE},
 145         {"U",N_("Update"),{MC_EDIT,1,{'u'}},KS_NONE},
 146         /* TRANSLATORS: ComposeTo means to start editing a new message to
 147             this address book entry */
 148         {"C",N_("ComposeTo"),{MC_COMPOSE,1,{'c'}},KS_COMPOSER},
 149         RCOMPOSE_MENU,
 150         PREVPAGE_MENU,
 151         NEXTPAGE_MENU,
 152         PRYNTTXT_MENU,
 153         WHEREIS_MENU,
 154         /* TRANSLATORS: abbreviation for Forward as Email */
 155         {"F", N_("Fwd Email"), {MC_FORWARD, 1, {'f'}}, KS_FORWARD},
 156         SAVE_MENU,
 157
 158         HELP_MENU,
 159         OTHER_MENU,
 160         /* TRANSLATORS: View the highlighted link, for example, a URL */
 161         {"V",N_("ViewLink"),{MC_VIEW_HANDLE,3,{'v',ctrl('m'),ctrl('j')}},KS_NONE},
 162         NULL_MENU,
 163         /* TRANSLATORS: go to the previous link, for example, the previous URL */
 164         {"^B",N_("PrevLink"),{MC_PREV_HANDLE,1,{ctrl('B')}},KS_NONE},
 165         {"^F",N_("NextLink"),{MC_NEXT_HANDLE,1,{ctrl('F')}},KS_NONE},
 166         NULL_MENU,
 167         NULL_MENU,
 168         NULL_MENU,
 169         NULL_MENU,
 170         NULL_MENU,
 171         NULL_MENU};
 172 INST_KEY_MENU(abook_view_keymenu, abook_view_keys);
 173
 174
 175 struct key abook_text_keys[] =
 176        {HELP_MENU,
 177         NULL_MENU,
 178         {"E",N_("Exit Viewer"),{MC_EXIT,1,{'e'}},KS_NONE},
 179         NULL_MENU,
 180         NULL_MENU,
 181         NULL_MENU,
 182         PREVPAGE_MENU,
 183         NEXTPAGE_MENU,
 184         PRYNTTXT_MENU,
 185         WHEREIS_MENU,
 186         FWDEMAIL_MENU,
 187         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE}};
 188 INST_KEY_MENU(abook_text_km, abook_text_keys);
 189
 190
 191 struct key ldap_view_keys[] =
 192        {HELP_MENU,
 193         OTHER_MENU,
 194         /* TRANSLATORS: go back to the index of results instead of
 195            viewing this particular entry */
 196         {"<",N_("Results Index"),{MC_EXIT,2,{'<',','}},KS_NONE},
 197         NULL_MENU,
 198         {"C", N_("ComposeTo"), {MC_COMPOSE,1,{'c'}}, KS_COMPOSER},
 199         RCOMPOSE_MENU,
 200         PREVPAGE_MENU,
 201         NEXTPAGE_MENU,
 202         PRYNTTXT_MENU,
 203         WHEREIS_MENU,
 204         FWDEMAIL_MENU,
 205         SAVE_MENU,
 206
 207         HELP_MENU,
 208         OTHER_MENU,
 209         {"V",N_("ViewLink"),{MC_VIEW_HANDLE,3,{'v',ctrl('m'),ctrl('j')}},KS_NONE},
 210         NULL_MENU,
 211         {"^B",N_("PrevLink"),{MC_PREV_HANDLE,1,{ctrl('B')}},KS_NONE},
 212         {"^F",N_("NextLink"),{MC_NEXT_HANDLE,1,{ctrl('F')}},KS_NONE},
 213         NULL_MENU,
 214         NULL_MENU,
 215         NULL_MENU,
 216         NULL_MENU,
 217         HOMEKEY_MENU,
 218         ENDKEY_MENU};
 219 INST_KEY_MENU(ldap_view_keymenu, ldap_view_keys);
 220
 221
 222 struct key context_mgr_keys[] =
 223        {HELP_MENU,
 224         OTHER_MENU,
 225         {"<", N_("Main Menu"), {MC_MAIN,3,{'m','<',','}}, KS_EXITMODE},
 226         /* TRANSLATORS: View this Collection of folders */
 227         {">", "[" N_("View Cltn") "]",
 228          {MC_CHOICE,5,{'v','>','.',ctrl('M'),ctrl('J')}}, KS_NONE},
 229         PREVC_MENU,
 230         NEXTC_MENU,
 231         PREVPAGE_MENU,
 232         NEXTPAGE_MENU,
 233         NULL_MENU,
 234         NULL_MENU,
 235         NULL_MENU,
 236         WHEREIS_MENU,
 237
 238         HELP_MENU,
 239         OTHER_MENU,
 240         QUIT_MENU,
 241         NULL_MENU,
 242         NULL_MENU,
 243         GOTO_MENU,
 244         CIND_MENU,
 245         COMPOSE_MENU,
 246         PRYNTTXT_MENU,
 247         RCOMPOSE_MENU,
 248         HOMEKEY_MENU,
 249         ENDKEY_MENU};
 250 INST_KEY_MENU(c_mgr_km, context_mgr_keys);
 251
 252
 253 struct key context_cfg_keys[] =
 254        {HELP_MENU,
 255         OTHER_MENU,
 256         {"E", N_("Exit Setup"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 257         {"C", "[" N_("Change") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
 258         PREVC_MENU,
 259         NEXTC_MENU,
 260         PREVPAGE_MENU,
 261         NEXTPAGE_MENU,
 262         /* TRANSLATORS; Add a Collection of folders */
 263         {"A", N_("Add Cltn"), {MC_ADD,1,{'a'}}, KS_NONE},
 264         DELC_MENU,
 265         /* TRANSLATORS; Change the order of items in a list */
 266         {"$", N_("Shuffle"), {MC_SHUFFLE,1,{'$'}},KS_NONE},
 267         WHEREIS_MENU,
 268
 269         HELP_MENU,
 270         OTHER_MENU,
 271         NULL_MENU,
 272         NULL_MENU,
 273         NULL_MENU,
 274         NULL_MENU,
 275         NULL_MENU,
 276         NULL_MENU,
 277         PRYNTTXT_MENU,
 278         NULL_MENU,
 279         HOMEKEY_MENU,
 280         ENDKEY_MENU};
 281 INST_KEY_MENU(c_cfg_km, context_cfg_keys);
 282
 283
 284 struct key context_select_keys[] =
 285        {HELP_MENU,
 286         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 287         NULL_MENU,
 288         /* TRANSLATORS: View this collection */
 289         {">", "[" N_("View Cltn") "]",
 290          {MC_CHOICE, 5, {'v','>','.',ctrl('M'),ctrl('J')}}, KS_NONE},
 291         PREVC_MENU,
 292         NEXTC_MENU,
 293         PREVPAGE_MENU,
 294         NEXTPAGE_MENU,
 295         HOMEKEY_MENU,
 296         ENDKEY_MENU,
 297         NULL_MENU,
 298         WHEREIS_MENU};
 299 INST_KEY_MENU(c_sel_km, context_select_keys);
 300
 301
 302 struct key context_fcc_keys[] =
 303        {HELP_MENU,
 304         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 305         NULL_MENU,
 306         {">", "[" N_("View Cltn") "]",
 307          {MC_CHOICE, 5, {'v','>','.',ctrl('M'),ctrl('J')}}, KS_NONE},
 308         PREVC_MENU,
 309         NEXTC_MENU,
 310         PREVPAGE_MENU,
 311         NEXTPAGE_MENU,
 312         HOMEKEY_MENU,
 313         ENDKEY_MENU,
 314         NULL_MENU,
 315         WHEREIS_MENU};
 316 INST_KEY_MENU(c_fcc_km, context_fcc_keys);
 317
 318 struct key folder_keys[] =
 319        {HELP_MENU,
 320         OTHER_MENU,
 321         {"<", NULL, {MC_EXIT,2,{'<',','}}, KS_NONE},
 322         {">", NULL, {MC_CHOICE,2,{'>','.'}}, KS_NONE},
 323         PREVF_MENU,
 324         NEXTF_MENU,
 325         PREVPAGE_MENU,
 326         NEXTPAGE_MENU,
 327         /* TRANSLATORS: make an addition, for example add a new folder
 328            or a new entry in an address book */
 329         {"A",N_("Add"),{MC_ADDFLDR,1,{'a'}},KS_NONE},
 330         DELETE_MENU,
 331         /* TRANSLATORS: change the name of something */
 332         {"R",N_("Rename"),{MC_RENAMEFLDR,1,{'r'}}, KS_NONE},
 333         WHEREIS_MENU,
 334
 335         HELP_MENU,
 336         OTHER_MENU,
 337         QUIT_MENU,
 338         MAIN_MENU,
 339         {"V", "[" N_("View Fldr") "]", {MC_OPENFLDR}, KS_NONE},
 340         GOTO_MENU,
 341         CIND_MENU,
 342         COMPOSE_MENU,
 343         {"%", N_("Print"), {MC_PRINTFLDR,1,{'%'}}, KS_PRINT},
 344         {"Z", N_("ZoomMode"), {MC_ZOOM,1,{'z'}}, KS_NONE},
 345         {";",N_("Select"),{MC_SELECT,1,{';'}},KS_SELECT},
 346         /* TRANSLATORS: Select current item */
 347         {":",N_("SelectCur"),{MC_SELCUR,1,{':'}},KS_SELECT},
 348
 349         HELP_MENU,
 350         OTHER_MENU,
 351         NULL_MENU,
 352         NULL_MENU,
 353         NULL_MENU,
 354         NULL_MENU,
 355         {"$", N_("Shuffle"), {MC_SHUFFLE,1,{'$'}},KS_NONE},
 356         RCOMPOSE_MENU,
 357         EXPORT_MENU,
 358         /* TRANSLATORS: Import refers to bringing something in from
 359            outside of alpine's normal world */
 360         {"U", N_("Import"), {MC_IMPORT,1,{'u'}},KS_NONE},
 361         HOMEKEY_MENU,
 362         ENDKEY_MENU};
 363 INST_KEY_MENU(folder_km, folder_keys);
 364
 365
 366 struct key folder_sel_keys[] =
 367        {HELP_MENU,
 368         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 369         NULL_MENU,
 370         {NULL, NULL, {MC_CHOICE,0}, KS_NONE},
 371         PREVF_MENU,
 372         NEXTF_MENU,
 373         PREVPAGE_MENU,
 374         NEXTPAGE_MENU,
 375         {"S", N_("Select"), {MC_OPENFLDR,1,{'s'}}, KS_NONE},
 376         NULL_MENU,
 377         NULL_MENU,
 378         WHEREIS_MENU,
 379
 380         HELP_MENU,
 381         OTHER_MENU,
 382         NULL_MENU,
 383         NULL_MENU,
 384         NULL_MENU,
 385         NULL_MENU,
 386         NULL_MENU,
 387         NULL_MENU,
 388         NULL_MENU,
 389         NULL_MENU,
 390         HOMEKEY_MENU,
 391         ENDKEY_MENU};
 392 INST_KEY_MENU(folder_sel_km, folder_sel_keys);
 393
 394
 395 struct key folder_sela_keys[] =
 396        {HELP_MENU,
 397         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 398         NULL_MENU,
 399         {NULL, NULL, {MC_CHOICE,0}, KS_NONE},
 400         PREVF_MENU,
 401         NEXTF_MENU,
 402         PREVPAGE_MENU,
 403         NEXTPAGE_MENU,
 404         {"S", N_("Select"), {MC_OPENFLDR,1,{'s'}}, KS_NONE},
 405         NULL_MENU,
 406         {"A", N_("AddNew"), {MC_ADD,1,{'a'}}, KS_NONE},
 407         WHEREIS_MENU,
 408
 409         HELP_MENU,
 410         OTHER_MENU,
 411         NULL_MENU,
 412         NULL_MENU,
 413         NULL_MENU,
 414         NULL_MENU,
 415         NULL_MENU,
 416         NULL_MENU,
 417         NULL_MENU,
 418         NULL_MENU,
 419         HOMEKEY_MENU,
 420         ENDKEY_MENU};
 421 INST_KEY_MENU(folder_sela_km, folder_sela_keys);
 422
 423
 424 struct key folder_sub_keys[] =
 425        {HELP_MENU,
 426         /* TRANSLATORS: Subscribe to a news group */
 427         {"S", N_("Subscribe"), {MC_CHOICE,1,{'s'}}, KS_NONE},
 428         /* TRANSLATORS: Exit Subscribe screen */
 429         {"E", N_("ExitSubscb"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 430         {NULL, "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
 431         PREVF_MENU,
 432         NEXTF_MENU,
 433         PREVPAGE_MENU,
 434         NEXTPAGE_MENU,
 435         /* TRANSLATORS: List Mode in alpine is where you can select not just
 436            one of something but you can select a whole list of something, for
 437            example a whole list of addresses to send to. */
 438         {"L", N_("List Mode"), {MC_LISTMODE, 1, {'l'}}, KS_NONE},
 439         NULL_MENU,
 440         NULL_MENU,
 441         WHEREIS_MENU,
 442
 443         HELP_MENU,
 444         OTHER_MENU,
 445         NULL_MENU,
 446         NULL_MENU,
 447         NULL_MENU,
 448         NULL_MENU,
 449         NULL_MENU,
 450         NULL_MENU,
 451         NULL_MENU,
 452         NULL_MENU,
 453         HOMEKEY_MENU,
 454         ENDKEY_MENU};
 455 INST_KEY_MENU(folder_sub_km, folder_sub_keys);
 456
 457
 458 struct key folder_post_keys[] =
 459        {HELP_MENU,
 460         NULL_MENU,
 461         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
 462         {"S", "[" N_("Select") "]", {MC_CHOICE, 3, {'s',ctrl('M'),ctrl('J')}}, KS_NONE},
 463         PREVF_MENU,
 464         NEXTF_MENU,
 465         PREVPAGE_MENU,
 466         NEXTPAGE_MENU,
 467         HOMEKEY_MENU,
 468         ENDKEY_MENU,
 469         NULL_MENU,
 470         WHEREIS_MENU};
 471 INST_KEY_MENU(folder_post_km, folder_post_keys);
 472
 473
 474 struct key help_keys[] =
 475        {MAIN_MENU,
 476         {NULL,NULL,{MC_EXIT,1,{'e'}}, KS_EXITMODE},
 477         {NULL,NULL,{MC_EXIT,1,{'e'}}, KS_EXITMODE},
 478         {NULL,NULL,{MC_VIEW_HANDLE,3,{'v',ctrl('m'),ctrl('j')}},KS_NONE},
 479         {"^B",N_("PrevLink"),{MC_PREV_HANDLE,1,{ctrl('B')}},KS_NONE},
 480         {"^F",N_("NextLink"),{MC_NEXT_HANDLE,1,{ctrl('F')}},KS_NONE},
 481         PREVPAGE_MENU,
 482         NEXTPAGE_MENU,
 483         PRYNTMSG_MENU,
 484         {"Z",N_("Print All"),{MC_PRINTALL,1,{'z'}},KS_NONE},
 485         {"N",N_("Name"),{MC_EXPORT,1,{'n'}},KS_NONE},
 486         WHEREIS_MENU,
 487
 488         HELP_MENU,
 489         OTHER_MENU,
 490         NULL_MENU,
 491         NULL_MENU,
 492         NULL_MENU,
 493         NULL_MENU,
 494         NULL_MENU,
 495         NULL_MENU,
 496         NULL_MENU,
 497         NULL_MENU,
 498         HOMEKEY_MENU,
 499         ENDKEY_MENU};
 500 INST_KEY_MENU(help_keymenu, help_keys);
 501
 502
 503 struct key rev_msg_keys[] =
 504        {HELP_MENU,
 505         OTHER_MENU,
 506         {"E",N_("Exit Viewer"),{MC_EXIT,1,{'e'}},KS_EXITMODE},
 507         NULL_MENU,
 508         {"T",NULL,{MC_TOGGLE,1,{'t'}},KS_NONE},
 509         {"D",NULL,{MC_JUMP,1,{'d'}},KS_NONE},
 510         PREVPAGE_MENU,
 511         NEXTPAGE_MENU,
 512         PRYNTTXT_MENU,
 513         WHEREIS_MENU,
 514         FWDEMAIL_MENU,
 515         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE},
 516
 517         HELP_MENU,
 518         OTHER_MENU,
 519         NULL_MENU,
 520         NULL_MENU,
 521         NULL_MENU,
 522         NULL_MENU,
 523         NULL_MENU,
 524         NULL_MENU,
 525         NULL_MENU,
 526         NULL_MENU,
 527         HOMEKEY_MENU,
 528         ENDKEY_MENU};
 529 INST_KEY_MENU(rev_msg_keymenu, rev_msg_keys);
 530
 531
 532 struct key ans_certfail_keys[] =
 533        {NULL_MENU,
 534         NULL_MENU,
 535         NULL_MENU,
 536         /* TRANSLATORS: Continue means to keep going. The user is paused to read
 537            something and has to tell us to continue when they are finished. */
 538         {"C","[" N_("Continue") "]",{MC_YES,3,{'c',ctrl('J'),ctrl('M')}},KS_NONE},
 539         NULL_MENU,
 540         NULL_MENU,
 541         PREVPAGE_MENU,
 542         NEXTPAGE_MENU,
 543         NULL_MENU,
 544         NULL_MENU,
 545         NULL_MENU,
 546         NULL_MENU};
 547 INST_KEY_MENU(ans_certfail_keymenu, ans_certfail_keys);
 548
 549
 550 struct key ans_certquery_keys[] =
 551        {HELP_MENU,
 552         NULL_MENU,
 553         {"Y",N_("Yes, continue"),{MC_YES,1,{'y'}},KS_NONE},
 554         {"D","[" N_("Details") "]",{MC_VIEW_HANDLE,3,{'d',ctrl('M'),ctrl('J')}},KS_NONE},
 555         {"N",N_("No"),{MC_NO,1,{'n'}},KS_NONE},
 556         NULL_MENU,
 557         PREVPAGE_MENU,
 558         NEXTPAGE_MENU,
 559         PRYNTTXT_MENU,
 560         WHEREIS_MENU,
 561         FWDEMAIL_MENU,
 562         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE}};
 563 INST_KEY_MENU(ans_certquery_keymenu, ans_certquery_keys);
 564
 565
 566 struct key forge_keys[] =
 567        {HELP_MENU,
 568         NULL_MENU,
 569         {"Y",N_("Yes, continue"),{MC_YES,1,{'y'}},KS_NONE},
 570         {"N",N_("No"),{MC_NO,1,{'n'}},KS_NONE},
 571         NULL_MENU,
 572         NULL_MENU,
 573         PREVPAGE_MENU,
 574         NEXTPAGE_MENU,
 575         PRYNTTXT_MENU,
 576         WHEREIS_MENU,
 577         FWDEMAIL_MENU,
 578         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE}};
 579 INST_KEY_MENU(forge_keymenu, forge_keys);
 580
 581
 582 struct key listmgr_keys[] =
 583        {HELP_MENU,
 584         NULL_MENU,
 585         /* TRANSLATORS: Exit Command List */
 586         {"E",N_("Exit CmdList"),{MC_EXIT,1,{'e'}},KS_EXITMODE},
 587         {"Ret","[" N_("Try Command") "]",{MC_VIEW_HANDLE,3,
 588                                 {ctrl('m'),ctrl('j'),KEY_RIGHT}},KS_NONE},
 589         /* TRANSLATORS: go to Previous Command in list */
 590         {"^B",N_("Prev Cmd"),{MC_PREV_HANDLE,1,{ctrl('B')}},KS_NONE},
 591         /* TRANSLATORS: go to Next Command in list */
 592         {"^F",N_("Next Cmd"),{MC_NEXT_HANDLE,1,{ctrl('F')}},KS_NONE},
 593         PREVPAGE_MENU,
 594         NEXTPAGE_MENU,
 595         PRYNTTXT_MENU,
 596         WHEREIS_MENU,
 597         HOMEKEY_MENU,
 598         ENDKEY_MENU};
 599 INST_KEY_MENU(listmgr_keymenu, listmgr_keys);
 600
 601
 602 struct key index_keys[] =
 603        {HELP_MENU,
 604         OTHER_MENU,
 605         {"<", NULL, {MC_FOLDERS,2,{'<',','}}, KS_NONE},
 606         VIEWMSG_MENU,
 607         PREVMSG_MENU,
 608         NEXTMSG_MENU,
 609         PREVPAGE_MENU,
 610         NEXTPAGE_MENU,
 611         DELETE_MENU,
 612         UNDELETE_MENU,
 613         REPLY_MENU,
 614         FORWARD_MENU,
 615
 616         HELP_MENU,
 617         OTHER_MENU,
 618         MAIN_MENU,
 619         QUIT_MENU,
 620         COMPOSE_MENU,
 621         GOTO_MENU,
 622         TAB_MENU,
 623         WHEREIS_MENU,
 624         PRYNTMSG_MENU,
 625         TAKE_MENU,
 626         SAVE_MENU,
 627         EXPORT_MENU,
 628
 629         HELP_MENU,
 630         OTHER_MENU,
 631         {"X",NULL,{MC_EXPUNGE,1,{'x'}},KS_NONE},
 632         /* TRANSLATORS: this stands for unexclude which is the opposite
 633            of the exclude command. Exclude eliminates some messages from
 634            the view and unexclude gets them back. */
 635         {"&",N_("unXclude"),{MC_UNEXCLUDE,1,{'&'}},KS_NONE},
 636         {";",N_("Select"),{MC_SELECT,1,{';'}},KS_SELECT},
 637         {"A",N_("Apply"),{MC_APPLY,1,{'a'}},KS_APPLY},
 638         FLDRSORT_MENU,
 639         JUMP_MENU,
 640         HDRMODE_MENU,
 641         BOUNCE_MENU,
 642         FLAG_MENU,
 643         PIPE_MENU,
 644
 645         HELP_MENU,
 646         OTHER_MENU,
 647         {":",N_("SelectCur"),{MC_SELCUR,1,{':'}},KS_SELECTCUR},
 648         {"Z",N_("ZoomMode"),{MC_ZOOM,1,{'z'}},KS_ZOOM},
 649         LISTFLD_MENU,
 650         RCOMPOSE_MENU,
 651         HOMEKEY_MENU,
 652         ENDKEY_MENU,
 653         NULL_MENU,
 654         /* TRANSLATORS: toggles a collapsed view or an expanded view
 655            of a message thread on and off */
 656         {"/",N_("Collapse/Expand"),{MC_COLLAPSE,1,{'/'}},KS_NONE},
 657         {"@", N_("Quota"), {MC_QUOTA,1,{'@'}}, KS_NONE},
 658         NULL_MENU};
 659 INST_KEY_MENU(index_keymenu, index_keys);
 660
 661
 662 struct key simple_index_keys[] =
 663        {HELP_MENU,
 664         {"E",N_("ExitSelect"),{MC_EXIT,1,{'e'}},KS_EXITMODE},
 665         NULL_MENU,
 666         {"S","[" N_("Select") "]",{MC_SELECT,3,{'s',ctrl('M'),ctrl('J')}},KS_SELECT},
 667         PREVMSG_MENU,
 668         NEXTMSG_MENU,
 669         PREVPAGE_MENU,
 670         NEXTPAGE_MENU,
 671         DELETE_MENU,
 672         UNDELETE_MENU,
 673         WHEREIS_MENU,
 674         NULL_MENU};
 675 INST_KEY_MENU(simple_index_keymenu, simple_index_keys);
 676
 677
 678 struct key thread_keys[] =
 679        {HELP_MENU,
 680         OTHER_MENU,
 681         /* TRANSLATORS: go to the Folder List */
 682         {"<", N_("FldrList"), {MC_FOLDERS,2,{'<',','}}, KS_NONE},
 683         /* TRANSLATORS: View a Thread of messages */
 684         {">", "[" N_("ViewThd") "]", {MC_VIEW_ENTRY,5,{'v','.','>',ctrl('M'),ctrl('J')}},
 685                                                                     KS_VIEW},
 686         /* TRANSLATORS: go to the Previous Thread */
 687         {"P", N_("PrevThd"), {MC_PREVITEM, 1, {'p'}}, KS_PREVMSG},
 688         /* TRANSLATORS: go to the Next Thread */
 689         {"N", N_("NextThd"), {MC_NEXTITEM, 1, {'n'}}, KS_NEXTMSG},
 690         PREVPAGE_MENU,
 691         NEXTPAGE_MENU,
 692         DELETE_MENU,
 693         UNDELETE_MENU,
 694         REPLY_MENU,
 695         FORWARD_MENU,
 696
 697         HELP_MENU,
 698         OTHER_MENU,
 699         MAIN_MENU,
 700         QUIT_MENU,
 701         COMPOSE_MENU,
 702         GOTO_MENU,
 703         TAB_MENU,
 704         WHEREIS_MENU,
 705         PRYNTMSG_MENU,
 706         TAKE_MENU,
 707         SAVE_MENU,
 708         EXPORT_MENU,
 709
 710         HELP_MENU,
 711         OTHER_MENU,
 712         {"X",NULL,{MC_EXPUNGE,1,{'x'}},KS_NONE},
 713         {"&",N_("unXclude"),{MC_UNEXCLUDE,1,{'&'}},KS_NONE},
 714         {";",N_("Select"),{MC_SELECT,1,{';'}},KS_SELECT},
 715         {"A",N_("Apply"),{MC_APPLY,1,{'a'}},KS_APPLY},
 716         FLDRSORT_MENU,
 717         JUMP_MENU,
 718         HDRMODE_MENU,
 719         BOUNCE_MENU,
 720         FLAG_MENU,
 721         PIPE_MENU,
 722
 723         HELP_MENU,
 724         OTHER_MENU,
 725         {":",N_("SelectCur"),{MC_SELCUR,1,{':'}},KS_SELECTCUR},
 726         {"Z",N_("ZoomMode"),{MC_ZOOM,1,{'z'}},KS_ZOOM},
 727         LISTFLD_MENU,
 728         RCOMPOSE_MENU,
 729         HOMEKEY_MENU,
 730         ENDKEY_MENU,
 731         NULL_MENU,
 732         {"/",N_("Collapse/Expand"),{MC_COLLAPSE,1,{'/'}},KS_NONE},
 733         {"@", N_("Quota"), {MC_QUOTA,1,{'@'}}, KS_NONE},
 734         NULL_MENU};
 735 INST_KEY_MENU(thread_keymenu, thread_keys);
 736
 737
 738 struct key att_index_keys[] =
 739        {HELP_MENU,
 740         OTHER_MENU,
 741         {"<",NULL,{MC_EXIT,2,{'<',','}},KS_EXITMODE},
 742         {">","[" N_("View") "]",{MC_VIEW_ATCH,5,{'v','>','.',ctrl('M'),ctrl('J')}},
 743           KS_VIEW},
 744         /* TRANSLATORS: go to Previous Attachment */
 745         {"P", N_("PrevAttch"),{MC_PREVITEM,4,{'p',ctrl('B'),ctrl('P'),KEY_UP}},
 746           KS_PREVMSG},
 747         /* TRANSLATORS: go to Next Attachment */
 748         {"N", N_("NextAtch"),
 749          {MC_NEXTITEM, 5, {'n','\t',ctrl('F'),ctrl('N'), KEY_DOWN}},
 750          KS_NEXTMSG},
 751         PREVPAGE_MENU,
 752         NEXTPAGE_MENU,
 753         DELETE_MENU,
 754         UNDELETE_MENU,
 755         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE},
 756         {NULL, NULL, {MC_EXPORT, 1, {'e'}}, KS_EXPORT},
 757
 758         HELP_MENU,
 759         OTHER_MENU,
 760         MAIN_MENU,
 761         QUIT_MENU,
 762         PIPE_MENU,
 763         BOUNCE_MENU,
 764         /* TRANSLATORS: About Attachment, a short description of the attachment */
 765         {"A",N_("AboutAttch"),{MC_ABOUTATCH,1,{'a'}},KS_NONE},
 766         WHEREIS_MENU,
 767         {"%", N_("Print"), {MC_PRINTMSG,1,{'%'}}, KS_PRINT},
 768         INDEX_MENU,
 769         REPLY_MENU,
 770         FORWARD_MENU,
 771
 772         HELP_MENU,
 773         OTHER_MENU,
 774         HDRMODE_MENU,
 775         NULL_MENU,
 776         NULL_MENU,
 777         NULL_MENU,
 778         NULL_MENU,
 779         NULL_MENU,
 780         NULL_MENU,
 781         NULL_MENU,
 782         NULL_MENU,
 783         NULL_MENU};
 784 INST_KEY_MENU(att_index_keymenu, att_index_keys);
 785
 786
 787 struct key att_view_keys[] =
 788        {HELP_MENU,
 789         OTHER_MENU,
 790         {"<",NULL,{MC_EXIT,2,{'<',','}},KS_EXITMODE},
 791         /* TRANSLATORS: View highlighted URL */
 792         {"Ret","[" N_("View Hilite") "]",{MC_VIEW_HANDLE,3,
 793                                 {ctrl('m'),ctrl('j'),KEY_RIGHT}},KS_NONE},
 794         /* TRANSLATORS: go to Previous URL */
 795         {"^B",N_("Prev URL"),{MC_PREV_HANDLE,1,{ctrl('B')}},KS_NONE},
 796         /* TRANSLATORS: go to Next URL */
 797         {"^F",N_("Next URL"),{MC_NEXT_HANDLE,1,{ctrl('F')}},KS_NONE},
 798         PREVPAGE_MENU,
 799         NEXTPAGE_MENU,
 800         DELETE_MENU,
 801         UNDELETE_MENU,
 802         SAVE_MENU,
 803         EXPORT_MENU,
 804
 805         HELP_MENU,
 806         OTHER_MENU,
 807         MAIN_MENU,
 808         QUIT_MENU,
 809         PIPE_MENU,
 810         BOUNCE_MENU,
 811         HDRMODE_MENU,
 812         WHEREIS_MENU,
 813         {"%", N_("Print"), {MC_PRINTMSG,1,{'%'}}, KS_PRINT},
 814         NULL_MENU,
 815         REPLY_MENU,
 816         FORWARD_MENU};
 817 INST_KEY_MENU(att_view_keymenu, att_view_keys);
 818
 819
 820 struct key view_keys[] =
 821        {HELP_MENU,
 822         OTHER_MENU,
 823         /* TRANSLATORS: go to Message Index */
 824         {"<",N_("MsgIndex"),{MC_INDEX,3,{'i','<',','}},KS_FLDRINDEX},
 825         /* TRANSLATORS: View the Attachment */
 826         {">",N_("ViewAttch"),{MC_VIEW_ATCH,3,{'v','>','.'}},KS_NONE},
 827         PREVMSG_MENU,
 828         NEXTMSG_MENU,
 829         PREVPAGE_MENU,
 830         NEXTPAGE_MENU,
 831         DELETE_MENU,
 832         UNDELETE_MENU,
 833         REPLY_MENU,
 834         FORWARD_MENU,
 835
 836         HELP_MENU,
 837         OTHER_MENU,
 838         MAIN_MENU,
 839         QUIT_MENU,
 840         LISTFLD_MENU,
 841         GOTO_MENU,
 842         COMPOSE_MENU,
 843         WHEREIS_MENU,
 844         PRYNTMSG_MENU,
 845         TAKE_MENU,
 846         SAVE_MENU,
 847         EXPORT_MENU,
 848
 849         HELP_MENU,
 850         OTHER_MENU,
 851         /* TRANSLATORS: View the highlighted URL */
 852         {"Ret","[" N_("View Hilite") "]",{MC_VIEW_HANDLE,3,
 853                                 {ctrl('m'),ctrl('j'),KEY_RIGHT}},KS_NONE},
 854         /* TRANSLATORS: Select the current item */
 855         {":",N_("SelectCur"),{MC_SELCUR,1,{':'}},KS_SELECTCUR},
 856         /* TRANSLATORS: go to previous URL */
 857         {"^B",N_("Prev URL"),{MC_PREV_HANDLE,1,{ctrl('B')}},KS_NONE},
 858         /* TRANSLATORS: go to next URL */
 859         {"^F",N_("Next URL"),{MC_NEXT_HANDLE,1,{ctrl('F')}},KS_NONE},
 860         JUMP_MENU,
 861         TAB_MENU,
 862         HDRMODE_MENU,
 863         BOUNCE_MENU,
 864         FLAG_MENU,
 865         PIPE_MENU,
 866
 867         HELP_MENU,
 868         OTHER_MENU,
 869         HOMEKEY_MENU,
 870         ENDKEY_MENU,
 871         RCOMPOSE_MENU,
 872         {"A",N_("TogglePreferPlain"),{MC_TOGGLE,1,{'a'}},KS_NONE},
 873 #ifdef SMIME
 874         {"^D","Decrypt", {MC_DECRYPT,1,{ctrl('d')},KS_NONE}},
 875         {"^E","Security", {MC_SECURITY,1,{ctrl('e')},KS_NONE}},
 876 #else
 877         NULL_MENU,
 878         NULL_MENU,
 879 #endif
 880         NULL_MENU,
 881         NULL_MENU,
 882         NULL_MENU,
 883         NULL_MENU};
 884 INST_KEY_MENU(view_keymenu, view_keys);
 885
 886
 887 struct key simple_text_keys[] =
 888        {HELP_MENU,
 889         OTHER_MENU,
 890         {"E",N_("Exit Viewer"),{MC_EXIT,1,{'e'}},KS_EXITMODE},
 891         NULL_MENU,
 892         NULL_MENU,
 893         NULL_MENU,
 894         PREVPAGE_MENU,
 895         NEXTPAGE_MENU,
 896         PRYNTTXT_MENU,
 897         WHEREIS_MENU,
 898         FWDEMAIL_MENU,
 899         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE},
 900
 901         HELP_MENU,
 902         OTHER_MENU,
 903         NULL_MENU,
 904         NULL_MENU,
 905         NULL_MENU,
 906         NULL_MENU,
 907         NULL_MENU,
 908         NULL_MENU,
 909         NULL_MENU,
 910         NULL_MENU,
 911         HOMEKEY_MENU,
 912         ENDKEY_MENU};
 913 INST_KEY_MENU(simple_text_keymenu, simple_text_keys);
 914
 915
 916 struct key oe_keys[] =
 917        {{"^G",N_("Help"),{MC_NONE},KS_SCREENHELP},
 918         {"^C",N_("Cancel"),{MC_NONE},KS_NONE},
 919         {"^T","xxx",{MC_NONE},KS_NONE},
 920         /* TRANSLATORS: The user is entering characters, for example, the
 921            name of a folder. Accept means the user is done and wants to
 922            accept what is currently displayed. */
 923         {"Ret",N_("Accept"),{MC_NONE},KS_NONE},
 924         NULL_MENU,
 925         NULL_MENU,
 926         NULL_MENU,
 927         NULL_MENU,
 928         NULL_MENU,
 929         NULL_MENU,
 930         NULL_MENU,
 931         NULL_MENU};
 932 INST_KEY_MENU(oe_keymenu, oe_keys);
 933
 934
 935 struct key choose_setup_keys[] =
 936        {HELP_MENU,
 937         OTHER_MENU,
 938         {"E",N_("Exit Setup"),{MC_EXIT,2,{'e',ctrl('C')}},KS_EXITMODE},
 939         {"P",N_("Printer"),{MC_PRINTER,1,{'p'}},KS_NONE},
 940         /* TRANSLATORS: Change password */
 941         {"N",N_("Newpassword"),{MC_PASSWD,1,{'n'}},KS_NONE},
 942         /* TRANSLATORS: Configure Alpine */
 943         {"C",N_("Config"),{MC_CONFIG,1,{'c'}},KS_NONE},
 944         /* TRANSLATORS: Edit signature block */
 945         {"S",N_("Signature"),{MC_SIG,1,{'s'}},KS_NONE},
 946         /* TRANSLATORS: configure address books */
 947         {"A",N_("AddressBooks"),{MC_ABOOKS,1,{'a'}},KS_NONE},
 948         /* TRANSLATORS: configure collection lists */
 949         {"L",N_("collectionList"),{MC_CLISTS,1,{'l'}},KS_NONE},
 950         /* TRANSLATORS: configure rules, an alpine concept */
 951         {"R",N_("Rules"),{MC_RULES,1,{'r'}},KS_NONE},
 952         /* TRANSLATORS: configure directory servers */
 953         {"D",N_("Directory"),{MC_DIRECTORY,1,{'d'}},KS_NONE},
 954         /* TRANSLATORS: configure color */
 955         {"K",N_("Kolor"),{MC_KOLOR,1,{'k'}},KS_NONE},
 956
 957         HELP_MENU,
 958         OTHER_MENU,
 959         NULL_MENU,
 960         /* TRANSLATORS: remote configuration setup */
 961         {"Z",N_("RemoteConfigSetup"),{MC_REMOTE,1,{'z'}},KS_NONE},
 962         /* TRANSLATORS: configure S/MIME */
 963         {"M",N_("S/Mime"),{MC_SECURITY,1,{'m'}},KS_NONE},
 964         NULL_MENU,
 965         PREVPAGE_MENU,
 966         NEXTPAGE_MENU,
 967         NULL_MENU,
 968         NULL_MENU,
 969         HOMEKEY_MENU,
 970         ENDKEY_MENU};
 971 INST_KEY_MENU(choose_setup_keymenu, choose_setup_keys);
 972
 973
 974 struct key main_keys[] =
 975        {HELP_MENU,
 976         OTHER_MENU,
 977         NULL_MENU,
 978         NULL_MENU,
 979         /* TRANSLATORS: go to Previous Command in list */
 980         {"P",N_("PrevCmd"),{MC_PREVITEM,3,{'p',ctrl('P'),KEY_UP}},KS_NONE},
 981         {"N",N_("NextCmd"),{MC_NEXTITEM,3,{'n',ctrl('N'),KEY_DOWN}},KS_NONE},
 982         NULL_MENU,
 983         NULL_MENU,
 984         /* TRANSLATORS: show release notes */
 985         {"R",N_("RelNotes"),{MC_RELNOTES,1,{'r'}},KS_NONE},
 986         /* TRANSLATORS: lock keyboard */
 987         {"K",N_("KBLock"),{MC_KBLOCK,1,{'k'}},KS_NONE},
 988         NULL_MENU,
 989         NULL_MENU,
 990
 991         HELP_MENU,
 992         OTHER_MENU,
 993         QUIT_MENU,
 994         COMPOSE_MENU,
 995         LISTFLD_MENU,
 996         GOTO_MENU,
 997         {"I",N_("Index"),{MC_INDEX,1,{'i'}},KS_FLDRINDEX},
 998         /* TRANSLATORS: go to the Journal. The Journal shows past
 999            messages that alpine has shown the user. */
1000         {"J",N_("Journal"),{MC_JOURNAL,1,{'j'}},KS_REVIEW},
1001         /* TRANSLATORS: go to the Setup screen */
1002         {"S",N_("Setup"),{MC_SETUP,1,{'s'}},KS_NONE},
1003         /* TRANSLATORS: go to the address book screen */
1004         {"A",N_("AddrBook"),{MC_ADDRBOOK,1,{'a'}},KS_ADDRBOOK},
1005         RCOMPOSE_MENU,
1006         NULL_MENU};
1007 INST_KEY_MENU(main_keymenu, main_keys);
1008
1009
1010 struct key simple_file_keys[] =
1011        {HELP_MENU,
1012         OTHER_MENU,
1013         {"Q",N_("Quit Viewer"),{MC_EXIT,1,{'q'}},KS_NONE},
1014         NULL_MENU,
1015         NULL_MENU,
1016         NULL_MENU,
1017         PREVPAGE_MENU,
1018         NEXTPAGE_MENU,
1019         PRYNTTXT_MENU,
1020         WHEREIS_MENU,
1021         FWDEMAIL_MENU,
1022         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE},
1023
1024         HELP_MENU,
1025         OTHER_MENU,
1026         NULL_MENU,
1027         NULL_MENU,
1028         NULL_MENU,
1029         NULL_MENU,
1030         NULL_MENU,
1031         NULL_MENU,
1032         NULL_MENU,
1033         NULL_MENU,
1034         HOMEKEY_MENU,
1035         ENDKEY_MENU};
1036 INST_KEY_MENU(simple_file_keymenu, simple_file_keys);
1037
1038
1039 struct key nuov_keys[] =
1040        {HELP_MENU,
1041         OTHER_MENU,
1042         {"E",NULL,{MC_EXIT,1,{'e',ctrl('M'),ctrl('J')}},KS_NONE},
1043         /* TRANSLATORS: Alpine asks the user to be counted when they
1044            first start using alpine. */
1045         {"Ret","[" N_("Be Counted!") "]",{MC_VIEW_HANDLE,2,{ctrl('M'),ctrl('J')}},KS_NONE},
1046         NULL_MENU,
1047         NULL_MENU,
1048         PREVPAGE_MENU,
1049         NEXTPAGE_MENU,
1050         PRYNTMSG_MENU,
1051         NULL_MENU,
1052         /* TRANSLATORS: show release notes */
1053         {"R",N_("RelNotes"),{MC_RELNOTES,1,{'r'}},KS_NONE},
1054         NULL_MENU,
1055
1056         HELP_MENU,
1057         OTHER_MENU,
1058         NULL_MENU,
1059         NULL_MENU,
1060         NULL_MENU,
1061         NULL_MENU,
1062         NULL_MENU,
1063         NULL_MENU,
1064         NULL_MENU,
1065         NULL_MENU,
1066         HOMEKEY_MENU,
1067         ENDKEY_MENU};
1068 INST_KEY_MENU(nuov_keymenu, nuov_keys);
1069
1070
1071 struct key modal_message_keys[] =
1072        {NULL_MENU,
1073         NULL_MENU,
1074         {"Ret",N_("Finished"),{MC_EXIT,2,{ctrl('m'),ctrl('j')}},KS_NONE},
1075         NULL_MENU,
1076         NULL_MENU,
1077         NULL_MENU,
1078         PREVPAGE_MENU,
1079         NEXTPAGE_MENU,
1080         NULL_MENU,
1081         NULL_MENU,
1082         HOMEKEY_MENU,
1083         ENDKEY_MENU};
1084 INST_KEY_MENU(modal_message_keymenu, modal_message_keys);
1085
1086
1087 struct key ta_keys_lm[] =
1088        {HELP_MENU,
1089         WHEREIS_MENU,
1090         TA_EXIT_MENU,
1091         /* TRANSLATORS: Take this address into the address book */
1092         {"T", N_("Take"), {MC_TAKE,1,{'t'}}, KS_NONE},
1093         TA_PREV_MENU,
1094         TA_NEXT_MENU,
1095         PREVPAGE_MENU,
1096         NEXTPAGE_MENU,
1097         {"X","[" N_("Set/Unset") "]", {MC_CHOICE,3,{'x',ctrl('M'),ctrl('J')}}, KS_NONE},
1098         {"A", N_("SetAll"),{MC_SELALL,1,{'a'}},KS_NONE},
1099         {"U",N_("UnSetAll"),{MC_UNSELALL,1,{'u'}},KS_NONE},
1100         /* TRANSLATORS: The Take Address screen has a Single mode and a
1101            List mode. This command causes us to go into Single mode. */
1102         {"S",N_("SinglMode"),{MC_LISTMODE,1,{'s'}},KS_NONE}};
1103 INST_KEY_MENU(ta_keymenu_lm, ta_keys_lm);
1104
1105
1106 struct key ta_keys_sm[] =
1107        {HELP_MENU,
1108         WHEREIS_MENU,
1109         TA_EXIT_MENU,
1110         {"T","[" N_("Take") "]",{MC_TAKE,3,{'t',ctrl('M'),ctrl('J')}}, KS_NONE},
1111         TA_PREV_MENU,
1112         TA_NEXT_MENU,
1113         PREVPAGE_MENU,
1114         NEXTPAGE_MENU,
1115         NULL_MENU,
1116         NULL_MENU,
1117         NULL_MENU,
1118         /* TRANSLATORS: The Take Address screen has a Single mode and a
1119            List mode. This command causes us to go into List mode. */
1120         {"L",N_("ListMode"),{MC_LISTMODE,1,{'l'}},KS_NONE}};
1121 INST_KEY_MENU(ta_keymenu_sm, ta_keys_sm);
1122
1123
1124 struct key pipe_cancel_keys[] =
1125        {NULL_MENU,
1126         {"^C",N_("Stop Waiting"),{MC_NONE},KS_NONE},
1127         NULL_MENU,
1128         NULL_MENU,
1129         NULL_MENU,
1130         NULL_MENU,
1131         NULL_MENU,
1132         NULL_MENU,
1133         NULL_MENU,
1134         NULL_MENU,
1135         NULL_MENU,
1136         NULL_MENU};
1137 INST_KEY_MENU(pipe_cancel_keymenu, pipe_cancel_keys);
1138
1139
1140 struct key color_pattern_keys[] =
1141        {HELP_MENU,
1142         OTHER_MENU,
1143         EXIT_SETUP_MENU,
1144         /* TRANSLATORS: Change Value */
1145         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1146         PREV_MENU,
1147         NEXT_MENU,
1148         PREVPAGE_MENU,
1149         NEXTPAGE_MENU,
1150         NULL_MENU,
1151         /* TRANSLATORS: Delete Value */
1152         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1153         PRYNTTXT_MENU,
1154         WHEREIS_MENU,
1155
1156         HELP_MENU,
1157         OTHER_MENU,
1158         {"I", N_("IndxHdr"), {MC_ADDHEADER,1,{'i'}}, KS_NONE},
1159         NULL_MENU,
1160         NULL_MENU,
1161         NULL_MENU,
1162         NULL_MENU,
1163         NULL_MENU,
1164         NULL_MENU,
1165         NULL_MENU,
1166         HOMEKEY_MENU,
1167         ENDKEY_MENU};
1168 INST_KEY_MENU(color_pattern_keymenu, color_pattern_keys);
1169
1170
1171 struct key hdr_color_checkbox_keys[] =
1172        {HELP_MENU,
1173         NULL_MENU,
1174         EXIT_SETUP_MENU,
1175         TOGGLEB_MENU,
1176         PREV_MENU,
1177         NEXT_MENU,
1178         PREVPAGE_MENU,
1179         NEXTPAGE_MENU,
1180         HOMEKEY_MENU,
1181         ENDKEY_MENU,
1182         PRYNTTXT_MENU,
1183         WHEREIS_MENU};
1184 INST_KEY_MENU(hdr_color_checkbox_keymenu, hdr_color_checkbox_keys);
1185
1186
1187 struct key kw_color_checkbox_keys[] =
1188        {HELP_MENU,
1189         NULL_MENU,
1190         EXIT_SETUP_MENU,
1191         TOGGLEC_MENU,
1192         PREV_MENU,
1193         NEXT_MENU,
1194         PREVPAGE_MENU,
1195         NEXTPAGE_MENU,
1196         HOMEKEY_MENU,
1197         ENDKEY_MENU,
1198         PRYNTTXT_MENU,
1199         WHEREIS_MENU};
1200 INST_KEY_MENU(kw_color_checkbox_keymenu, kw_color_checkbox_keys);
1201
1202
1203 struct key selectable_bold_checkbox_keys[] =
1204        {HELP_MENU,
1205         NULL_MENU,
1206         EXIT_SETUP_MENU,
1207         TOGGLED_MENU,
1208         PREV_MENU,
1209         NEXT_MENU,
1210         PREVPAGE_MENU,
1211         NEXTPAGE_MENU,
1212         HOMEKEY_MENU,
1213         ENDKEY_MENU,
1214         PRYNTTXT_MENU,
1215         WHEREIS_MENU};
1216 INST_KEY_MENU(selectable_bold_checkbox_keymenu, selectable_bold_checkbox_keys);
1217
1218
1219 struct key flag_keys[] =
1220        {HELP_MENU,
1221         {"A", N_("Add KW"), {MC_ADD,1,{'a'}}, KS_NONE},
1222         /* TRANSLATORS: Exit from the Flags screen */
1223         {"E", N_("Exit Flags"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1224         TOGGLE_MENU,
1225         PREV_MENU,
1226         NEXT_MENU,
1227         PREVPAGE_MENU,
1228         NEXTPAGE_MENU,
1229         HOMEKEY_MENU,
1230         ENDKEY_MENU,
1231         PRYNTTXT_MENU,
1232         WHEREIS_MENU};
1233 INST_KEY_MENU(flag_keymenu, flag_keys);
1234
1235
1236 struct key addr_select_keys[] =
1237        {HELP_MENU,
1238         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1239         NULL_MENU,
1240         {"S", "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
1241         PREV_MENU,
1242         NEXT_MENU,
1243         PREVPAGE_MENU,
1244         NEXTPAGE_MENU,
1245         HOMEKEY_MENU,
1246         ENDKEY_MENU,
1247         NULL_MENU,
1248         WHEREIS_MENU};
1249 INST_KEY_MENU(addr_s_km, addr_select_keys);
1250
1251
1252 struct key addr_select_with_goback_keys[] =
1253        {HELP_MENU,
1254         NULL_MENU,
1255         /* TRANSLATORS: go to address book list */
1256         {"<", N_("AddressBkList"), {MC_ADDRBOOK,2,{'<',','}}, KS_NONE},
1257         {"S", "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
1258         PREV_MENU,
1259         NEXT_MENU,
1260         PREVPAGE_MENU,
1261         NEXTPAGE_MENU,
1262         HOMEKEY_MENU,
1263         ENDKEY_MENU,
1264         {"E", N_("ExitSelect"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1265         WHEREIS_MENU};
1266 INST_KEY_MENU(addr_s_km_with_goback, addr_select_with_goback_keys);
1267
1268 static struct key addr_select_with_view_keys[] =
1269        {HELP_MENU,
1270         RCOMPOSE_MENU,
1271         {"<", N_("AddressBkList"), {MC_ADDRBOOK,2,{'<',','}}, KS_NONE},
1272         {">", "[" N_("View") "]",
1273            {MC_VIEW_TEXT,5,{'v','>','.',ctrl('M'),ctrl('J')}}, KS_NONE},
1274         PREV_MENU,
1275         NEXT_MENU,
1276         PREVPAGE_MENU,
1277         NEXTPAGE_MENU,
1278         /* TRANSLATORS: compose a message to the current address */
1279         {"C", N_("ComposeTo"), {MC_COMPOSE,1,{'c'}}, KS_COMPOSER},
1280         FWDEMAIL_MENU,
1281         SAVE_MENU,
1282         WHEREIS_MENU,
1283
1284         HELP_MENU,
1285         OTHER_MENU,
1286         NULL_MENU,
1287         NULL_MENU,
1288         NULL_MENU,
1289         NULL_MENU,
1290         NULL_MENU,
1291         NULL_MENU,
1292         NULL_MENU,
1293         NULL_MENU,
1294         HOMEKEY_MENU,
1295         ENDKEY_MENU};
1296 INST_KEY_MENU(addr_s_km_with_view, addr_select_with_view_keys);
1297
1298
1299 struct key addr_select_for_url_keys[] =
1300        {HELP_MENU,
1301         RCOMPOSE_MENU,
1302         {"<", N_("Exit Viewer"), {MC_ADDRBOOK,3,{'<',',','e'}}, KS_NONE},
1303         {">", "[" N_("View") "]",
1304            {MC_VIEW_TEXT,5,{'v','>','.',ctrl('M'),ctrl('J')}}, KS_NONE},
1305         PREV_MENU,
1306         NEXT_MENU,
1307         PREVPAGE_MENU,
1308         NEXTPAGE_MENU,
1309         {"C", N_("ComposeTo"), {MC_COMPOSE,1,{'c'}}, KS_COMPOSER},
1310         FWDEMAIL_MENU,
1311         SAVE_MENU,
1312         WHEREIS_MENU,
1313
1314         HELP_MENU,
1315         OTHER_MENU,
1316         NULL_MENU,
1317         NULL_MENU,
1318         NULL_MENU,
1319         NULL_MENU,
1320         NULL_MENU,
1321         NULL_MENU,
1322         NULL_MENU,
1323         NULL_MENU,
1324         HOMEKEY_MENU,
1325         ENDKEY_MENU};
1326 INST_KEY_MENU(addr_s_km_for_url, addr_select_for_url_keys);
1327
1328
1329 struct key addr_select_exit_keys[] =
1330        {NULL_MENU,
1331         NULL_MENU,
1332         {"E", "[" N_("Exit") "]", {MC_EXIT,3,{'e',ctrl('M'),ctrl('J')}},
1333            KS_EXITMODE},
1334         NULL_MENU,
1335         NULL_MENU,
1336         NULL_MENU,
1337         NULL_MENU,
1338         NULL_MENU,
1339         NULL_MENU,
1340         NULL_MENU,
1341         NULL_MENU,
1342         NULL_MENU};
1343 INST_KEY_MENU(addr_s_km_exit, addr_select_exit_keys);
1344
1345
1346 struct key addr_select_goback_keys[] =
1347        {NULL_MENU,
1348         NULL_MENU,
1349         {"E", "[" N_("Exit") "]", {MC_ADDRBOOK,3,{'e',ctrl('M'),ctrl('J')}},
1350            KS_EXITMODE},
1351         NULL_MENU,
1352         NULL_MENU,
1353         NULL_MENU,
1354         NULL_MENU,
1355         NULL_MENU,
1356         NULL_MENU,
1357         NULL_MENU,
1358         NULL_MENU,
1359         NULL_MENU};
1360 INST_KEY_MENU(addr_s_km_goback, addr_select_goback_keys);
1361
1362
1363 struct key config_text_keys[] =
1364        {HELP_MENU,
1365         OTHER_MENU,
1366         EXIT_SETUP_MENU,
1367         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1368         PREV_MENU,
1369         NEXT_MENU,
1370         PREVPAGE_MENU,
1371         NEXTPAGE_MENU,
1372         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1373         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1374         PRYNTTXT_MENU,
1375         WHEREIS_MENU,
1376
1377         HELP_MENU,
1378         OTHER_MENU,
1379         NULL_MENU,
1380         NULL_MENU,
1381         NULL_MENU,
1382         NULL_MENU,
1383         NULL_MENU,
1384         NULL_MENU,
1385         NULL_MENU,
1386         NULL_MENU,
1387         HOMEKEY_MENU,
1388         ENDKEY_MENU};
1389 INST_KEY_MENU(config_text_keymenu, config_text_keys);
1390
1391
1392 struct key config_text_to_charsets_keys[] =
1393        {HELP_MENU,
1394         OTHER_MENU,
1395         EXIT_SETUP_MENU,
1396         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1397         PREV_MENU,
1398         NEXT_MENU,
1399         PREVPAGE_MENU,
1400         NEXTPAGE_MENU,
1401         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1402         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1403         PRYNTTXT_MENU,
1404         WHEREIS_MENU,
1405
1406         HELP_MENU,
1407         OTHER_MENU,
1408         NULL_MENU,
1409         NULL_MENU,
1410         /* TRANSLATORS: go to list of keywords */
1411         {"T", N_("ToCharsets"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
1412         NULL_MENU,
1413         NULL_MENU,
1414         NULL_MENU,
1415         NULL_MENU,
1416         NULL_MENU,
1417         HOMEKEY_MENU,
1418         ENDKEY_MENU};
1419 INST_KEY_MENU(config_text_to_charsets_keymenu, config_text_to_charsets_keys);
1420
1421
1422 struct key direct_config_keys[] =
1423        {HELP_MENU,
1424         NULL_MENU,
1425         {"E", N_("Exit Setup"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1426         {"C", "[" N_("Change") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1427         /* TRANSLATORS: go to previous LDAP directory server in the list */
1428         {"P", N_("PrevDir"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1429         {"N", N_("NextDir"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1430         PREVPAGE_MENU,
1431         NEXTPAGE_MENU,
1432         /* TRANSLATORS: add a directory server to configuration */
1433         {"A", N_("Add Dir"), {MC_ADD,1,{'a'}}, KS_NONE},
1434         /* TRANSLATORS: delete a directory */
1435         {"D", N_("Del Dir"), {MC_DELETE,1,{'d'}}, KS_NONE},
1436         {"$", N_("Shuffle"), {MC_SHUFFLE,1,{'$'}}, KS_NONE},
1437         WHEREIS_MENU,
1438
1439         HELP_MENU,
1440         OTHER_MENU,
1441         NULL_MENU,
1442         NULL_MENU,
1443         NULL_MENU,
1444         NULL_MENU,
1445         NULL_MENU,
1446         NULL_MENU,
1447         NULL_MENU,
1448         NULL_MENU,
1449         HOMEKEY_MENU,
1450         ENDKEY_MENU};
1451 INST_KEY_MENU(dir_conf_km, direct_config_keys);
1452
1453
1454 struct key sel_from_list_keys[] =
1455        {HELP_MENU,
1456         NULL_MENU,
1457         {"E", N_("Exit"),     {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1458         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1459         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1460         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1461         PREVPAGE_MENU,
1462         NEXTPAGE_MENU,
1463         HOMEKEY_MENU,
1464         ENDKEY_MENU,
1465         PRYNTTXT_MENU,
1466         WHEREIS_MENU};
1467 INST_KEY_MENU(sel_from_list, sel_from_list_keys);
1468
1469
1470 struct key sel_from_list_keys_ctrlc[] =
1471        {HELP_MENU,
1472         NULL_MENU,
1473         {"^C", N_("exit"),     {MC_EXIT,1,{ctrl('C')}}, KS_EXITMODE},
1474         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1475         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1476         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1477         PREVPAGE_MENU,
1478         NEXTPAGE_MENU,
1479         HOMEKEY_MENU,
1480         ENDKEY_MENU,
1481         PRYNTTXT_MENU,
1482         WHEREIS_MENU};
1483 INST_KEY_MENU(sel_from_list_ctrlc, sel_from_list_keys_ctrlc);
1484
1485
1486 struct key sel_from_list_keys_sm[] =
1487        {HELP_MENU,
1488         OTHER_MENU,
1489         {"E", N_("Exit"),     {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1490         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1491         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1492         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1493         PREVPAGE_MENU,
1494         NEXTPAGE_MENU,
1495         NULL_MENU,
1496         {"L",N_("ListMode"),{MC_LISTMODE,1,{'l'}},KS_NONE},
1497         PRYNTTXT_MENU,
1498         WHEREIS_MENU,
1499
1500         HELP_MENU,
1501         OTHER_MENU,
1502         NULL_MENU,
1503         NULL_MENU,
1504         NULL_MENU,
1505         NULL_MENU,
1506         NULL_MENU,
1507         NULL_MENU,
1508         NULL_MENU,
1509         NULL_MENU,
1510         HOMEKEY_MENU,
1511         ENDKEY_MENU};
1512 INST_KEY_MENU(sel_from_list_sm, sel_from_list_keys_sm);
1513
1514
1515 struct key sel_from_list_keys_sm_ctrlc[] =
1516        {HELP_MENU,
1517         OTHER_MENU,
1518         {"^C", N_("exit"),     {MC_EXIT,1,{ctrl('C')}}, KS_EXITMODE},
1519         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1520         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1521         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1522         PREVPAGE_MENU,
1523         NEXTPAGE_MENU,
1524         NULL_MENU,
1525         {"L",N_("ListMode"),{MC_LISTMODE,1,{'l'}},KS_NONE},
1526         PRYNTTXT_MENU,
1527         WHEREIS_MENU,
1528
1529         HELP_MENU,
1530         OTHER_MENU,
1531         NULL_MENU,
1532         NULL_MENU,
1533         NULL_MENU,
1534         NULL_MENU,
1535         NULL_MENU,
1536         NULL_MENU,
1537         NULL_MENU,
1538         NULL_MENU,
1539         HOMEKEY_MENU,
1540         ENDKEY_MENU};
1541 INST_KEY_MENU(sel_from_list_sm_ctrlc, sel_from_list_keys_sm_ctrlc);
1542
1543
1544 struct key sel_from_list_keys_lm[] =
1545        {HELP_MENU,
1546         OTHER_MENU,
1547         {"E", N_("Exit"),     {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1548         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1549         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1550         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1551         PREVPAGE_MENU,
1552         NEXTPAGE_MENU,
1553         {"X", N_("Set/Unset"), {MC_TOGGLE,1,{'x'}}, KS_NONE},
1554         {"1",N_("SinglMode"),{MC_LISTMODE,1,{'1'}},KS_NONE},
1555         PRYNTTXT_MENU,
1556         WHEREIS_MENU,
1557
1558         HELP_MENU,
1559         OTHER_MENU,
1560         NULL_MENU,
1561         NULL_MENU,
1562         NULL_MENU,
1563         NULL_MENU,
1564         NULL_MENU,
1565         NULL_MENU,
1566         NULL_MENU,
1567         NULL_MENU,
1568         HOMEKEY_MENU,
1569         ENDKEY_MENU};
1570 INST_KEY_MENU(sel_from_list_lm, sel_from_list_keys_lm);
1571
1572
1573 struct key sel_from_list_keys_lm_ctrlc[] =
1574        {HELP_MENU,
1575         OTHER_MENU,
1576         {"^C", N_("exit"),     {MC_EXIT,1,{ctrl('C')}}, KS_EXITMODE},
1577         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1578         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1579         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1580         PREVPAGE_MENU,
1581         NEXTPAGE_MENU,
1582         {"X", N_("Set/Unset"), {MC_TOGGLE,1,{'x'}}, KS_NONE},
1583         {"1",N_("SinglMode"),{MC_LISTMODE,1,{'1'}},KS_NONE},
1584         PRYNTTXT_MENU,
1585         WHEREIS_MENU,
1586
1587         HELP_MENU,
1588         OTHER_MENU,
1589         NULL_MENU,
1590         NULL_MENU,
1591         NULL_MENU,
1592         NULL_MENU,
1593         NULL_MENU,
1594         NULL_MENU,
1595         NULL_MENU,
1596         NULL_MENU,
1597         HOMEKEY_MENU,
1598         ENDKEY_MENU};
1599 INST_KEY_MENU(sel_from_list_lm_ctrlc, sel_from_list_keys_lm_ctrlc);
1600
1601
1602 struct key sel_from_list_keys_olm[] =
1603        {HELP_MENU,
1604         OTHER_MENU,
1605         {"E", N_("Exit"),     {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1606         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1607         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1608         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1609         PREVPAGE_MENU,
1610         NEXTPAGE_MENU,
1611         {"X", N_("Set/Unset"), {MC_TOGGLE,1,{'x'}}, KS_NONE},
1612         NULL_MENU,
1613         PRYNTTXT_MENU,
1614         WHEREIS_MENU,
1615
1616         HELP_MENU,
1617         OTHER_MENU,
1618         NULL_MENU,
1619         NULL_MENU,
1620         NULL_MENU,
1621         NULL_MENU,
1622         NULL_MENU,
1623         NULL_MENU,
1624         NULL_MENU,
1625         NULL_MENU,
1626         HOMEKEY_MENU,
1627         ENDKEY_MENU};
1628 INST_KEY_MENU(sel_from_list_olm, sel_from_list_keys_olm);
1629
1630
1631 struct key sel_from_list_keys_olm_ctrlc[] =
1632        {HELP_MENU,
1633         OTHER_MENU,
1634         {"^C", N_("exit"),     {MC_EXIT,1,{ctrl('C')}}, KS_EXITMODE},
1635         {"S", "[" N_("Select") "]", {MC_SELECT,3,{'s',ctrl('J'),ctrl('M')}}, KS_NONE},
1636         {"P", N_("Prev"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1637         {"N", N_("Next"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1638         PREVPAGE_MENU,
1639         NEXTPAGE_MENU,
1640         {"X", N_("Set/Unset"), {MC_TOGGLE,1,{'x'}}, KS_NONE},
1641         NULL_MENU,
1642         PRYNTTXT_MENU,
1643         WHEREIS_MENU,
1644
1645         HELP_MENU,
1646         OTHER_MENU,
1647         NULL_MENU,
1648         NULL_MENU,
1649         NULL_MENU,
1650         NULL_MENU,
1651         NULL_MENU,
1652         NULL_MENU,
1653         NULL_MENU,
1654         NULL_MENU,
1655         HOMEKEY_MENU,
1656         ENDKEY_MENU};
1657 INST_KEY_MENU(sel_from_list_olm_ctrlc, sel_from_list_keys_olm_ctrlc);
1658
1659
1660 #ifndef DOS
1661
1662 struct key printer_edit_keys[] =
1663        {HELP_MENU,
1664         PRYNTTXT_MENU,
1665         EXIT_SETUP_MENU,
1666         {"S", "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
1667         PREV_MENU,
1668         NEXT_MENU,
1669         PREVPAGE_MENU,
1670         NEXTPAGE_MENU,
1671         /* TRANSLATORS: add a printer to configuration */
1672         {"A", N_("Add Printer"), {MC_ADD,1,{'a'}}, KS_NONE},
1673         /* TRANSLATORS: delete a printer from configuration */
1674         {"D", N_("DeletePrint"), {MC_DELETE,1,{'d'}}, KS_NONE},
1675         {"C", N_("Change"), {MC_EDIT,1,{'c'}}, KS_NONE},
1676         WHEREIS_MENU,
1677
1678         HELP_MENU,
1679         OTHER_MENU,
1680         NULL_MENU,
1681         NULL_MENU,
1682         NULL_MENU,
1683         NULL_MENU,
1684         NULL_MENU,
1685         NULL_MENU,
1686         NULL_MENU,
1687         NULL_MENU,
1688         HOMEKEY_MENU,
1689         ENDKEY_MENU};
1690 INST_KEY_MENU(printer_edit_keymenu, printer_edit_keys);
1691
1692
1693 struct key printer_select_keys[] =
1694        {HELP_MENU,
1695         PRYNTTXT_MENU,
1696         EXIT_SETUP_MENU,
1697         {"S", "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
1698         PREV_MENU,
1699         NEXT_MENU,
1700         PREVPAGE_MENU,
1701         NEXTPAGE_MENU,
1702         HOMEKEY_MENU,
1703         ENDKEY_MENU,
1704         NULL_MENU,
1705         WHEREIS_MENU};
1706 INST_KEY_MENU(printer_select_keymenu, printer_select_keys);
1707
1708 #endif  /* !DOS */
1709
1710
1711 struct key role_select_keys[] =
1712        {HELP_MENU,
1713         NULL_MENU,
1714         {"E", N_("Exit"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1715         NULL_MENU,
1716         /* TRANSLATORS: go to previous Role in list */
1717         {"P", N_("PrevRole"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1718         {"N", N_("NextRole"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1719         PREVPAGE_MENU,
1720         NEXTPAGE_MENU,
1721         HOMEKEY_MENU,
1722         ENDKEY_MENU,
1723         {"D", "", {MC_TOGGLE, 1, {'d'}}, KS_NONE},
1724         WHEREIS_MENU};
1725 INST_KEY_MENU(role_select_km, role_select_keys);
1726
1727
1728 struct key role_config_keys[] =
1729        {HELP_MENU,
1730         OTHER_MENU,
1731         {"E", N_("Exit Setup"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
1732         {"C", "[" N_("Change") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1733         /* TRANSLATORS: go to previous Rule in list */
1734         {"P", N_("PrevRule"), {MC_PREVITEM, 1, {'p'}}, KS_NONE},
1735         {"N", N_("NextRule"), {MC_NEXTITEM, 2, {'n', TAB}}, KS_NONE},
1736         PREVPAGE_MENU,
1737         NEXTPAGE_MENU,
1738         {"A", N_("Add"), {MC_ADD,1,{'a'}}, KS_NONE},
1739         {"D", N_("Delete"), {MC_DELETE,1,{'d'}}, KS_NONE},
1740         {"$", N_("Shuffle"), {MC_SHUFFLE,1,{'$'}}, KS_NONE},
1741         WHEREIS_MENU,
1742
1743         HELP_MENU,
1744         OTHER_MENU,
1745         NULL_MENU,
1746         NULL_MENU,
1747         /* TRANSLATORS: Include a File from filesystem */
1748         {"I", N_("IncludeFile"), {MC_ADDFILE,1,{'i'}}, KS_NONE},
1749         {"X", N_("eXcludeFile"), {MC_DELFILE,1,{'x'}}, KS_NONE},
1750         NULL_MENU,
1751         NULL_MENU,
1752         {"R", N_("Replicate"), {MC_COPY,1,{'r'}}, KS_NONE},
1753         NULL_MENU,
1754         HOMEKEY_MENU,
1755         ENDKEY_MENU};
1756 INST_KEY_MENU(role_conf_km, role_config_keys);
1757
1758
1759 struct key config_text_wshuf_keys[] =
1760        {HELP_MENU,
1761         OTHER_MENU,
1762         EXIT_SETUP_MENU,
1763         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1764         PREV_MENU,
1765         NEXT_MENU,
1766         PREVPAGE_MENU,
1767         NEXTPAGE_MENU,
1768         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1769         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1770         PRYNTTXT_MENU,
1771         WHEREIS_MENU,
1772
1773         HELP_MENU,
1774         OTHER_MENU,
1775         NULL_MENU,
1776         NULL_MENU,
1777         {"$", N_("Shuffle"), {MC_SHUFFLE,1,{'$'}}, KS_NONE},
1778         NULL_MENU,
1779         NULL_MENU,
1780         NULL_MENU,
1781         NULL_MENU,
1782         NULL_MENU,
1783         HOMEKEY_MENU,
1784         ENDKEY_MENU};
1785 INST_KEY_MENU(config_text_wshuf_keymenu, config_text_wshuf_keys);
1786
1787
1788 struct key config_text_wshufandfldr_keys[] =
1789        {HELP_MENU,
1790         OTHER_MENU,
1791         EXIT_SETUP_MENU,
1792         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1793         PREV_MENU,
1794         NEXT_MENU,
1795         PREVPAGE_MENU,
1796         NEXTPAGE_MENU,
1797         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1798         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1799         PRYNTTXT_MENU,
1800         WHEREIS_MENU,
1801
1802         HELP_MENU,
1803         OTHER_MENU,
1804         NULL_MENU,
1805         NULL_MENU,
1806         {"$", N_("Shuffle"), {MC_SHUFFLE,1,{'$'}}, KS_NONE},
1807         {"T", N_("ToFldrs"), {MC_CHOICE,2,{'t', ctrl('T')}}, KS_NONE},
1808         NULL_MENU,
1809         NULL_MENU,
1810         NULL_MENU,
1811         NULL_MENU,
1812         HOMEKEY_MENU,
1813         ENDKEY_MENU};
1814 INST_KEY_MENU(config_text_wshufandfldr_keymenu, config_text_wshufandfldr_keys);
1815
1816
1817 struct key config_role_file_keys[] =
1818        {HELP_MENU,
1819         OTHER_MENU,
1820         EXIT_SETUP_MENU,
1821         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1822         PREV_MENU,
1823         NEXT_MENU,
1824         PREVPAGE_MENU,
1825         NEXTPAGE_MENU,
1826         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1827         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1828         PRYNTTXT_MENU,
1829         WHEREIS_MENU,
1830
1831         HELP_MENU,
1832         OTHER_MENU,
1833         NULL_MENU,
1834         NULL_MENU,
1835         /* TRANSLATORS: go to list of Files */
1836         {"T", N_("ToFiles"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
1837         /* TRANSLATORS: edit a file */
1838         {"F", N_("editFile"), {MC_EDITFILE, 1, {'f'}}, KS_NONE},
1839         NULL_MENU,
1840         NULL_MENU,
1841         NULL_MENU,
1842         NULL_MENU,
1843         HOMEKEY_MENU,
1844         ENDKEY_MENU};
1845 INST_KEY_MENU(config_role_file_keymenu, config_role_file_keys);
1846
1847
1848 struct key config_role_file_res_keys[] =
1849        {HELP_MENU,
1850         OTHER_MENU,
1851         EXIT_SETUP_MENU,
1852         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1853         PREV_MENU,
1854         NEXT_MENU,
1855         PREVPAGE_MENU,
1856         NEXTPAGE_MENU,
1857         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1858         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1859         PRYNTTXT_MENU,
1860         WHEREIS_MENU,
1861
1862         HELP_MENU,
1863         OTHER_MENU,
1864         NULL_MENU,
1865         NULL_MENU,
1866         {"T", N_("ToFiles"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
1867         NULL_MENU,
1868         NULL_MENU,
1869         NULL_MENU,
1870         NULL_MENU,
1871         NULL_MENU,
1872         HOMEKEY_MENU,
1873         ENDKEY_MENU};
1874 INST_KEY_MENU(config_role_file_res_keymenu, config_role_file_res_keys);
1875
1876
1877 struct key config_role_keyword_keys[] =
1878        {HELP_MENU,
1879         OTHER_MENU,
1880         EXIT_SETUP_MENU,
1881         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1882         PREV_MENU,
1883         NEXT_MENU,
1884         PREVPAGE_MENU,
1885         NEXTPAGE_MENU,
1886         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1887         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1888         PRYNTTXT_MENU,
1889         WHEREIS_MENU,
1890
1891         HELP_MENU,
1892         OTHER_MENU,
1893         NULL_MENU,
1894         NULL_MENU,
1895         /* TRANSLATORS: go to list of keywords */
1896         {"T", N_("ToKeywords"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
1897         NULL_MENU,
1898         NULL_MENU,
1899         NULL_MENU,
1900         NULL_MENU,
1901         NULL_MENU,
1902         HOMEKEY_MENU,
1903         ENDKEY_MENU};
1904 INST_KEY_MENU(config_role_keyword_keymenu, config_role_keyword_keys);
1905
1906
1907 struct key config_role_keyword_keys_not[] =
1908        {HELP_MENU,
1909         OTHER_MENU,
1910         EXIT_SETUP_MENU,
1911         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1912         PREV_MENU,
1913         NEXT_MENU,
1914         PREVPAGE_MENU,
1915         NEXTPAGE_MENU,
1916         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1917         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1918         PRYNTTXT_MENU,
1919         WHEREIS_MENU,
1920
1921         HELP_MENU,
1922         OTHER_MENU,
1923         NULL_MENU,
1924         NULL_MENU,
1925         {"T", N_("ToKeywords"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
1926         NULL_MENU,
1927         /* TRANSLATORS: toggle between NOT and not NOT, turn NOT on or off */
1928         {"!", N_("toggle NOT"), {MC_NOT,1,{'!'}}, KS_NONE},
1929         NULL_MENU,
1930         NULL_MENU,
1931         NULL_MENU,
1932         HOMEKEY_MENU,
1933         ENDKEY_MENU};
1934 INST_KEY_MENU(config_role_keyword_keymenu_not, config_role_keyword_keys_not);
1935
1936
1937 struct key config_role_charset_keys_not[] =
1938        {HELP_MENU,
1939         OTHER_MENU,
1940         EXIT_SETUP_MENU,
1941         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1942         PREV_MENU,
1943         NEXT_MENU,
1944         PREVPAGE_MENU,
1945         NEXTPAGE_MENU,
1946         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1947         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1948         PRYNTTXT_MENU,
1949         WHEREIS_MENU,
1950
1951         HELP_MENU,
1952         OTHER_MENU,
1953         NULL_MENU,
1954         NULL_MENU,
1955         /* TRANSLATORS: go to list of character sets */
1956         {"T", N_("ToCharSets"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
1957         NULL_MENU,
1958         {"!", N_("toggle NOT"), {MC_NOT,1,{'!'}}, KS_NONE},
1959         NULL_MENU,
1960         NULL_MENU,
1961         NULL_MENU,
1962         HOMEKEY_MENU,
1963         ENDKEY_MENU};
1964 INST_KEY_MENU(config_role_charset_keymenu_not, config_role_charset_keys_not);
1965
1966
1967 struct key config_role_keys[] =
1968        {HELP_MENU,
1969         OTHER_MENU,
1970         EXIT_SETUP_MENU,
1971         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
1972         PREV_MENU,
1973         NEXT_MENU,
1974         PREVPAGE_MENU,
1975         NEXTPAGE_MENU,
1976         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
1977         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
1978         PRYNTTXT_MENU,
1979         WHEREIS_MENU,
1980
1981         HELP_MENU,
1982         OTHER_MENU,
1983         NULL_MENU,
1984         NULL_MENU,
1985         NULL_MENU,
1986         NULL_MENU,
1987         NULL_MENU,
1988         NULL_MENU,
1989         NULL_MENU,
1990         NULL_MENU,
1991         HOMEKEY_MENU,
1992         ENDKEY_MENU};
1993 INST_KEY_MENU(config_role_keymenu, config_role_keys);
1994
1995
1996 struct key config_role_keys_not[] =
1997        {HELP_MENU,
1998         OTHER_MENU,
1999         EXIT_SETUP_MENU,
2000         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2001         PREV_MENU,
2002         NEXT_MENU,
2003         PREVPAGE_MENU,
2004         NEXTPAGE_MENU,
2005         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2006         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2007         PRYNTTXT_MENU,
2008         WHEREIS_MENU,
2009
2010         HELP_MENU,
2011         OTHER_MENU,
2012         NULL_MENU,
2013         NULL_MENU,
2014         NULL_MENU,
2015         /* TRANSLATORS: add extra headers to list */
2016         {"X", N_("eXtraHdr"), {MC_ADDHDR, 1, {'x'}}, KS_NONE},
2017         {"!", N_("toggle NOT"), {MC_NOT,1,{'!'}}, KS_NONE},
2018         NULL_MENU,
2019         NULL_MENU,
2020         NULL_MENU,
2021         HOMEKEY_MENU,
2022         ENDKEY_MENU};
2023 INST_KEY_MENU(config_role_keymenu_not, config_role_keys_not);
2024
2025
2026 struct key config_role_keys_extra[] =
2027        {HELP_MENU,
2028         NULL_MENU,
2029         EXIT_SETUP_MENU,
2030         {"X", "[" N_("eXtraHdr") "]", {MC_ADDHDR, 3,{'x',ctrl('M'),ctrl('J')}}, KS_NONE},
2031         PREV_MENU,
2032         NEXT_MENU,
2033         PREVPAGE_MENU,
2034         NEXTPAGE_MENU,
2035         HOMEKEY_MENU,
2036         ENDKEY_MENU,
2037         PRYNTTXT_MENU,
2038         WHEREIS_MENU};
2039 INST_KEY_MENU(config_role_keymenu_extra, config_role_keys_extra);
2040
2041
2042 struct key config_role_addr_pat_keys[] =
2043        {HELP_MENU,
2044         OTHER_MENU,
2045         EXIT_SETUP_MENU,
2046         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2047         PREV_MENU,
2048         NEXT_MENU,
2049         PREVPAGE_MENU,
2050         NEXTPAGE_MENU,
2051         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2052         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2053         PRYNTTXT_MENU,
2054         WHEREIS_MENU,
2055
2056         HELP_MENU,
2057         OTHER_MENU,
2058         NULL_MENU,
2059         NULL_MENU,
2060         /* TRANSLATORS: go to address book to get address */
2061         {"T", N_("ToAddrBk"), {MC_CHOICEB, 2, {'t', ctrl('T')}}, KS_NONE},
2062         {"X", N_("eXtraHdr"), {MC_ADDHDR, 1, {'x'}}, KS_NONE},
2063         {"!", N_("toggle NOT"), {MC_NOT,1,{'!'}}, KS_NONE},
2064         NULL_MENU,
2065         NULL_MENU,
2066         NULL_MENU,
2067         HOMEKEY_MENU,
2068         ENDKEY_MENU};
2069 INST_KEY_MENU(config_role_addr_pat_keymenu, config_role_addr_pat_keys);
2070
2071
2072 struct key config_role_xtrahdr_keys[] =
2073        {HELP_MENU,
2074         OTHER_MENU,
2075         EXIT_SETUP_MENU,
2076         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2077         PREV_MENU,
2078         NEXT_MENU,
2079         PREVPAGE_MENU,
2080         NEXTPAGE_MENU,
2081         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2082         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2083         PRYNTTXT_MENU,
2084         WHEREIS_MENU,
2085
2086         HELP_MENU,
2087         OTHER_MENU,
2088         NULL_MENU,
2089         NULL_MENU,
2090         NULL_MENU,
2091         {"X", N_("eXtraHdr"), {MC_ADDHDR, 1, {'x'}}, KS_NONE},
2092         {"!", N_("toggle NOT"), {MC_NOT,1,{'!'}}, KS_NONE},
2093         NULL_MENU,
2094         /* TRANSLATORS: remove a header we previously added */
2095         {"R", N_("RemoveHdr"), {MC_DELHDR, 1, {'r'}}, KS_NONE},
2096         NULL_MENU,
2097         HOMEKEY_MENU,
2098         ENDKEY_MENU};
2099 INST_KEY_MENU(config_role_xtrahdr_keymenu, config_role_xtrahdr_keys);
2100
2101
2102 struct key config_role_addr_act_keys[] =
2103        {HELP_MENU,
2104         OTHER_MENU,
2105         EXIT_SETUP_MENU,
2106         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2107         PREV_MENU,
2108         NEXT_MENU,
2109         PREVPAGE_MENU,
2110         NEXTPAGE_MENU,
2111         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2112         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2113         PRYNTTXT_MENU,
2114         WHEREIS_MENU,
2115
2116         HELP_MENU,
2117         OTHER_MENU,
2118         NULL_MENU,
2119         NULL_MENU,
2120         {"T", N_("ToAddrBk"), {MC_CHOICEC, 2, {'t', ctrl('T')}}, KS_NONE},
2121         NULL_MENU,
2122         NULL_MENU,
2123         NULL_MENU,
2124         NULL_MENU,
2125         NULL_MENU,
2126         HOMEKEY_MENU,
2127         ENDKEY_MENU};
2128 INST_KEY_MENU(config_role_addr_act_keymenu, config_role_addr_act_keys);
2129
2130
2131 struct key config_role_patfolder_keys[] =
2132        {HELP_MENU,
2133         OTHER_MENU,
2134         EXIT_SETUP_MENU,
2135         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2136         PREV_MENU,
2137         NEXT_MENU,
2138         PREVPAGE_MENU,
2139         NEXTPAGE_MENU,
2140         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2141         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2142         PRYNTTXT_MENU,
2143         WHEREIS_MENU,
2144
2145         HELP_MENU,
2146         OTHER_MENU,
2147         NULL_MENU,
2148         NULL_MENU,
2149         /* TRANSLATORS: go to list of folders */
2150         {"T", N_("ToFldrs"), {MC_CHOICED, 2, {'t', ctrl('T')}}, KS_NONE},
2151         NULL_MENU,
2152         NULL_MENU,
2153         NULL_MENU,
2154         NULL_MENU,
2155         NULL_MENU,
2156         HOMEKEY_MENU,
2157         ENDKEY_MENU};
2158 INST_KEY_MENU(config_role_patfolder_keymenu, config_role_patfolder_keys);
2159
2160
2161 struct key config_role_actionfolder_keys[] =
2162        {HELP_MENU,
2163         OTHER_MENU,
2164         EXIT_SETUP_MENU,
2165         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2166         PREV_MENU,
2167         NEXT_MENU,
2168         PREVPAGE_MENU,
2169         NEXTPAGE_MENU,
2170         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2171         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2172         PRYNTTXT_MENU,
2173         WHEREIS_MENU,
2174
2175         HELP_MENU,
2176         OTHER_MENU,
2177         NULL_MENU,
2178         NULL_MENU,
2179         {"T", N_("ToFldrs"), {MC_CHOICEE, 2, {'t', ctrl('T')}}, KS_NONE},
2180         NULL_MENU,
2181         NULL_MENU,
2182         NULL_MENU,
2183         NULL_MENU,
2184         NULL_MENU,
2185         HOMEKEY_MENU,
2186         ENDKEY_MENU};
2187 INST_KEY_MENU(config_role_actionfolder_keymenu, config_role_actionfolder_keys);
2188
2189
2190 struct key config_role_inick_keys[] =
2191        {HELP_MENU,
2192         OTHER_MENU,
2193         EXIT_SETUP_MENU,
2194         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2195         PREV_MENU,
2196         NEXT_MENU,
2197         PREVPAGE_MENU,
2198         NEXTPAGE_MENU,
2199         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2200         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2201         PRYNTTXT_MENU,
2202         WHEREIS_MENU,
2203
2204         HELP_MENU,
2205         OTHER_MENU,
2206         NULL_MENU,
2207         NULL_MENU,
2208         /* TRANSLATORS: go to list of nicknames */
2209         {"T", N_("ToNicks"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
2210         NULL_MENU,
2211         NULL_MENU,
2212         NULL_MENU,
2213         NULL_MENU,
2214         NULL_MENU,
2215         HOMEKEY_MENU,
2216         ENDKEY_MENU};
2217 INST_KEY_MENU(config_role_inick_keymenu, config_role_inick_keys);
2218
2219
2220 struct key config_role_afrom_keys[] =
2221        {HELP_MENU,
2222         OTHER_MENU,
2223         EXIT_SETUP_MENU,
2224         {"C", "[" N_("Change Val") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2225         PREV_MENU,
2226         NEXT_MENU,
2227         PREVPAGE_MENU,
2228         NEXTPAGE_MENU,
2229         {"A", N_("Add Value"), {MC_ADD,1,{'a'}}, KS_NONE},
2230         {"D", N_("Delete Val"), {MC_DELETE,1,{'d'}}, KS_NONE},
2231         PRYNTTXT_MENU,
2232         WHEREIS_MENU,
2233
2234         HELP_MENU,
2235         OTHER_MENU,
2236         NULL_MENU,
2237         NULL_MENU,
2238         /* TRANSLATORS: go to list of address books */
2239         {"T", N_("ToAbookList"), {MC_CHOICE, 2, {'t', ctrl('T')}}, KS_NONE},
2240         NULL_MENU,
2241         NULL_MENU,
2242         NULL_MENU,
2243         NULL_MENU,
2244         NULL_MENU,
2245         HOMEKEY_MENU,
2246         ENDKEY_MENU};
2247 INST_KEY_MENU(config_role_afrom_keymenu, config_role_afrom_keys);
2248
2249
2250 struct key config_checkbox_keys[] =
2251        {HELP_MENU,
2252         NULL_MENU,
2253         EXIT_SETUP_MENU,
2254         TOGGLE_MENU,
2255         PREV_MENU,
2256         NEXT_MENU,
2257         PREVPAGE_MENU,
2258         NEXTPAGE_MENU,
2259         HOMEKEY_MENU,
2260         ENDKEY_MENU,
2261         PRYNTTXT_MENU,
2262         WHEREIS_MENU};
2263 INST_KEY_MENU(config_checkbox_keymenu, config_checkbox_keys);
2264
2265
2266 struct key config_radiobutton_keys[] =
2267        {HELP_MENU,
2268         NULL_MENU,
2269         EXIT_SETUP_MENU,
2270         {"*", "[" N_("Select") "]", {MC_CHOICE,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2271         PREV_MENU,
2272         NEXT_MENU,
2273         PREVPAGE_MENU,
2274         NEXTPAGE_MENU,
2275         HOMEKEY_MENU,
2276         ENDKEY_MENU,
2277         PRYNTTXT_MENU,
2278         WHEREIS_MENU};
2279 INST_KEY_MENU(config_radiobutton_keymenu, config_radiobutton_keys);
2280
2281
2282 struct key config_yesno_keys[] =
2283        {HELP_MENU,
2284         NULL_MENU,
2285         EXIT_SETUP_MENU,
2286         {"C", "[" N_("Change") "]", {MC_TOGGLE,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2287         PREV_MENU,
2288         NEXT_MENU,
2289         PREVPAGE_MENU,
2290         NEXTPAGE_MENU,
2291         HOMEKEY_MENU,
2292         ENDKEY_MENU,
2293         PRYNTTXT_MENU,
2294         WHEREIS_MENU};
2295 INST_KEY_MENU(config_yesno_keymenu, config_yesno_keys);
2296
2297
2298 struct key color_changing_keys[] =
2299        {HELP_MENU,
2300         NULL_MENU,
2301         {"E", N_("To Colors"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
2302         {"*", "[" N_("Select") "]", {MC_CHOICE,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2303         PREV_MENU,
2304         NEXT_MENU,
2305         PREVPAGE_MENU,
2306         NEXTPAGE_MENU,
2307         HOMEKEY_MENU,
2308         ENDKEY_MENU,
2309         PRYNTTXT_MENU,
2310         WHEREIS_MENU};
2311 INST_KEY_MENU(color_changing_keymenu, color_changing_keys);
2312
2313
2314 struct key custom_color_changing_keys[] =
2315        {HELP_MENU,
2316         NULL_MENU,
2317         /* TRANSLATORS: go to color configuration screen */
2318         {"E", N_("To Colors"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
2319         {"*", "[" N_("Select") "]", {MC_CHOICEB,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2320         PREV_MENU,
2321         NEXT_MENU,
2322         PREVPAGE_MENU,
2323         NEXTPAGE_MENU,
2324         HOMEKEY_MENU,
2325         ENDKEY_MENU,
2326         PRYNTTXT_MENU,
2327         WHEREIS_MENU};
2328 INST_KEY_MENU(custom_color_changing_keymenu, custom_color_changing_keys);
2329
2330
2331 struct key kw_color_changing_keys[] =
2332        {HELP_MENU,
2333         NULL_MENU,
2334         {"E", N_("To Colors"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
2335         {"*", "[" N_("Select") "]", {MC_CHOICEC,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2336         PREV_MENU,
2337         NEXT_MENU,
2338         PREVPAGE_MENU,
2339         NEXTPAGE_MENU,
2340         HOMEKEY_MENU,
2341         ENDKEY_MENU,
2342         PRYNTTXT_MENU,
2343         WHEREIS_MENU};
2344 INST_KEY_MENU(kw_color_changing_keymenu, kw_color_changing_keys);
2345
2346
2347 #ifdef  _WINDOWS
2348
2349 struct key color_rgb_changing_keys[] =
2350        {HELP_MENU,
2351         OTHER_MENU,
2352         {"E", N_("To Colors"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
2353         {"*", "[" N_("Select") "]", {MC_CHOICE,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2354         PREV_MENU,
2355         NEXT_MENU,
2356         PREVPAGE_MENU,
2357         NEXTPAGE_MENU,
2358         {"C", N_("Customize"), {MC_RGB1,1,{'c'}},KS_NONE},
2359         NULL_MENU,
2360         PRYNTTXT_MENU,
2361         WHEREIS_MENU,
2362
2363         HELP_MENU,
2364         OTHER_MENU,
2365         NULL_MENU,
2366         NULL_MENU,
2367         NULL_MENU,
2368         NULL_MENU,
2369         NULL_MENU,
2370         NULL_MENU,
2371         NULL_MENU,
2372         NULL_MENU,
2373         HOMEKEY_MENU,
2374         ENDKEY_MENU};
2375 INST_KEY_MENU(color_rgb_keymenu, color_rgb_changing_keys);
2376
2377
2378 struct key custom_rgb_changing_keys[] =
2379        {HELP_MENU,
2380         OTHER_MENU,
2381         {"E", N_("To Colors"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
2382         {"*", "[" N_("Select") "]", {MC_CHOICEB,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2383         PREV_MENU,
2384         NEXT_MENU,
2385         PREVPAGE_MENU,
2386         NEXTPAGE_MENU,
2387         {"C", N_("Customize"), {MC_RGB2,1,{'c'}},KS_NONE},
2388         NULL_MENU,
2389         PRYNTTXT_MENU,
2390         WHEREIS_MENU,
2391
2392         HELP_MENU,
2393         OTHER_MENU,
2394         NULL_MENU,
2395         NULL_MENU,
2396         NULL_MENU,
2397         NULL_MENU,
2398         NULL_MENU,
2399         NULL_MENU,
2400         NULL_MENU,
2401         NULL_MENU,
2402         HOMEKEY_MENU,
2403         ENDKEY_MENU};
2404 INST_KEY_MENU(custom_rgb_keymenu, custom_rgb_changing_keys);
2405
2406
2407 struct key kw_rgb_changing_keys[] =
2408        {HELP_MENU,
2409         OTHER_MENU,
2410         {"E", N_("To Colors"), {MC_EXIT,1,{'e'}}, KS_EXITMODE},
2411         {"*", "[" N_("Select") "]", {MC_CHOICEC,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2412         PREV_MENU,
2413         NEXT_MENU,
2414         PREVPAGE_MENU,
2415         NEXTPAGE_MENU,
2416         {"C", N_("Customize"), {MC_RGB3,1,{'c'}},KS_NONE},
2417         NULL_MENU,
2418         PRYNTTXT_MENU,
2419         WHEREIS_MENU,
2420
2421         HELP_MENU,
2422         OTHER_MENU,
2423         NULL_MENU,
2424         NULL_MENU,
2425         NULL_MENU,
2426         NULL_MENU,
2427         NULL_MENU,
2428         NULL_MENU,
2429         NULL_MENU,
2430         NULL_MENU,
2431         HOMEKEY_MENU,
2432         ENDKEY_MENU};
2433 INST_KEY_MENU(kw_rgb_keymenu, kw_rgb_changing_keys);
2434
2435 #endif
2436
2437
2438 struct key color_setting_keys[] =
2439        {HELP_MENU,
2440         OTHER_MENU,
2441         EXIT_SETUP_MENU,
2442         {"C", "[" N_("Change") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2443         PREV_MENU,
2444         NEXT_MENU,
2445         PREVPAGE_MENU,
2446         NEXTPAGE_MENU,
2447         {"A", N_("AddHeader"), {MC_ADD,1,{'a'}}, KS_NONE},
2448         /* TRANSLATORS: restore defaults */
2449         {"R", N_("RestoreDefs"), {MC_DEFAULT,1,{'r'}}, KS_NONE},
2450         PRYNTTXT_MENU,
2451         WHEREIS_MENU,
2452
2453         HELP_MENU,
2454         OTHER_MENU,
2455         {"I", N_("IndxHdr"), {MC_ADDHEADER,1,{'i'}}, KS_NONE},
2456         NULL_MENU,
2457         NULL_MENU,
2458         NULL_MENU,
2459         NULL_MENU,
2460         NULL_MENU,
2461         NULL_MENU,
2462         NULL_MENU,
2463         HOMEKEY_MENU,
2464         ENDKEY_MENU};
2465 INST_KEY_MENU(color_setting_keymenu, color_setting_keys);
2466
2467
2468 struct key custom_color_setting_keys[] =
2469        {HELP_MENU,
2470         OTHER_MENU,
2471         EXIT_SETUP_MENU,
2472         {"C", "[" N_("Change") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2473         PREV_MENU,
2474         NEXT_MENU,
2475         PREVPAGE_MENU,
2476         NEXTPAGE_MENU,
2477         {"A", N_("AddHeader"), {MC_ADD,1,{'a'}}, KS_NONE},
2478         {"R", N_("RestoreDefs"), {MC_DEFAULT,1,{'r'}}, KS_NONE},
2479         PRYNTTXT_MENU,
2480         WHEREIS_MENU,
2481
2482         HELP_MENU,
2483         OTHER_MENU,
2484         {"I", N_("IndxHdr"), {MC_ADDHEADER,1,{'i'}}, KS_NONE},
2485         NULL_MENU,
2486         {"D", N_("DeleteHdr"), {MC_DELETE,1,{'d'}}, KS_NONE},
2487         /* TRANSLATORS: shuffle headers (change the order of headers) */
2488         {"$", N_("ShuffleHdr"), {MC_SHUFFLE,1,{'$'}}, KS_NONE},
2489         NULL_MENU,
2490         NULL_MENU,
2491         NULL_MENU,
2492         NULL_MENU,
2493         HOMEKEY_MENU,
2494         ENDKEY_MENU};
2495 INST_KEY_MENU(custom_color_setting_keymenu, custom_color_setting_keys);
2496
2497
2498 struct key role_color_setting_keys[] =
2499        {HELP_MENU,
2500         NULL_MENU,
2501         EXIT_SETUP_MENU,
2502         {"*", "[" N_("Select") "]", {MC_CHOICE,3,{'*',ctrl('M'),ctrl('J')}}, KS_NONE},
2503         PREV_MENU,
2504         NEXT_MENU,
2505         PREVPAGE_MENU,
2506         NEXTPAGE_MENU,
2507         HOMEKEY_MENU,
2508         ENDKEY_MENU,
2509         PRYNTTXT_MENU,
2510         WHEREIS_MENU};
2511 INST_KEY_MENU(role_color_setting_keymenu, role_color_setting_keys);
2512
2513
2514 struct key kw_color_setting_keys[] =
2515        {HELP_MENU,
2516         OTHER_MENU,
2517         EXIT_SETUP_MENU,
2518         {"C", "[" N_("Change") "]", {MC_EDIT,3,{'c',ctrl('M'),ctrl('J')}}, KS_NONE},
2519         PREV_MENU,
2520         NEXT_MENU,
2521         PREVPAGE_MENU,
2522         NEXTPAGE_MENU,
2523         {"A", N_("AddHeader"), {MC_ADD,1,{'a'}}, KS_NONE},
2524         {"R", N_("RestoreDefs"), {MC_DEFAULT,1,{'r'}}, KS_NONE},
2525         PRYNTTXT_MENU,
2526         WHEREIS_MENU,
2527
2528         HELP_MENU,
2529         OTHER_MENU,
2530         {"I", N_("IndxHdr"), {MC_ADDHEADER,1,{'i'}}, KS_NONE},
2531         NULL_MENU,
2532         NULL_MENU,
2533         NULL_MENU,
2534         NULL_MENU,
2535         NULL_MENU,
2536         NULL_MENU,
2537         NULL_MENU,
2538         HOMEKEY_MENU,
2539         ENDKEY_MENU};
2540 INST_KEY_MENU(kw_color_setting_keymenu, kw_color_setting_keys);
2541
2542
2543 struct key take_export_keys_sm[] =
2544        {HELP_MENU,
2545         WHEREIS_MENU,
2546         /* TRANSLATORS: exit the Take Address screen */
2547         {"<",N_("ExitTake"), {MC_EXIT,4,{'e',ctrl('C'),'<',','}}, KS_EXITMODE},
2548         {"T","[" N_("Take") "]",{MC_TAKE,3,{'t',ctrl('M'),ctrl('J')}}, KS_NONE},
2549         PREV_MENU,
2550         NEXT_MENU,
2551         PREVPAGE_MENU,
2552         NEXTPAGE_MENU,
2553         NULL_MENU,
2554         NULL_MENU,
2555         NULL_MENU,
2556         {"L",N_("ListMode"),{MC_LISTMODE,1,{'l'}},KS_NONE}};
2557 INST_KEY_MENU(take_export_keymenu_sm, take_export_keys_sm);
2558
2559
2560 struct key take_export_keys_lm[] =
2561        {HELP_MENU,
2562         WHEREIS_MENU,
2563         {"<",N_("ExitTake"), {MC_EXIT,4,{'e',ctrl('C'),'<',','}}, KS_EXITMODE},
2564         {"T",N_("Take"), {MC_TAKE,1,{'t'}}, KS_NONE},
2565         PREV_MENU,
2566         NEXT_MENU,
2567         PREVPAGE_MENU,
2568         NEXTPAGE_MENU,
2569         {"X","[" N_("Set/Unset") "]", {MC_CHOICE,3,{'x',ctrl('M'),ctrl('J')}}, KS_NONE},
2570         {"A", N_("SetAll"),{MC_SELALL,1,{'a'}},KS_NONE},
2571         {"U",N_("UnSetAll"),{MC_UNSELALL,1,{'u'}},KS_NONE},
2572         {"S",N_("SinglMode"),{MC_LISTMODE,1,{'s'}},KS_NONE}};
2573 INST_KEY_MENU(take_export_keymenu_lm, take_export_keys_lm);
2574
2575
2576 struct key smime_info_keys[] =
2577        {HELP_MENU,
2578         OTHER_MENU,
2579         {"<","Back",{MC_VIEW_TEXT,2,{'<',','}},KS_EXITMODE},
2580         NULL_MENU,
2581         NULL_MENU,
2582         NULL_MENU,
2583         PREVPAGE_MENU,
2584         NEXTPAGE_MENU,
2585         NULL_MENU,
2586         NULL_MENU,
2587         NULL_MENU,
2588         NULL_MENU,
2589
2590         HELP_MENU,
2591         OTHER_MENU,
2592         MAIN_MENU,
2593         QUIT_MENU,
2594         NULL_MENU,
2595         NULL_MENU,
2596         NULL_MENU,
2597         NULL_MENU,
2598         NULL_MENU,
2599         INDEX_MENU,
2600         NULL_MENU,
2601         NULL_MENU};
2602 INST_KEY_MENU(smime_info_keymenu, smime_info_keys);
2603
2604
2605 struct key config_smime_helper_keys[] =
2606        {HELP_MENU,
2607         WHEREIS_MENU,
2608         EXIT_SETUP_MENU,
2609         {"T","[" N_("Transfer") "]", {MC_CHOICE,3,{'t',ctrl('M'),ctrl('J')}}, KS_NONE},
2610         PREV_MENU,
2611         NEXT_MENU,
2612         PREVPAGE_MENU,
2613         NEXTPAGE_MENU,
2614         NULL_MENU,
2615         NULL_MENU,
2616         HOMEKEY_MENU,
2617         ENDKEY_MENU};
2618 INST_KEY_MENU(config_smime_helper_keymenu, config_smime_helper_keys);
2619
2620 struct key config_smime_manage_certs_menu_keys[] =
2621        {HELP_MENU,
2622         WHEREIS_MENU,
2623         EXIT_SETUP_MENU,
2624         {"S", "[" N_("Select") "]", {MC_CHOICE,3,{'s',ctrl('M'),ctrl('J')}}, KS_NONE},
2625         {"I", N_("Import Cert"), {MC_IMPORT,1,{'i'}}, KS_NONE},
2626         NULL_MENU,
2627         PREV_MENU,
2628         NEXT_MENU,
2629         PREVPAGE_MENU,
2630         NEXTPAGE_MENU,
2631         HOMEKEY_MENU,
2632         ENDKEY_MENU};
2633 INST_KEY_MENU(config_smime_manage_certs_menu_keymenu, config_smime_manage_certs_menu_keys);
2634
2635 struct key config_smime_add_certs_keys[] =
2636        {HELP_MENU,
2637         NULL_MENU,
2638         EXIT_SETUP_MENU,
2639         {"I", N_("Import Cert"), {MC_IMPORT,3,{'i', ctrl('M'), ctrl('J')}}, KS_NONE},
2640         NULL_MENU,
2641         NULL_MENU,
2642         NULL_MENU,
2643         NULL_MENU,
2644         NULL_MENU,
2645         NULL_MENU,
2646         NULL_MENU,
2647         NULL_MENU};
2648 INST_KEY_MENU(config_smime_add_certs_keymenu, config_smime_add_certs_keys);
2649
2650 struct key config_smime_manage_certs_work_keys[] =
2651        {HELP_MENU,
2652         OTHER_MENU,
2653         EXIT_SETUP_MENU,
2654         {"V", "[" N_("View Info") "]", {MC_CHOICE,3,{'v',ctrl('M'),ctrl('J')}}, KS_NONE},
2655         {"I", N_("Import Cert"), {MC_IMPORT,1,{'i'}}, KS_NONE},
2656         NULL_MENU,
2657         {"D", N_("Delete"), {MC_DELETE,1,{'d'}}, KS_NONE},
2658         {"U", N_("Undelete"), {MC_UNDELETE,1,{'u'}}, KS_NONE},
2659         {"X", N_("Expunge"), {MC_EXPUNGE,1,{'x'}}, KS_NONE},
2660         NULL_MENU,
2661         NULL_MENU,
2662         WHEREIS_MENU,
2663
2664         PREV_MENU,
2665         NEXT_MENU,
2666         PREVPAGE_MENU,
2667         NEXTPAGE_MENU,
2668         NULL_MENU,
2669         NULL_MENU,
2670         NULL_MENU,
2671         NULL_MENU,
2672         NULL_MENU,
2673         NULL_MENU,
2674         HOMEKEY_MENU,
2675         ENDKEY_MENU};
2676 INST_KEY_MENU(config_smime_manage_certs_work_keymenu, config_smime_manage_certs_work_keys);
2677
2678 struct key smime_certificate_info_keys[] =
2679        {HELP_MENU,
2680         OTHER_MENU,
2681         {"E",N_("Exit Viewer"),{MC_EXIT,1,{'e'}},KS_EXITMODE},
2682         {"T",N_("Trust Cert"), {MC_TRUST,1,{'t'}},KS_NONE},
2683         {"D",N_("Delete"),     {MC_DELETE,1,{'d'}},KS_NONE},
2684         {"U",N_("Undelete"),   {MC_UNDELETE,1,{'u'}},KS_NONE},
2685         {"B",N_("Public Key"), {MC_PUBLIC,1,{'b'}},KS_NONE},
2686         {"R",N_("Private Key"),{MC_PRIVATE,1,{'r'}},KS_NONE},
2687         NULL_MENU,
2688         NULL_MENU,
2689         FWDEMAIL_MENU,
2690         {"S", N_("Save"), {MC_SAVETEXT,1,{'s'}}, KS_SAVE},
2691
2692         HELP_MENU,
2693         OTHER_MENU,
2694         PREVPAGE_MENU,
2695         NEXTPAGE_MENU,
2696         PRYNTTXT_MENU,
2697         WHEREIS_MENU,
2698         NULL_MENU,
2699         NULL_MENU,
2700         NULL_MENU,
2701         NULL_MENU,
2702         HOMEKEY_MENU,
2703         ENDKEY_MENU};
2704 INST_KEY_MENU(smime_certificate_info_keymenu, smime_certificate_info_keys);
2705
2706
2707 /*
2708  * Internal prototypes
2709  */
2710 void  output_keymenu(struct key_menu *, bitmap_t, int, int);
2711 void  format_keymenu(struct key_menu *, bitmap_t, int);
2712 void  menu_clear_cmd_binding(struct key_menu *, int);
2713 #ifdef  MOUSE
2714 void  print_inverted_label(int, MENUITEM *);
2715 #endif
2716
2717
2718 /* Saved key menu drawing state */
2719 static struct {
2720     struct key_menu *km;
2721     int              row,
2722                      column,
2723                      blanked;
2724     bitmap_t         bitmap;
2725 } km_state;
2726
2727
2728 /*
2729  * Longest label that can be displayed in keymenu
2730  */
2731 #define MAX_LABEL       40
2732 #define MAX_KEYNAME      3
2733 static struct key last_time_buf[12];
2734 static int keymenu_is_dirty = 1;
2735
2736 void
2737 mark_keymenu_dirty(void)
2738 {
2739     keymenu_is_dirty = 1;
2740 }
2741
2742
2743 /*
2744  * Write an already formatted key_menu to the screen
2745  *
2746  * Args: km     -- key_menu structure
2747  *       bm     -- bitmap, 0's mean don't draw this key
2748  *       row    -- the row on the screen to begin on, negative values
2749  *                 are counted from the bottom of the screen up
2750  *       column -- column on the screen to begin on
2751  *
2752  * The bits in the bitmap are used from least significant to most significant,
2753  * not left to right.  So, if you write out the bitmap in the normal way, for
2754  * example,
2755  * bm[0] = 0x5, bm[1] = 0x8, bm[2] = 0x21, bm[3] = bm[4] = bm[5] = 0
2756  *   0000 0101    0000 1000    0010 0001   ...
2757  * means that menu item 0 (first row, first column) is set, item 1 (2nd row,
2758  * first column) is not set, item 2 is set, items 3-10 are not set, item 11
2759  * (2nd row, 6th and last column) is set.  In the second menu (the second set
2760  * of 12 bits) items 0-3 are unset, 4 is set, 5-8 unset, 9 set, 10-11 unset.
2761  * That uses up bm[0] - bm[2].
2762  * Just to make sure, here it is drawn out for the first set of 12 items in
2763  * the first keymenu (0-11)
2764  *    bm[0] x x x x  x x x x   bm[1] x x x x  x x x x
2765  *          7 6 5 4  3 2 1 0                 1110 9 8
2766  */
2767 void
2768 output_keymenu(struct key_menu *km, unsigned char *bm, int row, int column)
2769 {
2770 #ifdef __CYGWIN__
2771     extern char term_name[];
2772 #endif
2773     register struct key *k;
2774     struct key          *last_time;
2775     int                  i, j,
2776                          ufk,        /* using function keys */
2777                          real_row,
2778                          max_column, /* number of columns on screen */
2779                          off;        /* offset into keymap */
2780     struct variable *vars = ps_global->vars;
2781     COLOR_PAIR          *lastc=NULL, *label_color=NULL, *name_color=NULL;
2782 #ifdef  MOUSE
2783                         /* 6's are for UTF-8 */
2784     char                 keystr[6*MAX_KEYNAME + 6*MAX_LABEL + 2];
2785 #endif
2786
2787     off           = km->which * 12;
2788     max_column    = ps_global->ttyo->screen_cols;
2789
2790     if((ps_global->ttyo->screen_rows - FOOTER_ROWS(ps_global)) < 0
2791        || max_column <= 0){
2792         keymenu_is_dirty = 1;
2793         return;
2794     }
2795
2796
2797     real_row = row > 0 ? row : ps_global->ttyo->screen_rows + row;
2798
2799     if(pico_usingcolor()){
2800         lastc = pico_get_cur_color();
2801         if(lastc && VAR_KEYLABEL_FORE_COLOR && VAR_KEYLABEL_BACK_COLOR &&
2802            pico_is_good_color(VAR_KEYLABEL_FORE_COLOR) &&
2803            pico_is_good_color(VAR_KEYLABEL_BACK_COLOR)){
2804             label_color = new_color_pair(VAR_KEYLABEL_FORE_COLOR,
2805                                          VAR_KEYLABEL_BACK_COLOR);
2806             if(label_color)
2807               (void)pico_set_colorp(label_color, PSC_NONE);
2808         }
2809
2810         if(label_color && VAR_KEYNAME_FORE_COLOR && VAR_KEYNAME_BACK_COLOR &&
2811            pico_is_good_color(VAR_KEYNAME_FORE_COLOR) &&
2812            pico_is_good_color(VAR_KEYNAME_BACK_COLOR)){
2813             name_color = new_color_pair(VAR_KEYNAME_FORE_COLOR,
2814                                         VAR_KEYNAME_BACK_COLOR);
2815         }
2816     }
2817
2818     if(keymenu_is_dirty){
2819         ClearLines(real_row, real_row+1);
2820         keymenu_is_dirty = 0;
2821         /* first time through, set up storage */
2822         if(!last_time_buf[0].name){
2823             for(i = 0; i < 12; i++){
2824                 last_time = &last_time_buf[i];
2825                 last_time->name  = (char *) fs_get(6*MAX_KEYNAME + 1);
2826                 last_time->label = (char *) fs_get(6*MAX_LABEL + 1);
2827             }
2828         }
2829
2830         for(i = 0; i < 12; i++)
2831           last_time_buf[i].column = -1;
2832     }
2833
2834     for(i = 0; i < 12; i++){
2835         int e;
2836
2837         e = off + i;
2838         dprint((9, "%2d %-7.7s %-10.10s %d\n", i,
2839                    km == NULL ? "(no km)"
2840                    : km->keys[e].name == NULL ? "(null)"
2841                    : km->keys[e].name,
2842                    km == NULL ? "(no km)"
2843                    : km->keys[e].label == NULL ? "(null)"
2844                    : km->keys[e].label, km ? km->keys[e].column : 0));
2845 #ifdef  MOUSE
2846         register_key(i, NO_OP_COMMAND, "", NULL, 0, 0, 0, NULL, NULL);
2847 #endif
2848     }
2849
2850     ufk = F_ON(F_USE_FK, ps_global);
2851     dprint((9, "row: %d, real_row: %d, column: %d\n", row,
2852                real_row, column));
2853
2854     for(i = 0; i < 2; i++){
2855         int   c, el, empty, fkey, last_in_row, fix_start;
2856         short next_col;
2857         char  temp[6*MAX_SCREEN_COLS+1];
2858         char  temp2[6*MAX_SCREEN_COLS+1];
2859         char  this_label[6*MAX_LABEL+1];
2860
2861         j = 6*i - 1;
2862 #ifndef __CYGWIN__
2863         if(i == 1 && !label_color)
2864 #else
2865         if(i == 1 && (!label_color || !struncmp(term_name,"cygwin", 6)))
2866 #endif
2867           max_column--;  /* Some terminals scroll if you write in the
2868                             lower right hand corner. If user has a
2869                             label_color set we'll take our chances.
2870                             Otherwise, we'd get one cell of Normal. */
2871
2872         /*
2873          * k is the key struct we're working on
2874          * c is the column number
2875          * el is an index into the whole keys array
2876          * Last_time_buf is ordered strangely. It goes row by row instead
2877          * of down each column like km does. J is an index into it.
2878          */
2879         for(c = 0, el = off+i, k = &km->keys[el];
2880             k < &km->keys[off+12] && c < max_column;
2881             k += 2, el += 2){
2882
2883             if(k->column > max_column)
2884               break;
2885
2886             j++;
2887             if(ufk)
2888               fkey = 1 + k - &km->keys[off];
2889
2890             empty     = (!bitnset(el,bm) || !(k->name && *k->name));
2891             last_time = &last_time_buf[j];
2892             if(k+2 < &km->keys[off+12]){
2893                 last_in_row = 0;
2894                 next_col    = last_time_buf[j+1].column;
2895                 fix_start = (k == &km->keys[off] ||
2896                              k == &km->keys[off+1]) ? k->column : 0;
2897             }
2898             else{
2899                 last_in_row = 1;
2900                 fix_start = 0;
2901             }
2902
2903             /*
2904              * Make sure there is a space between this label and
2905              * the next name. That is, we prefer a space to the
2906              * extra character of the label because the space
2907              * separates the commands and looks nicer.
2908              */
2909             if(k->label){
2910                 size_t l;
2911                 char tmp_label[6*MAX_LABEL+1];
2912
2913                 if(k->label[0] == '[' && k->label[(l=strlen(k->label))-1] == ']' && l > 2){
2914                     /*
2915                      * Can't write in k->label, which might be a constant array.
2916                      */
2917                     strncpy(tmp_label, &k->label[1], MIN(sizeof(tmp_label),l-2));
2918                     tmp_label[MIN(sizeof(tmp_label)-1,l-2)] = '\0';
2919
2920                     snprintf(this_label, sizeof(this_label), "[%s]", _(tmp_label));
2921                 }
2922                 else
2923                   strncpy(this_label, _(k->label), sizeof(this_label));
2924
2925                 this_label[sizeof(this_label)-1] = '\0';
2926                 if(!last_in_row){
2927                     int trunc;
2928
2929                     trunc = (k+2)->column - k->column
2930                                      - ((k->name ? utf8_width(k->name) : 0) + 1);
2931                     /*
2932                      * trunc columns available for label but we don't want the label
2933                      * to go all the way to the edge
2934                      */
2935                     if(utf8_width(this_label) >= trunc){
2936                         if(trunc > 1){
2937                             strncpy(tmp_label, this_label, sizeof(tmp_label));
2938                             tmp_label[sizeof(tmp_label)-1] = '\0';
2939                             l = utf8_pad_to_width(this_label, tmp_label, sizeof(this_label)-2, trunc-1, 1);
2940                             this_label[l++] = SPACE;
2941                             this_label[l] = '\0';;
2942                         }
2943                         else if(trunc == 1)
2944                           this_label[0] = SPACE;
2945                         else
2946                           this_label[0] = '\0';
2947
2948                         this_label[sizeof(this_label)-1] = '\0';
2949                     }
2950                 }
2951             }
2952             else
2953               this_label[0] = '\0';
2954
2955             if(!(k->column == last_time->column
2956                  && (last_in_row || (k+2)->column <= next_col)
2957                  && ((empty && !*last_time->label && !*last_time->name)
2958                      || (!empty
2959                          && this_label && !strcmp(this_label,last_time->label)
2960                          && ((k->name && !strcmp(k->name,last_time->name))
2961                              || ufk))))){
2962                 if(empty){
2963                     /* blank out key with spaces */
2964                     strncpy(temp, repeat_char(
2965                                     ((last_in_row || (k+2)->column > max_column)
2966                                          ? max_column
2967                                          : (k+2)->column) -
2968                                      (fix_start
2969                                          ? 0
2970                                          : k->column),
2971                                          SPACE), sizeof(temp));
2972                     temp[sizeof(temp)-1] = '\0';
2973                     last_time->column  = k->column;
2974                     *last_time->name   = '\0';
2975                     *last_time->label  = '\0';
2976                     MoveCursor(real_row + i, column + (fix_start ? 0 : k->column));
2977                     Write_to_screen(temp);
2978                     c = (fix_start ? 0 : k->column) + strlen(temp);
2979                 }
2980                 else{
2981                     /* make sure extra space before key name is there */
2982                     if(fix_start){
2983                         strncpy(temp, repeat_char(k->column, SPACE), sizeof(temp));
2984                         temp[sizeof(temp)-1] = '\0';
2985                         MoveCursor(real_row + i, column + 0);
2986                         Write_to_screen(temp);
2987                     }
2988
2989                     /* short name of the key */
2990                     if(ufk)
2991                       snprintf(temp, sizeof(temp), "F%d", fkey);
2992                     else
2993                       strncpy(temp, k->name, sizeof(temp));
2994
2995                     temp[sizeof(temp)-1] = '\0';
2996                     last_time->column = k->column;
2997                     strncpy(last_time->name, temp, 6*MAX_KEYNAME);
2998                     last_time->name[6*MAX_KEYNAME] = '\0';
2999                     /* make sure name not too long */
3000 #ifdef  MOUSE
3001                     strncpy(keystr, temp, sizeof(keystr));
3002                     keystr[sizeof(keystr)-1] = '\0';
3003 #endif
3004                     MoveCursor(real_row + i, column + k->column);
3005                     if(!empty){
3006                         if(name_color)
3007                           (void)pico_set_colorp(name_color, PSC_NONE);
3008                         else
3009                           StartInverse();
3010                     }
3011
3012                     Write_to_screen(temp);
3013                     c = k->column + utf8_width(temp);
3014                     if(!empty){
3015                         if(!name_color)
3016                           EndInverse();
3017                     }
3018
3019                     /* now the space after the name and the label */
3020                     temp[0] = '\0';
3021                     if(c < max_column){
3022                         temp[0] = SPACE;
3023                         temp[1] = '\0';
3024                         strncat(temp, this_label, sizeof(temp)-strlen(temp)-1);
3025
3026                         /* Don't run over the right hand edge */
3027                         if(utf8_width(temp) > max_column - c){
3028                             size_t l;
3029
3030                             l = utf8_pad_to_width(temp2, temp, sizeof(temp2)-1, max_column-c, 1);
3031                             temp2[l] = '\0';
3032                             strncpy(temp, temp2, sizeof(temp));
3033                             temp[sizeof(temp)-1] = '\0';
3034                         }
3035
3036                         c += utf8_width(temp);
3037                     }
3038
3039 #ifdef  MOUSE
3040                     strncat(keystr, temp, sizeof(keystr)-strlen(keystr)-1);
3041                     keystr[sizeof(keystr)-1] = '\0';
3042 #endif
3043                     /* fill out rest of this key with spaces */
3044                     if(c < max_column){
3045                         if(last_in_row){
3046                             strncat(temp, repeat_char(max_column - c, SPACE), sizeof(temp)-strlen(temp)-1);
3047                             c = max_column;
3048                         }
3049                         else{
3050                             if(c < (k+2)->column){
3051                                 strncat(temp,
3052                                     repeat_char((k+2)->column - c, SPACE), sizeof(temp)-strlen(temp)-1);
3053                                 c = (k+2)->column;
3054                             }
3055                         }
3056
3057                         temp[sizeof(temp)-1] = '\0';
3058                     }
3059
3060                     strncpy(last_time->label, this_label, 6*MAX_LABEL);
3061                     last_time->label[6*MAX_LABEL] = '\0';
3062                     if(label_color)
3063                       (void)pico_set_colorp(label_color, PSC_NONE);
3064
3065                     Write_to_screen(temp);
3066                 }
3067             }
3068 #ifdef  MOUSE
3069             else if(!empty)
3070               /* fill in what register_key needs from cached data */
3071               snprintf(keystr, sizeof(keystr), "%s %s", last_time->name, last_time->label);
3072
3073             if(!empty){
3074               int len;
3075
3076               /*
3077                * If label ends in space,
3078                * don't register the space part of label.
3079                */
3080               len = strlen(keystr);
3081               while(keystr[len-1] == SPACE)
3082                 len--;
3083                 len--;
3084
3085               register_key(j, ufk ? PF1 + fkey - 1
3086                                   : (k->name[0] == '^')
3087                                     ? ctrl(k->name[1])
3088                                     : (!strucmp(k->name, "ret"))
3089                                       ? ctrl('M')
3090                                       : (!strucmp(k->name, "tab"))
3091                                         ? '\t'
3092                                         : (!strucmp(k->name, "spc"))
3093                                           ? SPACE
3094                                             : (!strucmp(k->name, HISTORY_UP_KEYNAME))
3095                                               ? KEY_UP
3096                                               : (!strucmp(k->name, HISTORY_DOWN_KEYNAME))
3097                                                 ? KEY_DOWN
3098                                                 : (k->bind.nch)
3099                                                   ? ((isascii((int) k->bind.ch[0]) && islower((int) k->bind.ch[0]))
3100                                                        ? toupper((unsigned char) k->bind.ch[0])
3101                                                        : k->bind.ch[0])
3102                                                   : k->name[0],
3103                            keystr, print_inverted_label,
3104                            real_row+i, k->column, len,
3105                            name_color, label_color);
3106             }
3107 #endif
3108
3109         }
3110
3111         while(++j < 6*(i+1))
3112           last_time_buf[j].column = -1;
3113     }
3114
3115     fflush(stdout);
3116     if(lastc){
3117         (void)pico_set_colorp(lastc, PSC_NONE);
3118         free_color_pair(&lastc);
3119         if(label_color)
3120           free_color_pair(&label_color);
3121         if(name_color)
3122           free_color_pair(&name_color);
3123     }
3124 }
3125
3126
3127 /*
3128  * Clear the key menu lines.
3129  */
3130 void
3131 blank_keymenu(int row, int column)
3132 {
3133     struct variable *vars = ps_global->vars;
3134     COLOR_PAIR *lastc;
3135
3136     if(FOOTER_ROWS(ps_global) > 1){
3137         km_state.blanked    = 1;
3138         km_state.row        = row;
3139         km_state.column     = column;
3140         MoveCursor(row, column);
3141         lastc = pico_set_colors(VAR_KEYLABEL_FORE_COLOR,
3142                                 VAR_KEYLABEL_BACK_COLOR, PSC_NORM|PSC_RET);
3143
3144         CleartoEOLN();
3145         MoveCursor(row+1, column);
3146         CleartoEOLN();
3147         fflush(stdout);
3148         if(lastc){
3149             (void)pico_set_colorp(lastc, PSC_NONE);
3150             free_color_pair(&lastc);
3151         }
3152     }
3153 }
3154
3155
3156 void
3157 draw_cancel_keymenu(void)
3158 {
3159     bitmap_t   bitmap;
3160
3161     setbitmap(bitmap);
3162     draw_keymenu(&cancel_keymenu, bitmap, ps_global->ttyo->screen_cols,
3163                  1-FOOTER_ROWS(ps_global), 0, FirstMenu);
3164 }
3165
3166
3167 void
3168 clearfooter(struct pine *ps)
3169 {
3170     ClearLines(ps->ttyo->screen_rows - 3, ps->ttyo->screen_rows - 1);
3171     mark_keymenu_dirty();
3172     mark_status_unknown();
3173 }
3174
3175
3176 /*
3177  * Calculate formatting for key menu at bottom of screen
3178  *
3179  * Args:  km    -- The key_menu structure to format
3180  *        bm    -- Bitmap indicating which menu items should be displayed.  If
3181  *                 an item is NULL, that also means it shouldn't be displayed.
3182  *                 Sometimes the bitmap will be turned on in that case and just
3183  *                 rely on the NULL entry.
3184  *        width -- the screen width to format it at
3185  *
3186  * If already formatted for this particular screen width and the requested
3187  * bitmap and formatted bitmap agree, return.
3188  *
3189  * The formatting results in the column field in the key_menu being
3190  * filled in.  The column field is the column to start the label at, the
3191  * name of the key; after that is the label for the key.  The basic idea
3192  * is to line up the end of the names and beginning of the labels.  If
3193  * the name is too long and shifting it left would run into previous
3194  * label, then shift the whole menu right, or at least that entry if
3195  * things following are short enough to fit back into the regular
3196  * spacing.  This has to be calculated and not fixed so it can cope with
3197  * screen resize.
3198  */
3199 void
3200 format_keymenu(struct key_menu *km, unsigned char *bm, int width)
3201 {
3202     int spacing[7], w[6], min_w[6], tw[6], extra[6], ufk, i, set;
3203
3204     /* already formatted? */
3205     if(!km || (width == km->width &&
3206                km->how_many <= km->formatted_hm &&
3207                !memcmp(km->bitmap, bm, BM_SIZE)))
3208       return;
3209
3210     /*
3211      * If we're in the initial command sequence we may be using function
3212      * keys instead of alphas, or vice versa, so we want to recalculate
3213      * the formatting next time through.
3214      */
3215     if((F_ON(F_USE_FK,ps_global) && ps_global->orig_use_fkeys) ||
3216         (F_OFF(F_USE_FK,ps_global) && !ps_global->orig_use_fkeys)){
3217         km->width        = width;
3218         km->formatted_hm = km->how_many;
3219         memcpy(km->bitmap, bm, BM_SIZE);
3220     }
3221
3222     ufk = F_ON(F_USE_FK,ps_global);     /* ufk = "Using Function Keys" */
3223
3224     /* set up "ideal" columns to start in, plus fake 7th column start */
3225     for(i = 0; i < 7; i++)
3226       spacing[i] = (i * width) / 6;
3227
3228     /* Loop thru each set of 12 menus */
3229     for(set = 0; set < km->how_many; set++){
3230         int         k_top, k_bot, top_name_width, bot_name_width,
3231                     top_label_width, bot_label_width, done, offset, next_one;
3232         struct key *keytop, *keybot;
3233
3234         offset = set * 12;              /* offset into keymenu */
3235
3236         /*
3237          * Find the required widths for each box.
3238          */
3239         for(i = 0; i < 6; i++){
3240             k_top  = offset + i*2;
3241             k_bot  = k_top + 1;
3242             keytop = &km->keys[k_top];
3243             keybot = &km->keys[k_bot];
3244
3245             /*
3246              * The width of a box is the max width of top or bottom name,
3247              * plus 1 space, plus the max width of top or bottom label.
3248              *
3249              *     ? HelpInfo
3250              *    ^C Cancel
3251              *    |||||||||||  = 2 + 1 + 8 = 11
3252              *
3253              * Then we adjust that by adding one space after the box to
3254              * separate it from the next box. The last box doesn't need that
3255              * but we may need an extra space for last box to avoid putting
3256              * a character in the lower right hand cell of display.
3257              * We also have a minimum label width (if screen is really narrow)
3258              * of 3, so at least "Hel" and "Can" shows and the rest gets
3259              * truncated off right hand side.
3260              */
3261
3262             top_name_width = (keytop->name && bitnset(k_top,bm))
3263                                      ? (ufk ? (i >= 5 ? 3 : 2)
3264                                             : utf8_width(keytop->name)) : 0;
3265             bot_name_width = (keybot->name && bitnset(k_bot,bm))
3266                                      ? (ufk ? (i >= 4 ? 3 : 2)
3267                                             : utf8_width(keybot->name)) : 0;
3268             /*
3269              * Labels are complicated by the fact that we want to look
3270              * up their translation, but also by the fact that we surround
3271              * the word with brackets like [ViewMsg] when the command is
3272              * the default. We want to look up the translation of the
3273              * part inside the brackets, not the whole thing.
3274              */
3275             if(keytop->label && bitnset(k_top,bm)){
3276                 char tmp_label[6*MAX_LABEL+1];
3277                 size_t l;
3278
3279                 if(keytop->label[0] == '[' && keytop->label[(l=strlen(keytop->label))-1] == ']' && l > 2){
3280                     /*
3281                      * Can't write in k->label, which might be a constant array.
3282                      */
3283                     strncpy(tmp_label, &keytop->label[1], MIN(sizeof(tmp_label),l-2));
3284                     tmp_label[MIN(sizeof(tmp_label)-1,l-2)] = '\0';
3285
3286                     top_label_width = 2 + utf8_width(_(tmp_label));
3287                 }
3288                 else
3289                   top_label_width = utf8_width(_(keytop->label));
3290             }
3291             else
3292               top_label_width = 0;
3293
3294             if(keybot->label && bitnset(k_bot,bm)){
3295                 char tmp_label[6*MAX_LABEL+1];
3296                 size_t l;
3297
3298                 if(keybot->label[0] == '[' && keybot->label[(l=strlen(keybot->label))-1] == ']' && l > 2){
3299                     strncpy(tmp_label, &keybot->label[1], MIN(sizeof(tmp_label),l-2));
3300                     tmp_label[MIN(sizeof(tmp_label)-1,l-2)] = '\0';
3301
3302                     bot_label_width = 2 + utf8_width(_(tmp_label));
3303                 }
3304                 else
3305                   bot_label_width = utf8_width(_(keybot->label));
3306             }
3307             else
3308               bot_label_width = 0;
3309
3310             /*
3311              * The 1 for i < 5 is the space between adjacent boxes.
3312              * The last 1 or 0 when i == 5 is so that we won't try to put
3313              * a character in the lower right cell of the display, since that
3314              * causes a linefeed on some terminals.
3315              */
3316             w[i] = MAX(top_name_width, bot_name_width) + 1 +
3317                    MAX(top_label_width, bot_label_width) +
3318                    ((i < 5) ? 1
3319                            : ((bot_label_width >= top_label_width) ? 1 : 0));
3320
3321             /*
3322              * The smallest we'll squeeze a column.
3323              *
3324              *    X ABCDEF we'll squeeze to   X ABC
3325              *   YZ GHIJ                     YZ GHI
3326              */
3327             min_w[i] = MAX(top_name_width, bot_name_width) + 1 +
3328                        MIN(MAX(top_label_width, bot_label_width), 3) +
3329                      ((i < 5) ? 1
3330                               : ((bot_label_width >= top_label_width) ? 1 : 0));
3331
3332             /* init trial width */
3333             tw[i] = spacing[i+1] - spacing[i];
3334             extra[i] = tw[i] - w[i];    /* negative if it doesn't fit */
3335         }
3336
3337         /*
3338          * See if we can fit everything on the screen.
3339          */
3340         done = 0;
3341         while(!done){
3342             int smallest_extra, how_small;
3343
3344             /* Find smallest extra */
3345             smallest_extra = -1;
3346             how_small = 100;
3347             for(i = 0; i < 6; i++){
3348                 if(extra[i] < how_small){
3349                     smallest_extra = i;
3350                     how_small = extra[i];
3351                 }
3352             }
3353
3354             if(how_small >= 0)                  /* everything fits */
3355               done++;
3356             else{
3357                 int take_from, how_close;
3358
3359                 /*
3360                  * Find the one that is closest to the ideal width
3361                  * that has some extra to spare.
3362                  */
3363                 take_from = -1;
3364                 how_close = 100;
3365                 for(i = 0; i < 6; i++){
3366                     if(extra[i] > 0 &&
3367                        ((spacing[i+1]-spacing[i]) - tw[i]) < how_close){
3368                         take_from = i;
3369                         how_close = (spacing[i+1]-spacing[i]) - tw[i];
3370                     }
3371                 }
3372
3373                 if(take_from >= 0){
3374                     /*
3375                      * Found one. Take one from take_from and add it
3376                      * to the smallest_extra.
3377                      */
3378                     tw[smallest_extra]++;
3379                     extra[smallest_extra]++;
3380                     tw[take_from]--;
3381                     extra[take_from]--;
3382                 }
3383                 else{
3384                     int used_width;
3385
3386                     /*
3387                      * Oops. Not enough space to fit everything in.
3388                      * Some of the labels are truncated. Some may even be
3389                      * truncated past the minimum. We make sure that each
3390                      * field is at least its minimum size, and then we cut
3391                      * back those over the minimum until we can fit all the
3392                      * minimal names on the screen (if possible).
3393                      */
3394                     for(i = 0; i < 6; i++)
3395                       tw[i] = MAX(tw[i], min_w[i]);
3396
3397                     used_width = 0;
3398                     for(i = 0; i < 6; i++)
3399                       used_width += tw[i];
3400
3401                     while(used_width > width && !done){
3402                         int candidate, excess;
3403
3404                         /*
3405                          * Find the one with the most width over it's
3406                          * minimum width.
3407                          */
3408                         candidate = -1;
3409                         excess = -100;
3410                         for(i = 0; i < 6; i++){
3411                             if(tw[i] - min_w[i] > excess){
3412                                 candidate = i;
3413                                 excess = tw[i] - min_w[i];
3414                             }
3415                         }
3416
3417                         if(excess > 0){
3418                             tw[candidate]--;
3419                             used_width--;
3420                         }
3421                         else
3422                           done++;
3423                     }
3424
3425                     done++;
3426                 }
3427             }
3428         }
3429
3430         /*
3431          * Assign the format we came up with to the keymenu.
3432          */
3433         next_one = 0;
3434         for(i = 0; i < 6; i++){
3435             k_top  = offset + i*2;
3436             k_bot  = k_top + 1;
3437             keytop = &km->keys[k_top];
3438             keybot = &km->keys[k_bot];
3439             top_name_width = (keytop->name && bitnset(k_top,bm))
3440                                      ? (ufk ? (i >= 5 ? 3 : 2)
3441                                             : utf8_width(keytop->name)) : 0;
3442             bot_name_width = (keybot->name && bitnset(k_bot,bm))
3443                                      ? (ufk ? (i >= 4 ? 3 : 2)
3444                                             : utf8_width(keybot->name)) : 0;
3445
3446             if(top_name_width >= bot_name_width){
3447                 keytop->column = next_one;
3448                 keybot->column = next_one + (top_name_width - bot_name_width);
3449             }
3450             else{
3451                 keytop->column = next_one + (bot_name_width - top_name_width);
3452                 keybot->column = next_one;
3453             }
3454
3455             next_one += tw[i];
3456         }
3457     }
3458 }
3459
3460
3461 /*
3462  * Draw the key menu at bottom of screen
3463  *
3464  * Args:  km     -- key_menu structure
3465  *        bitmap -- which fields are active
3466  *        width  -- the screen width to format it at
3467  *        row    -- where to put it
3468  *        column -- where to put it
3469  *        what   -- this is an enum telling us whether to display the
3470  *                  first menu (first set of 12 keys), or to display the same
3471  *                  one we displayed last time, or to display a particular
3472  *                  one (which), or to display the next one.
3473  *
3474  * Fields are inactive if *either* the corresponding bitmap entry is 0 *or*
3475  * the actual entry in the key_menu is NULL.  Therefore, it is sometimes
3476  * useful to just turn on all the bits in a bitmap and let the NULLs take
3477  * care of it.  On the other hand, the bitmap gives a convenient method
3478  * for turning some keys on or off dynamically or due to options.
3479  * Both methods are used about equally.
3480  *
3481  * Also saves the state for a possible redraw later.
3482  *
3483  * Row should usually be a negative number.  If row is 0, the menu is not
3484  * drawn.
3485  */
3486 void
3487 draw_keymenu(struct key_menu *km, unsigned char *bitmap, int width, int row,
3488              int column, OtherMenu what)
3489 {
3490 #ifdef _WINDOWS
3491     configure_menu_items (km, bitmap);
3492 #endif
3493     format_keymenu(km, bitmap, width);
3494
3495     /*--- save state for a possible redraw ---*/
3496     km_state.km         = km;
3497     km_state.row        = row;
3498     km_state.column     = column;
3499     memcpy(km_state.bitmap, bitmap, BM_SIZE);
3500
3501     if(row == 0)
3502       return;
3503
3504     if(km_state.blanked)
3505       keymenu_is_dirty = 1;
3506
3507     if(what == FirstMenu || what == SecondMenu || what == ThirdMenu ||
3508        what == FourthMenu || what == MenuNotSet){
3509         if(what == FirstMenu || what == MenuNotSet)
3510           km->which = 0;
3511         else if(what == SecondMenu)
3512           km->which = 1;
3513         else if(what == ThirdMenu)
3514           km->which = 2;
3515         else if(what == FourthMenu)
3516           km->which = 3;
3517
3518         if(km->which >= km->how_many)
3519           km->which = 0;
3520     }
3521     else if(what == NextMenu)
3522       km->which = (km->which + 1) % km->how_many;
3523     /* else what must be SameMenu */
3524
3525     output_keymenu(km, bitmap, row, column);
3526
3527     km_state.blanked    = 0;
3528 }
3529
3530
3531 void
3532 redraw_keymenu(void)
3533 {
3534     if(km_state.blanked)
3535       blank_keymenu(km_state.row, km_state.column);
3536     else
3537       draw_keymenu(km_state.km, km_state.bitmap, ps_global->ttyo->screen_cols,
3538                    km_state.row, km_state.column, SameMenu);
3539 }
3540
3541
3542 /*
3543  * end_keymenu - free resources associated with keymenu display cache
3544  */
3545 void
3546 end_keymenu(void)
3547 {
3548     int i;
3549
3550     for(i = 0; i < 12; i++){
3551         if(last_time_buf[i].name)
3552           fs_give((void **) &last_time_buf[i].name);
3553
3554         if(last_time_buf[i].label)
3555           fs_give((void **) &last_time_buf[i].label);
3556     }
3557 }
3558
3559
3560 /*----------------------------------------------------------------------
3561    Reveal Keymenu to Pine Command mappings
3562
3563   Args:
3564
3565  ----*/
3566 int
3567 menu_command(UCS keystroke, struct key_menu *menu)
3568 {
3569     int i, n;
3570
3571     if(keystroke == KEY_UTF8 || keystroke == KEY_UNKNOWN)
3572       return(MC_UTF8);
3573
3574     if(!menu)
3575       return(MC_UNKNOWN);
3576
3577     if(F_ON(F_USE_FK,ps_global)){
3578         /* No alpha commands permitted in function key mode */
3579         if(keystroke < 0x80 && isalpha((unsigned char) keystroke))
3580           return(MC_UNKNOWN);
3581
3582         /* Tres simple: compute offset, and test */
3583         if(keystroke >= F1 && keystroke <= F12){
3584             n = (menu->which * 12) + (keystroke - F1);
3585             if(bitnset(n, menu->bitmap))
3586               return(menu->keys[n].bind.cmd);
3587         }
3588     }
3589     else if(keystroke >= F1 && keystroke <= F12)
3590       return(MC_UNKNOWN);
3591
3592     /* if ascii, coerce lower case */
3593     if(keystroke < 0x80 && isupper((unsigned char) keystroke))
3594       keystroke = tolower((unsigned char) keystroke);
3595
3596     /* keep this here for Windows port */
3597     if((keystroke = validatekeys(keystroke)) == KEY_JUNK)
3598       return(MC_UNKNOWN);
3599
3600     /* Scan the list for any keystroke/command binding */
3601     if(keystroke != NO_OP_COMMAND)
3602       for(i = (menu->how_many * 12) - 1;  i >= 0; i--)
3603         if(bitnset(i, menu->bitmap))
3604           for(n = menu->keys[i].bind.nch - 1; n >= 0; n--)
3605             if(keystroke == menu->keys[i].bind.ch[n])
3606               return(menu->keys[i].bind.cmd);
3607
3608     /*
3609      * If explicit mapping failed, check feature mappings and
3610      * hardwired defaults...
3611      */
3612     if(F_ON(F_ENABLE_PRYNT,ps_global)
3613         && (keystroke == 'y' || keystroke == 'Y')){
3614         /* SPECIAL CASE: Scan the list for print bindings */
3615         for(i = (menu->how_many * 12) - 1;  i >= 0; i--)
3616           if(bitnset(i, menu->bitmap))
3617             if(menu->keys[i].bind.cmd == MC_PRINTMSG
3618                || menu->keys[i].bind.cmd == MC_PRINTTXT)
3619               return(menu->keys[i].bind.cmd);
3620     }
3621
3622     if(F_ON(F_ENABLE_LESSTHAN_EXIT,ps_global)
3623        && (keystroke == '<' || keystroke == ','
3624            || (F_ON(F_ARROW_NAV,ps_global) && keystroke == KEY_LEFT))){
3625         /* SPECIAL CASE: Scan the list for MC_EXIT bindings */
3626         for(i = (menu->how_many * 12) - 1;  i >= 0; i--)
3627           if(bitnset(i, menu->bitmap))
3628             if(menu->keys[i].bind.cmd == MC_EXIT)
3629               return(MC_EXIT);
3630     }
3631
3632     /*
3633      * If no match after scanning bindings, try universally
3634      * bound keystrokes...
3635      */
3636     switch(keystroke){
3637       case KEY_MOUSE :
3638         return(MC_MOUSE);
3639
3640       case ctrl('P') :
3641       case KEY_UP :
3642         return(MC_CHARUP);
3643
3644       case ctrl('N') :
3645       case KEY_DOWN :
3646         return(MC_CHARDOWN);
3647
3648       case ctrl('F') :
3649       case KEY_RIGHT :
3650         return(MC_CHARRIGHT);
3651
3652       case ctrl('B') :
3653       case KEY_LEFT :
3654         return(MC_CHARLEFT);
3655
3656       case ctrl('A') :
3657         return(MC_GOTOBOL);
3658
3659       case ctrl('E') :
3660         return(MC_GOTOEOL);
3661
3662       case  ctrl('L') :
3663         return(MC_REPAINT);
3664
3665       case KEY_RESIZE :
3666         return(MC_RESIZE);
3667
3668       case NO_OP_IDLE:
3669       case NO_OP_COMMAND:
3670         if(USER_INPUT_TIMEOUT(ps_global))
3671           user_input_timeout_exit(ps_global->hours_to_timeout); /* no return */
3672
3673         return(MC_NONE);
3674
3675       default :
3676         break;
3677     }
3678
3679     return(MC_UNKNOWN);                 /* utter failure */
3680 }
3681
3682
3683
3684 /*----------------------------------------------------------------------
3685    Set up a binding for cmd, with one key bound to it.
3686    Use menu_add_binding to add more keys to this binding.
3687
3688   Args: menu   -- the keymenu
3689         key    -- the initial key to bind to
3690         cmd    -- the command to initialize to
3691         name   -- a pointer to the string to point name to
3692         label  -- a pointer to the string to point label to
3693         keynum -- which key in the keys array to initialize
3694
3695     For translation purposes, the label in the calling routine
3696     should be wrapped in an N_() macro.
3697
3698  ----*/
3699 void
3700 menu_init_binding(struct key_menu *menu, UCS key, int cmd, char *name, char *label, int keynum)
3701 {
3702     /* if ascii, coerce to lower case */
3703     if(key < 0x80 && isupper((unsigned char)key))
3704       key = tolower((unsigned char)key);
3705
3706     /* remove binding from any other key */
3707     menu_clear_cmd_binding(menu, cmd);
3708
3709     menu->keys[keynum].name     = name;
3710     menu->keys[keynum].label    = label;
3711     menu->keys[keynum].bind.cmd = cmd;
3712     menu->keys[keynum].bind.nch = 0;
3713     menu->keys[keynum].bind.ch[menu->keys[keynum].bind.nch++] = key;
3714 }
3715
3716
3717 /*----------------------------------------------------------------------
3718    Add a key/command binding to the given keymenu structure
3719
3720   Args:
3721
3722  ----*/
3723 void
3724 menu_add_binding(struct key_menu *menu, UCS key, int cmd)
3725 {
3726     int i, n;
3727
3728     /* NOTE: cmd *MUST* already have had a binding */
3729     for(i = (menu->how_many * 12) - 1;  i >= 0; i--)
3730       if(menu->keys[i].bind.cmd == cmd){
3731           for(n = menu->keys[i].bind.nch - 1;
3732               n >= 0 && key != menu->keys[i].bind.ch[n];
3733               n--)
3734             ;
3735
3736           /* if ascii, coerce to lower case */
3737           if(key < 0x80 && isupper((unsigned char)key))
3738             key = tolower((unsigned char)key);
3739
3740           if(n < 0)             /* not already bound, bind it */
3741             menu->keys[i].bind.ch[menu->keys[i].bind.nch++] = key;
3742
3743           break;
3744       }
3745 }
3746
3747
3748 /*----------------------------------------------------------------------
3749    REMOVE a key/command binding from the given keymenu structure
3750
3751   Args:
3752
3753  ----*/
3754 int
3755 menu_clear_binding(struct key_menu *menu, UCS key)
3756 {
3757     int i, n;
3758
3759     /* if ascii, coerce to lower case */
3760     if(key < 0x80 && isupper((unsigned char)key))
3761       key = tolower((unsigned char)key);
3762
3763     for(i = (menu->how_many * 12) - 1;  i >= 0; i--)
3764       for(n = menu->keys[i].bind.nch - 1; n >= 0; n--)
3765         if(key == menu->keys[i].bind.ch[n]){
3766             int cmd = menu->keys[i].bind.cmd;
3767
3768             for(--menu->keys[i].bind.nch; n < menu->keys[i].bind.nch; n++)
3769               menu->keys[i].bind.ch[n] = menu->keys[i].bind.ch[n+1];
3770
3771             return(cmd);
3772         }
3773
3774     return(MC_UNKNOWN);
3775 }
3776
3777
3778 void
3779 menu_clear_cmd_binding(struct key_menu *menu, int cmd)
3780 {
3781     int i;
3782
3783     for(i = (menu->how_many * 12) - 1;  i >= 0; i--){
3784         if(cmd == menu->keys[i].bind.cmd){
3785             menu->keys[i].name     = NULL;
3786             menu->keys[i].label    = NULL;
3787             menu->keys[i].bind.cmd = 0;
3788             menu->keys[i].bind.nch = 0;
3789             menu->keys[i].bind.ch[0] = 0;
3790         }
3791     }
3792 }
3793
3794
3795 int
3796 menu_binding_index(struct key_menu *menu, int cmd)
3797 {
3798     int i;
3799
3800     for(i = 0; i < menu->how_many * 12; i++)
3801       if(cmd == menu->keys[i].bind.cmd)
3802         return(i);
3803
3804     return(-1);
3805 }
3806
3807
3808 #ifdef  MOUSE
3809 /*
3810  * print_inverted_label - highlight the label of the given menu item.
3811  * (callback from pico mouse routines)
3812  *
3813  * So far, this is only
3814  * ever called with the top left row equal to the bottom right row.
3815  * If you change that you probably need to fix it.
3816  */
3817 void
3818 print_inverted_label(int state, MENUITEM *m)
3819 {
3820     unsigned i, j, k;
3821     int      col_offsetwid, col_offsetchars, do_color = 0, skipwid = 0, skipchars = 0, len, c;
3822     char     prename[100];
3823     char     namepart[100];
3824     char     labelpart[100];
3825     char    *lp, *label;
3826     COLOR_PAIR *name_color = NULL, *label_color = NULL, *lastc = NULL;
3827     struct variable *vars = ps_global->vars;
3828
3829     if(m->label &&  (lp=strchr(m->label, ' '))){
3830         char save;
3831
3832         save = *lp;
3833         *lp = '\0';
3834         col_offsetwid = utf8_width(m->label);
3835         col_offsetchars = lp - m->label;
3836         *lp = save;
3837     }
3838     else
3839       col_offsetwid = col_offsetchars = 0;
3840
3841     if(pico_usingcolor() && ((VAR_KEYLABEL_FORE_COLOR &&
3842                               VAR_KEYLABEL_BACK_COLOR) ||
3843                              (VAR_KEYNAME_FORE_COLOR &&
3844                               VAR_KEYNAME_BACK_COLOR))){
3845         lastc = pico_get_cur_color();
3846
3847         if(VAR_KEYNAME_FORE_COLOR && VAR_KEYNAME_BACK_COLOR){
3848             name_color = state ? new_color_pair(VAR_KEYNAME_BACK_COLOR,
3849                                                 VAR_KEYNAME_FORE_COLOR)
3850                                : new_color_pair(VAR_KEYNAME_FORE_COLOR,
3851                                                 VAR_KEYNAME_BACK_COLOR);
3852         }
3853         else if(VAR_REV_FORE_COLOR && VAR_REV_BACK_COLOR)
3854           name_color = new_color_pair(VAR_REV_FORE_COLOR, VAR_REV_BACK_COLOR);
3855
3856         if(VAR_KEYLABEL_FORE_COLOR && VAR_KEYLABEL_BACK_COLOR){
3857             label_color = state ? new_color_pair(VAR_KEYLABEL_BACK_COLOR,
3858                                                  VAR_KEYLABEL_FORE_COLOR)
3859                                 : new_color_pair(VAR_KEYLABEL_FORE_COLOR,
3860                                                  VAR_KEYLABEL_BACK_COLOR);
3861         }
3862         else if(VAR_REV_FORE_COLOR && VAR_REV_BACK_COLOR){
3863             label_color = state ? new_color_pair(VAR_REV_FORE_COLOR,
3864                                                  VAR_REV_BACK_COLOR)
3865                                 : new_color_pair(VAR_NORM_FORE_COLOR,
3866                                                  VAR_NORM_BACK_COLOR);
3867         }
3868
3869         /*
3870          * See if we can grok all these colors. If not, we're going to
3871          * punt and pretend there are no colors at all.
3872          */
3873         if(!pico_is_good_colorpair(name_color) ||
3874            !pico_is_good_colorpair(label_color)){
3875             if(name_color)
3876               free_color_pair(&name_color);
3877             if(label_color)
3878               free_color_pair(&label_color);
3879             if(lastc)
3880               free_color_pair(&lastc);
3881         }
3882         else{
3883             do_color++;
3884             (void)pico_set_colorp(label_color, PSC_NONE);
3885             if(!(VAR_KEYLABEL_FORE_COLOR && VAR_KEYLABEL_BACK_COLOR)){
3886                 if(state)
3887                   StartInverse();
3888                 else
3889                   EndInverse();
3890             }
3891         }
3892     }
3893
3894     if(!do_color){
3895         /*
3896          * Command name's already inverted, leave it.
3897          */
3898         skipwid = state ? 0 : col_offsetwid;
3899         skipchars = state ? 0 : col_offsetchars;
3900         if(state)
3901           StartInverse();
3902         else
3903           EndInverse();
3904     }
3905
3906     MoveCursor((int)(m->tl.r), (int)(m->tl.c) + skipwid);
3907
3908     label = m->label ? m->label : "";
3909     len = strlen(label);
3910
3911     /*
3912      * this is a bit complicated by the fact that we have to keep track of
3913      * the screenwidth as we print the label, because the screenwidth might
3914      * not be the same as the number of characters.
3915 * UNTESTED SINCE switching to UTF-8 *
3916      */
3917     for(i = m->tl.r; i <= m->br.r; i++){
3918       /* collect part before name */
3919       for(k=0, j = m->tl.c + skipchars; j < MIN(m->lbl.c,m->br.c); j++){
3920           if(k < sizeof(prename))
3921             prename[k++] = ' ';
3922       }
3923
3924       if(k < sizeof(prename))
3925         prename[k] = '\0';
3926
3927       /* collect name part */
3928       for(k=0; j < MIN(m->lbl.c+col_offsetchars,m->br.c); j++){
3929           c = (i == m->lbl.r &&
3930                j - m->lbl.c < len) ? label[j - m->lbl.c] : ' ';
3931           if(k < sizeof(namepart))
3932             namepart[k++] = c;
3933       }
3934
3935       if(k < sizeof(namepart))
3936         namepart[k] = '\0';
3937
3938       /* collect label part */
3939       for(k=0; j <= m->br.c; j++){
3940           c = (i == m->lbl.r &&
3941                j - m->lbl.c < len) ? label[j - m->lbl.c] : ' ';
3942           if(k < sizeof(labelpart))
3943           labelpart[k++] = c;
3944       }
3945
3946       if(k < sizeof(labelpart))
3947         labelpart[k] = '\0';
3948     }
3949
3950     if(prename)
3951       Write_to_screen(prename);
3952
3953     if(namepart){
3954         if(name_color && col_offsetchars)
3955           (void) pico_set_colorp(name_color, PSC_NONE);
3956
3957         Write_to_screen(namepart);
3958     }
3959
3960     if(labelpart){
3961         if(name_color && col_offsetchars){
3962           if(label_color)
3963             (void) pico_set_colorp(label_color, PSC_NONE);
3964           else{
3965               if(state)
3966                 StartInverse();
3967               else
3968                 EndInverse();
3969           }
3970         }
3971
3972         Write_to_screen(labelpart);
3973     }
3974
3975     if(do_color){
3976         if(lastc){
3977             (void)pico_set_colorp(lastc, PSC_NONE);
3978             free_color_pair(&lastc);
3979         }
3980         else if(state)
3981           EndInverse();
3982         else
3983           pico_set_normal_color();
3984
3985         if(name_color)
3986           free_color_pair(&name_color);
3987         if(label_color)
3988           free_color_pair(&label_color);
3989     }
3990     else{
3991         if(state)
3992           EndInverse();
3993     }
3994 }
3995 #endif  /* MOUSE */
3996
3997
3998 #ifdef _WINDOWS
3999 /*
4000  * This function scans the key menu and calls mswin.c functions
4001  * to build a corresponding windows menu.
4002  */
4003 void
4004 configure_menu_items (struct key_menu *km, bitmap_t bitmap)
4005 {
4006     int                 i;
4007     struct key          *k;
4008     UCS                 key;
4009
4010     mswin_menuitemclear ();
4011
4012     if(!km)
4013       return;
4014
4015     for (i = 0, k = km->keys ; i < km->how_many * 12; i++, k++) {
4016         if (k->name != NULL && k->label != NULL && bitnset (i, bitmap) &&
4017             k->menuitem != KS_NONE) {
4018
4019             if (k->name[0] == '^')
4020                 key = ctrl(k->name[1]);
4021             else if (strcmp(k->name, "Ret") == 0)
4022                 key = '\r';
4023             else if (strcmp(k->name, "Spc") == 0)
4024                 key = ' ';
4025             else
4026                 key = k->name[0];
4027
4028             mswin_menuitemadd (key, k->label, k->menuitem, 0);
4029         }
4030     }
4031 }
4032 #endif