src/win.c

   1 /* Curses utilities
   2    Copyright (C) 1995 Miguel de Icaza, Janne Kukonlehto
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #include <config.h>
  19 #include "tty.h"
  20 #include <stdio.h>
  21 #include <string.h>
  22 #if (!defined(__IBMC__) && !defined(__IBMCPP__)) && !defined(HAS_NO_TERMIOS_H)
  23 #    include <termios.h>
  24 #endif
  25 #include "global.h"
  26 #include "color.h"
  27 #include "mouse.h"
  28 #include "dlg.h"
  29 #include "widget.h"
  30 #include "win.h"
  31 #include "key.h"                /* XCTRL and ALT macros  */
  32 #include "layout.h"
  33
  34 /* "$Id$" */
  35
  36 #ifndef HAVE_X
  37 typedef void (*fnptr)(void);
  38
  39 typedef struct Fkey_Table_List {
  40     fnptr  actions[11];
  41     struct Fkey_Table_List *next;
  42     int    has_labels;
  43 } Fkey_Table_List;
  44
  45 static Fkey_Table_List *fkey_table_list = NULL;
  46
  47 /* Width of output is always seven characters */
  48 void sprint_bytesize (char *buffer, int size, int scale)
  49 {
  50     char scales[] = " kMGT";
  51
  52     if (size > 0){
  53         while (size > 9999 && scale < sizeof (scales)){
  54             size = (size + 512) / 1024;
  55             scale ++;
  56         }
  57     }
  58     if (scale > 0)
  59         g_snprintf (buffer, 10, "%4d %cb", size, scales[scale]);
  60     else
  61         g_snprintf (buffer, 10, "%4d b ", size);
  62 }
  63
  64 void print_bytesize (int size, int scale)
  65 {
  66     char buffer [10];
  67
  68     sprint_bytesize (buffer, size, scale);
  69     printw (buffer);
  70 }
  71
  72 /* Return values: 0 = not a fkey, other = was a fkey */
  73 int check_fkeys (int c)
  74 {
  75     int fkey;
  76
  77     if (!fkey_table_list)
  78         return 0;
  79
  80     switch (c){
  81     case KEY_F(1):
  82         fkey = 1;
  83         break;
  84     case KEY_F(2):
  85         fkey = 2;
  86         break;
  87     case KEY_F(3):
  88         fkey = 3;
  89         break;
  90     case KEY_F(4):
  91         fkey = 4;
  92         break;
  93     case KEY_F(5):
  94         fkey = 5;
  95         break;
  96     case KEY_F(6):
  97         fkey = 6;
  98         break;
  99     case KEY_F(7):
 100         fkey = 7;
 101         break;
 102     case KEY_F(8):
 103         fkey = 8;
 104         break;
 105     case KEY_F(9):
 106         fkey = 9;
 107         break;
 108     case KEY_F(10):
 109         fkey = 10;
 110         break;
 111     default:
 112         return 0;
 113     }
 114     if (fkey_table_list->actions [fkey]){
 115         fkey_table_list->actions [fkey] ();
 116         return fkey;
 117     }
 118     else
 119         return 0;
 120 }
 121 #endif /* !HAVE_X */
 122
 123 /* Return values: 0 = not a movement key, 1 = was a movement key */
 124 int check_movement_keys (int c, int additional, int page_size, void *data,
 125                          movefn backfn, movefn forfn, movefn topfn,
 126                          movefn bottomfn)
 127 {
 128     switch (c){
 129     case KEY_UP:
 130     case XCTRL ('p'):
 131         (*backfn)(data, 1);
 132         return 1;
 133
 134     case KEY_DOWN:
 135     case XCTRL ('n'):
 136         (*forfn)(data, 1);
 137         return 1;
 138
 139     case KEY_PPAGE:
 140     case ALT('v'):
 141         (*backfn)(data, page_size-1);
 142         return 1;
 143
 144     case KEY_NPAGE:
 145     case XCTRL('v'):
 146         (*forfn)(data, page_size-1);
 147         return 1;
 148
 149     case KEY_HOME:
 150     case KEY_A1:
 151         (*topfn)(data, 0);
 152         return 1;
 153     case KEY_END:
 154     case KEY_C1:
 155         (*bottomfn)(data, 0);
 156         return 1;
 157     }
 158     if (additional)
 159         switch (c){
 160         case 'b':
 161         case XCTRL('h'):
 162         case KEY_BACKSPACE:
 163         case 0177:
 164             (*backfn)(data, page_size-1);
 165             return 1;
 166         case ' ':
 167             (*forfn)(data, page_size-1);
 168             return 1;
 169         case 'u':
 170             (*backfn)(data, page_size / 2);
 171             return 1;
 172         case 'd':
 173             (*forfn)(data, page_size / 2);
 174             return 1;
 175         case 'g':
 176             (*topfn)(data, 0);
 177             return 1;
 178         case 'G':
 179             (*bottomfn)(data, 0);
 180             return 1;
 181         }
 182     return 0;
 183 }
 184
 185 /* Classification routines */
 186 int is_abort_char (int c)
 187 {
 188     return (c == XCTRL('c') || c == XCTRL('g') || c == ESC_CHAR ||
 189             c == KEY_F(10));
 190 }
 191
 192 #ifndef HAVE_X
 193 void mc_raw_mode (void)
 194 {
 195     raw ();
 196 }
 197
 198 void mc_noraw_mode (void)
 199 {
 200     noraw ();
 201 }
 202
 203 int is_quit_char (int c)
 204 {
 205     return (c == XCTRL('g') || (c == ESC_CHAR) || (c == KEY_F(10)));
 206 }
 207
 208 /* This table is a mapping between names and the constants we use
 209  * We use this to allow users to define alternate definitions for
 210  * certain keys that may be missing from the terminal database
 211  */
 212 key_code_name_t key_name_conv_tab [] = {
 213 /* KEY_F(0) is not here, since we are mapping it to f10, so there is no reason
 214    to define f0 as well. Also, it makes Learn keys a bunch of problems :( */
 215     { KEY_F(1),      "f1",         N_("Function key 1") },
 216     { KEY_F(2),      "f2",         N_("Function key 2") },
 217     { KEY_F(3),      "f3",         N_("Function key 3") },
 218     { KEY_F(4),      "f4",         N_("Function key 4") },
 219     { KEY_F(5),      "f5",         N_("Function key 5") },
 220     { KEY_F(6),      "f6",         N_("Function key 6") },
 221     { KEY_F(7),      "f7",         N_("Function key 7") },
 222     { KEY_F(8),      "f8",         N_("Function key 8") },
 223     { KEY_F(9),      "f9",         N_("Function key 9") },
 224     { KEY_F(10),     "f10",        N_("Function key 10") },
 225     { KEY_F(11),     "f11",        N_("Function key 11") },
 226     { KEY_F(12),     "f12",        N_("Function key 12") },
 227     { KEY_F(13),     "f13",        N_("Function key 13") },
 228     { KEY_F(14),     "f14",        N_("Function key 14") },
 229     { KEY_F(15),     "f15",        N_("Function key 15") },
 230     { KEY_F(16),     "f16",        N_("Function key 16") },
 231     { KEY_F(17),     "f17",        N_("Function key 17") },
 232     { KEY_F(18),     "f18",        N_("Function key 18") },
 233     { KEY_F(19),     "f19",        N_("Function key 19") },
 234     { KEY_F(20),     "f20",        N_("Function key 20") },
 235     { KEY_BACKSPACE, "bs",         N_("Backspace key") },
 236     { KEY_END,       "end",        N_("End key") },
 237     { KEY_UP,        "up",         N_("Up arrow key") },
 238     { KEY_DOWN,      "down",       N_("Down arrow key") },
 239     { KEY_LEFT,      "left",       N_("Left arrow key") },
 240     { KEY_RIGHT,     "right",      N_("Right arrow key") },
 241     { KEY_HOME,      "home",       N_("Home key") },
 242     { KEY_NPAGE,     "pgdn",       N_("Page Down key") },
 243     { KEY_PPAGE,     "pgup",       N_("Page Up key") },
 244     { KEY_IC,        "insert",     N_("Insert key") },
 245     { KEY_DC,        "delete",     N_("Delete key") },
 246     { ALT('\t'),     "complete",   N_("Completion/M-tab") },
 247     { KEY_KP_ADD,    "kpplus",     N_("+ on keypad") },
 248     { KEY_KP_SUBTRACT,"kpminus",   N_("- on keypad") },
 249     { KEY_KP_MULTIPLY,"kpasterix", N_("* on keypad") },
 250 /* From here on, these won't be shown in Learn keys (no space) */
 251     { KEY_LEFT,      "kpleft",     N_("Left arrow keypad") },
 252     { KEY_RIGHT,     "kpright",    N_("Right arrow keypad") },
 253     { KEY_UP,        "kpup",       N_("Up arrow keypad") },
 254     { KEY_DOWN,      "kpdown",     N_("Down arrow keypad") },
 255     { KEY_HOME,      "kphome",     N_("Home on keypad") },
 256     { KEY_END,       "kpend",      N_("End on keypad") },
 257     { KEY_NPAGE,     "kpnpage",    N_("Page Down keypad") },
 258     { KEY_PPAGE,     "kpppage",    N_("Page Up keypad") },
 259     { KEY_IC,        "kpinsert",   N_("Insert on keypad") },
 260     { KEY_DC,        "kpdelete",   N_("Delete on keypad") },
 261     { (int) '\n',    "kpenter",    N_("Enter on keypad") },
 262     { (int) '/',     "kpslash",    N_("Slash on keypad") },
 263     { (int) '#',     "kpnumlock",  N_("NumLock on keypad") },
 264     { 0, 0 }
 265     };
 266
 267 /* Return the code associated with the symbolic name keyname */
 268 int lookup_key (char *keyname)
 269 {
 270     int i;
 271
 272     for (i = 0; key_name_conv_tab [i].code; i++){
 273         if ( g_strcasecmp (key_name_conv_tab [i].name, keyname))
 274             continue;
 275         return key_name_conv_tab [i].code;
 276     }
 277     return 0;
 278 }
 279
 280 #endif /* !HAVE_X */