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