home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d0xx / d023 / microemacs.lha / Ver30 / Tty / Intuition / gnuttymenu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-05-10  |  7.5 KB  |  277 lines
  1. /*
  2.  * Name:    MicroEmacs
  3.  *         Commodore Amiga Intuition menus
  4.  * Version:    31
  5.  * Last edit:    20-Apr-86 ...!ihnp4!seismo!ut-sally!ut-ngp!mic
  6.  * Created:    20-Apr-86 ...!ihnp4!seismo!ut-sally!ut-ngp!mic
  7.  */
  8.  
  9. #include <exec/types.h>
  10. #include <exec/memory.h>
  11. #include <graphics/text.h>
  12. #include <libraries/diskfont.h>
  13. #include <intuition/intuition.h>
  14. #undef    TRUE
  15. #undef    FALSE
  16. #include "def.h"    /* Also includes "sysdef.h" and "ttydef.h" */
  17.  
  18. /*
  19.  * When ttgetc() sees a menu selection event, it stuffs
  20.  * the sequence <CSI>M~ into the input buffer, and
  21.  * caches the menu number and item number for later.
  22.  * This sequence is translated into the internal key code
  23.  * KMENU, similar to KHELP and the other function keys.
  24.  *
  25.  * The menu item names are chosen to be relatively close
  26.  * to the extended function names, so a user can usually
  27.  * figure out the key binding of a menu item by searching
  28.  * through the "display-bindings" buffer for something
  29.  * that's close.
  30.  */
  31.  
  32. /*
  33.  * Commands for managing files
  34.  */
  35.  
  36. static struct MenuBinding FileItems[] = {
  37.     { "Read File",        "file-file-read-only",        },
  38.     { "Save File",        "file-buffer",            },
  39.     { "Find File",        "find-file",            },
  40.     { "Write File",        "write-file"            },
  41.     { "Insert File",    "insert-file"            },
  42.     { "Set File Name",    "set-visited-file-name"        },
  43.     { "Save And Exit",    "save-buffers-kill-emacs"    },
  44.     { "Kill Emacs",        "kill-emacs",            }
  45. };
  46.  
  47. /*
  48.  * Commands for various editing functions
  49.  */
  50.  
  51. static struct MenuBinding EditItems[] = {
  52.     { "Delete Char",        "delete-char"            },
  53.     { "Kill Line",            "kill-line"            },
  54.     { "Yank",            "yank"                },
  55.     { "Delete Blank Lines",        "delete-blank-lines"        },
  56.     { "Newline And Indent",        "newline-and-indent"        },
  57.     { "Transpose Characters",    "transpose-characters"        },
  58.     { "Quoted Insert",        "quoted-insert"            }
  59. };
  60.  
  61. /*
  62.  * Movement commands
  63.  */
  64.  
  65. static struct MenuBinding MoveItems[] = {
  66.     { "Beginning Of Line",        "beginning-of-line"        },
  67. #ifdef AS_DISTRIBUTED
  68.     { "Beg. Of  Paragraph",        "goto-bop"            },
  69. #endif
  70.     { "Beginning Of Buffer",    "beginning-of-buffer"        },
  71.     { "End Of Line",        "end-of-line"            },
  72. #ifdef AS_DISTRIBUTED
  73.     { "End Of Paragraph",        "goto-eop"            },
  74. #endif
  75.     { "End Of Buffer",        "end-of-buffer"            },
  76.     { "Goto Line",            "goto-line"            },
  77.     { "Show Cursor Pos",        "what-cursor-position"        }
  78. };
  79.  
  80. /*
  81.  * Commands for searching and replacing
  82.  */
  83.  
  84. static struct MenuBinding SearchItems[] = {
  85.     { "Search Again",        "search-again"            },
  86.     { "I-Search Forward",        "isearch-forward"        },
  87.     { "I-Search Backward",        "isearch-backward"        },
  88.     { "Search Forward",        "search-forward"        },
  89.     { "Search Backward",        "search-backward"        },
  90.     { "Query Replace",        "query-replace"            },
  91. };
  92.  
  93. /*
  94.  * Commands that manipulate words
  95.  */
  96. static struct MenuBinding WordItems[] = {
  97. #ifdef AS_DISTRIBUTED
  98.     { "Fill Paragraph",        "fill-paragraph"        },
  99.     { "Set Fill Column",        "set-fill-column"        },
  100. #endif
  101.     { "Forward Word",        "forward-word"            },
  102.     { "Backward Word",        "backward-word"            },
  103.     { "Kill Word",            "kill-word"             },
  104.     { "Backward Kill Word",        "backward-kill-word"         },
  105.     { "Capitalize Word",        "capitalize-word"        },
  106.     { "Downcase Word",        "downcase-word"            },
  107.     { "Upcase Word",        "upcase-word"            }
  108. };
  109.  
  110. /*
  111.  * Region management
  112.  */
  113.  
  114. static struct MenuBinding RegionItems[] = {
  115.     { "Set Mark Command",        "set-mark-command"        },
  116.     { "Exch Point And Mark",    "exchange-point-and-mark"    },
  117.     { "Kill Region",        "kill-region"            },
  118.     { "Copy Region As Kill",    "copy-region-as-kill"        },
  119.     { "Downcase Region",        "downcase-region"        },
  120.     { "Upcase Region",        "upcase-region"            }
  121. };
  122.  
  123. /*
  124.  * Buffer management
  125.  */
  126.  
  127. static struct MenuBinding BufferItems[] = {
  128. #ifdef NOTIMPLEMENTED
  129.     { "Rename Buffer",        "rename-buffer"            },
  130. #endif
  131.     { "Switch To Buffer",        "switch-to-buffer"        },
  132.     { "Kill Buffer",        "kill-buffer"            },
  133.     { "List Buffers",        "list-buffers"            }
  134. };
  135.  
  136. /*
  137.  * Commands for manipulating windows
  138.  */
  139.  
  140. static struct MenuBinding WindowItems[] = {
  141.     { "Recenter",            "recenter"            },
  142.     { "Move To Window Line",    "move-to-window-line"        },
  143.     { "Split Window Vertically",    "split-window-vertically"    },
  144.     { "Delete Other Windows",    "delete-other-windows"        },
  145.     { "Other Window",        "other-window"            },
  146.     { "Back Window",        "back-window"            },
  147.     { "Down Window",        "down-window"            },
  148.     { "Up Window",            "up-window"            },
  149.     { "Enlarge Window",        "enlarge-window"        },
  150.     { "Shrink Window",        "shrink-window"            }
  151. };
  152.  
  153. /*
  154.  * Miscellaneous commands
  155.  */
  156.  
  157. static struct MenuBinding MiscItems[] = {
  158.     { "Emacs Version",        "emacs-version"            },
  159.     { "Start Kbd Macro",        "start-kbd-macro"        },
  160.     { "End Kbd Macro",        "end-kbd-macro"            },
  161.     { "Call Kbd Macro",        "call-last-kbd-macro"        },
  162.     { "Execute Command",        "execute-extended-command"    },
  163.     { "Global Set Key",        "global-set-key"        },
  164.     { "Describe Bindings",        "describe-bindings"        },
  165.     { "Suspend Emacs",        "suspend-emacs"            }
  166. };
  167.  
  168. /*
  169.  * The following table contains the titles, number of
  170.  * items, and pointers to, the individual menus.
  171.  *
  172.  * The MenuWidth field is the number of characters
  173.  * in the longest item name.
  174.  */
  175.  
  176. static struct MenuInfo EMInfo[] = {
  177.     { "File",    NITEMS(FileItems),    13,    &FileItems[0]    },
  178.     { "Edit",    NITEMS(EditItems),    20,    &EditItems[0]    },
  179.     { "Move",     NITEMS(MoveItems),    19,    &MoveItems[0]    },
  180.     { "Search",    NITEMS(SearchItems),    17,    &SearchItems[0] },
  181.     { "Word",    NITEMS(WordItems),    18,    &WordItems[0]    },
  182.     { "Region",    NITEMS(RegionItems),    19,    &RegionItems[0]    },
  183.     { "Buffer",    NITEMS(BufferItems),    16,    &BufferItems[0]    },
  184.     { "Window",    NITEMS(WindowItems),    23,    &WindowItems[0] },
  185.     { "Misc",    NITEMS(MiscItems),    17,    &MiscItems[0]    }
  186. };
  187.  
  188. /*
  189.  * Initialize the MicroEmacs menus.
  190.  *
  191.  * Returns a pointer to the first menu header in
  192.  * the menu list back to the caller.
  193.  *
  194.  * Makes the assumption that the font for
  195.  * the window being used is 8 pixels wide --
  196.  * a safe bet with the version 1.1 ROM Kernel.
  197.  */
  198.  
  199. struct Menu *InitEmacsMenu()
  200. {
  201.     struct Menu *EMMenu, *NewMenu(), *AddMenu();
  202.     struct MenuItem *AddNewMenuItem(), *AddItem(), *AddNewSubItem();
  203.  
  204.     register struct Menu *cm;
  205.     register struct MenuInfo *cinf, *lastinfo;/* current menu info    */
  206.  
  207.     lastinfo = &EMInfo[NITEMS(EMInfo)];    /* sentinel for loop    */
  208.  
  209.     for (cinf = EMInfo; cinf < lastinfo; cinf++) {
  210.         if (cinf == EMInfo)        /* create menu header    */
  211.             EMMenu = cm = NewMenu(cinf->Name,
  212.                 strlen(cinf->Name) * 8 + 6, 10);
  213.         else
  214.             cm = AddMenu(cm,
  215.                 cinf->Name,strlen(cinf->Name) * 8 + 6, 10);
  216.         MakeMenu(cinf,cm,cinf->MenuWidth * 8 + 2, 10);
  217.     }
  218.     return EMMenu;
  219. }
  220.  
  221. /*
  222.  * Put menu items in a menu.  Width and
  223.  * height control the respective
  224.  * sizes of the menu items.
  225.  */
  226.  
  227. static    MakeMenu(cinf,cm,width,height)
  228. struct MenuInfo *cinf;
  229. struct Menu *cm;
  230. int width, height;
  231. {
  232.     struct Menu *NewMenu(), *AddMenu();
  233.     struct MenuItem *AddNewMenuItem(), *AddItem(), *AddNewSubItem();
  234.  
  235.     register struct MenuBinding *cb, *lastbinding;
  236.     register struct MenuItem *ci;
  237.  
  238.     lastbinding = &cinf->Items[cinf->NumItems];
  239.     for (cb = cinf->Items; cb < lastbinding; cb++) {
  240.         if (cb == cinf->Items)
  241.             ci = AddNewMenuItem(cm, cb->Command, width, height);
  242.         else
  243.             ci = AddItem(ci, cb->Command);
  244.     }
  245. }
  246.  
  247. /*
  248.  * Menu command.   Get the name of the command to
  249.  * perform from the menu binding table, then
  250.  * run the command if it is found and has the
  251.  * right type. Print an error if there is anything
  252.  * wrong.
  253.  */
  254. extern ttmenu();            /* Defined in "ttyio.c"     */
  255.                     /* Returns last menu selection    */
  256. amigamenu(f, n, k)
  257. {
  258.     register SYMBOL    *sp, *symlookup();
  259.     char        *xname;
  260.     int MenuNum, ItemNum, SubItem;
  261.  
  262.     ttmenu(&MenuNum,&ItemNum,&SubItem);
  263.  
  264.     /* check for spurious numbers */
  265.     if ((MenuNum < 0) || (MenuNum >= NITEMS(EMInfo)))
  266.         return (FALSE);
  267.     if ((ItemNum < 0) || (ItemNum >= EMInfo[MenuNum].NumItems))
  268.         return (FALSE);    
  269.  
  270.     xname = EMInfo[MenuNum].Items[ItemNum].Binding;
  271.  
  272.     if ((sp=symlookup(xname)) != NULL)
  273.         return ((*sp->s_funcp)(f, n, KRANDOM));
  274.     eprintf("Unknown menu command");
  275.     return (ABORT);
  276. }
  277.