home *** CD-ROM | disk | FTP | other *** search
/ Mega Top 1 / os2_top1.zip / os2_top1 / APPS / EDITORS / EHP12 / KM.C < prev    next >
Text File  |  1993-11-16  |  27KB  |  723 lines
  1. #include "curses.h"  /* includiert stdlib.h */
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. #define MAX_COMM_LEN 10  /* maximale Laenge einer Tastenkombination */
  6. #define MAX_COMM_ANZ 200 /* maximale Anzahl Kommandos */
  7.  
  8. #ifdef GERMAN
  9. #define PROMPT_NUMBERMISSING "Anzahl der Kombinationen nicht in Datei!\r\n"
  10. #define PROMPT_TOOFEWCOMBS   "Nicht genügend Tastenkombinationen!\r\n"
  11. #define PROMPT_ERROR         "Tastenbelegungsdatei fehlerhaft, Programm wird beendet!\r\n"
  12. #define PROMPT_ERRWRITE      "Tastenfile nicht schreibbar!\r\n"
  13. #define PROMPT_NOBAK         "Konnte keine Sicherungskopie des Tastenfiles anlegen. Datei wird überschieben.\r\n"
  14. #define PROMPT_NUMBERCHANGE  "Welchen Nummer wollen Sie ändern (-1 fuer Ende)? "
  15. #define PROMPT_OLDSTRING     "alter String: %s\r\n"
  16. #define PROMPT_STRING        "String eingeben: "
  17. #define PROMPT_OLDCOMB       "Alte Kombination (dezimal): "
  18. #define PROMPT_COMMAND       "\r\nKommando: %s\n"
  19. #define PROMPT_KEYS          "\r\nGeben Sie die Tastaturcodes ein: (/ fuer Ende)\r\n"
  20. #define PROMPT_NEWCOMB       "Eingegebene Kombination (dezimal): "
  21. #define PROMPT_CONFLICT      "Kombination ist nicht eindeutig, gerät in Konflikt mit Befehl %hd\r\nBisherige Kombination bleibt erhalten!\n\n\r"
  22. #define PROMPT_KEYABORT      "Bitte eine Taste drücken (a=Abbruch)...\r\n"
  23. #define PROMPT_KEY           "Bitte eine Taste drücken... \r\n"
  24. #define PROMPT_MENU1         "1) Tastenkombinationen aendern\r\n"
  25. #define PROMPT_MENU2         "2) Hilfstexte aendern\r\n"
  26. #define PROMPT_MENU3         "3) Befehlsnamen anzeigen\r\n"
  27. #define PROMPT_MENU4         "4) Ende (Tastaturdatei abspeichern)\r\n"
  28. #define PROMPT_MENU5         "Welche Alternative wuenschen Sie (1-4) ? "
  29. #else
  30. #define PROMPT_NUMBERMISSING "Number of combinations not in file!\r\n"
  31. #define PROMPT_TOOFEWCOMBS   "Too few combinations!\r\n"
  32. #define PROMPT_ERROR         "Keyboardfile erroneous, program exits!\r\n"
  33. #define PROMPT_ERRWRITE      "Error writing keyboard file\r\n"
  34. #define PROMPT_NOBAK         "Error creating backup of keyboard file. File will be overwritten!\r\n"
  35. #define PROMPT_NUMBERCHANGE  "Which number do you want to change (-1 for exit)? "
  36. #define PROMPT_OLDSTRING     "old string: %s\r\n"
  37. #define PROMPT_STRING        "Enter string: "
  38. #define PROMPT_OLDCOMB       "Old combination (decimal): "
  39. #define PROMPT_COMMAND       "\r\nCommand: %s\n"
  40. #define PROMPT_KEYS          "\r\nEnter new combination: (/ is terminator)\r\n"
  41. #define PROMPT_NEWCOMB       "Entered combination (decimal): "
  42. #define PROMPT_CONFLICT      "Ambiguous combination, conflicts with number %hd\r\nPrevious combination remains unchanged!\n\n\r"
  43. #define PROMPT_KEYABORT      "Please hit a key (a=abort)...\r\n"
  44. #define PROMPT_KEY           "Please hit a key...\r\n"
  45. #define PROMPT_MENU1         "1) Change key combinations\r\n"
  46. #define PROMPT_MENU2         "2) Change helptexts\r\n"
  47. #define PROMPT_MENU3         "3) Show command names\r\n"
  48. #define PROMPT_MENU4         "4) Exit (save keyboard file)\r\n"
  49. #define PROMPT_MENU5         "Enter your choice (1-4) : "
  50. #endif
  51.  
  52. typedef struct s3
  53. {
  54.   short int blen;
  55.   short int befehl[MAX_COMM_LEN];
  56.   char  *info_text;
  57. }comm_typ;
  58.  
  59. /* *** globale Daten *** */
  60. comm_typ  comm_feld [MAX_COMM_ANZ];  /* Feld der Tastenkombinationen */
  61. char      *it_feld[MAX_COMM_ANZ];    /* Pointertabelle fuer Hilfstrings */
  62. short int anz,                       /* Anzahl der Tastenkombinationen */
  63.       n_info;                    /* Anzahl der Info-Strings */
  64. char      *kom_names[MAX_COMM_ANZ] = /* Namen der Kommandos */
  65. #ifdef GERMAN
  66.       { "Refresh","Zum Zeilenanfang","Zum Zeilenende","Halbe Seite hoch",
  67.         "Halbe Seite runter","Zeichen unter Cursor loeschen",
  68.         "Zeichen links vom Cursor loeschen","Zum Fensteranfang",
  69.         "Zum Fensterende","Einfuege-/Ueberschreibmodus aendern",
  70.         "Zum Dateianfang","Zum Dateiende","Wort loeschen",
  71.         "Wort nach links","Wort nach rechts","Nach rechts","Nach links",
  72.         "Nach oben","Nach unten","Seite hoch","Seite runter",
  73.         "Naechste Zeile","Zeile loeschen",
  74.         "Datei in aktuelles Fenster laden",
  75.         "Aktuelles Fenster abspeichern",
  76.         "Verlassen ohne Sichern ohne Loadfile",
  77.         "Controlcode einfuegen","Anzeigen der Hilfstexte ein-/ausschalten",
  78.         "Fenster bewegen","Fentsergroesse aendern","Zum naechsten Fenster",
  79.         "Zum vorherigen Fenster","Fenster per Nummer anspringen",
  80.         "Fenster oeffnen","Fenster schliessen",
  81.         "Zeile per Nummer anspringen",
  82.         "Verlassen mit Abspeichern ohne Loadfile","Suchen","Ersetzen",
  83.         "Unterstreichung an/aus","Fensterinhalt eine Zeile hoch",
  84.         "Fensterinhalt eine Zeile runter",
  85.         "Aktuelle Zeile zur obersten Fensterzeile machen",
  86.         "Aktuelle Zeile zur mittleren Fensterzeile machen",
  87.         "Aktuelle Zeile zur untersten Fensterzeile machen",
  88.         "Bis zum Zeilenende loeschen","Fenstergroesse wechseln",
  89.         "Suchen/Ersetzen wiederholen","Kommando(s) wiederholen",
  90.         "Suchen/Ersetzen wiederholen","Zeilen verknuepfen",
  91.         "Zeile vor aktueller einfuegen","Autoindent an/aus","Tabulator",
  92.         "Tabulatorlaenge festlegen","Tabkomprimierungsmodus an/aus",
  93.         "Blockanfang setzen","Blockende normaler Block setzen",
  94.         "Blockende rechteckiger Block setzen","Blockmarkierung loeschen",
  95.         "Block loeschen","Block kopieren","Block verschieben",
  96.         "Block in Paste-Puffer kopieren","Paste-Puffer in Text kopieren",
  97.         "Block einruecken","Block aus Datei lesen",
  98.         "Block in Datei schreiben","Zum Blockende","Zum Blockanfang",
  99.         "Blockhervorhebung an/aus","Block an Filter uebergeben",
  100.         "Marker setzen","Marker anspringen","Zur letzten Position",
  101.         "Zeile hinter der aktuellen einfuegen",
  102.         "Fenster per Dateiname anspringen",
  103.         "Datei im aktuellen Fenster umbenennen","Tabulator rueckwaerts",
  104.         "Sicherungskopie an/aus","Macro definieren/ausfuehren",
  105.         "Geloeschte Zeile wiederherstellen","Shell-Modus an/aus",
  106.         "Verlassen mit Abspeichern mit Loadfile",
  107.         "Verlassen ohne Abspeichern mit Loadfile",
  108.         "Aktuelles Zeichen loeschen", "Reguläre Ausdrücke an/aus",
  109.         "Passende Klammer finden", "Cursor in Bildschirmmitte",
  110.         "Alle geänderten Dateien sichern" };
  111. #else
  112.       { "refresh","to beginning of line","to end of line",
  113.         "half page up", "half page down","delete current character",
  114.         "delete character left to cursor","to top of window",
  115.         "to bottom of window","toggle insert/overwrite",
  116.         "to beginning of file","to end of file","delete word",
  117.         "word left","word right","one character right",
  118.         "one character left", "one line up","one line down","page up",
  119.         "page down", "new line", "delete line",
  120.         "load file in current window", "save current window",
  121.         "quit without save without loadfile", "insert control character",
  122.         "toggle helptext display", "move window","change windowsize",
  123.         "to next window", "to previous window",
  124.         "switch to window by number", "open window","close window",
  125.         "goto line by number", "quit with save without loadfile",
  126.         "find","replace", "toggle underline",
  127.         "move text one line up", "move text one line down",
  128.         "make current line top line", "make current line middle line",
  129.         "make current line lowest line", "delete to end of line",
  130.         "toggle windowsize", "repeat find/replace",
  131.         "repeat command sequence", "repeat find/replace",
  132.         "join lines", "insert line before current","toggle autoindent",
  133.         "tab", "set tablength","toggle tabcompression",
  134.         "mark beginning of block","mark end of normal block",
  135.         "mark end of rectangular block","unmark block",
  136.         "delete block","copy block","move block",
  137.         "cut block","paste block", "indent block","read block from file",
  138.         "write block to file","goto end of block" ,
  139.         "goto beginning of block", "toggle blockhighlighting",
  140.         "pass block to filter", "set marker","goto marker",
  141.         "goto last position", "insert line after current",
  142.         "switch to window by filename",
  143.         "rename file in current window","tab backwards",
  144.         "toggle creation of .bak-files","define/execute macro",
  145.         "undelete line","toggle shell-mode", 
  146.         "quit with save and loadfile", "quit without save with loadfile",
  147.         "delete current character", "regular expressions on/off",
  148.         "goto matching parenthesis", "cursor to middle of window",
  149.         "save all modified files" };
  150. #endif
  151.  
  152. #ifndef OWN_CURSES
  153. /******************************************************************************
  154. *
  155. * Funktion    : Fatale Fehlermeldung ausgeben (fatal)
  156. * -------------
  157. *
  158. * Parameter   : s           :
  159. *                 Typ          : char *
  160. *                 Wertebereich : Pointer auf ASCII-Zeichenkette
  161. *                 Bedeutung    : Auszugebende Fehlermeldung
  162. *
  163. * Bescheibung : Der bergene String s wird ausgegeben, das Programm mit dem
  164. *               Fehlercode 1 abgebrochen.
  165. *
  166. ******************************************************************************/
  167.  
  168. void fatal(s)
  169. char *s;
  170. {
  171. #ifdef GERMAN
  172.   printf("\r\nFATAL: %s\r\nProgramm wird abgebrochen\r\n",s);
  173. #else
  174.   printf("\r\nFATAL: %s\r\naborting program\r\n",s);
  175. #endif
  176.   exit(1);
  177. }
  178. #endif
  179.  
  180. /******************************************************************************
  181. *
  182. * Funktion     : Speicher reservieren (reserve_mem)
  183. * --------------
  184. *
  185. * Parameter    : n           :
  186. *                  Typ          : int
  187. *                  Wertebereich : 0-MAXINT
  188. *                  Bedeutung    : Laenge des zu reservierenden Bereichs
  189. *
  190. * Ergebnis     :
  191. *                  Typ          : char *
  192. *                  Wertebereich : != NULL
  193. *                  Bedeutung    : Zeiger auf reservierten Bereich
  194. *
  195. * Beschreibung : Ist noch genug Speicher frei, wird der gewuenschte Bereich
  196. *                angefordert und der Pointer auf den Bereich zurueckgegeben.
  197. *                Ansonsten wird die Curses-Fuktion fatal aufgerufen, die
  198. *                zum Abbruch des Programms fuehrt.
  199. *
  200. ******************************************************************************/
  201.  
  202. char *reserve_mem(n)
  203. {
  204.   char *p;
  205.  
  206.   if(p = malloc(n))
  207.     return(p);
  208.   else
  209. #ifdef GERMAN
  210.     fatal("Kein Speicherplatz mehr ");
  211. #else
  212.     fatal("Out of memory ");
  213. #endif
  214. }
  215.  
  216. /*****************************************************************************
  217. *
  218. *  Funktion       Hilfstexte-Array neu anordnen (rearrange_it)
  219. *  --------
  220. *
  221. *  Beschreibung : Durch die Bearbeitung des Tastenbelegungsfiles können
  222. *                 Hilfetexte überflüssig geworden sein. Dadurch würden
  223. *                 bei unverändertem Ablegen von it_feld in der Datei
  224. *                 beim nächsten Einlesen zu wenig Hilfstexte gelesen.
  225. *                 Es wird also zunächst für alle Hilfstexte geprüft,
  226. *                 ob sie noch von mindestens einem Kommando benötigt werden.
  227. *                 Ist dies der Fall, so werden sie als zu übernehmend
  228. *                 markiert.
  229. *                 Anschließend werden die als nicht zu übernehmend
  230. *                 markierten Hilfstexte aus dem Array gelöscht und die
  231. *                 weiter hinten stehenden werden entsprechend nach
  232. *                 vorne verschoben.
  233. *
  234. *****************************************************************************/
  235.  
  236. void rearrange_it ()
  237. {
  238.   int  i, /* Laufindex für Tastenkombinationen */
  239.        j, k; /* Laufindex für Hilfstexte */
  240.   char *take_it = reserve_mem (n_info); /* String zu übernehmen ? */
  241.  
  242.   /* initialisiere take_it und shift: */
  243.   for (j=0; j<n_info; j++)
  244.     take_it [j] = FALSE;
  245.   for (i=0; i<anz; i++)
  246.     for (j=0; j<n_info; j++)
  247.       if (comm_feld [i].info_text == it_feld [j])
  248.     if (take_it [j])
  249.       break;
  250.     else
  251.     {
  252.       take_it [j] = TRUE;
  253.       break;
  254.     }
  255.  
  256.   /* Jetzt das Feld zusammenschrumpfen */
  257.   j = 0;
  258.   while (j<n_info)
  259.   {
  260.     if (!take_it [j])           /* Hilfstext nicht übernehmen? */
  261.     {
  262.       n_info--;                 /* Eine Kombination weniger    */
  263.       for (k=j; k<n_info; k++)  /* Rest ranziehen              */
  264.       {
  265.     it_feld [k] = it_feld [k+1];
  266.     take_it [k] = take_it [k+1];
  267.       }
  268.     }
  269.     else
  270.       j++;
  271.   }
  272. }
  273.  
  274. /*****************************************************************************
  275. *
  276. *  Funktion       Tastenbelegung einlesen (lies_tasten)
  277. *  --------
  278. *
  279. *  Beschreibung : Aus der Datei tasten.inf wird die Tastaturbelegung ge-
  280. *                 laden. Dabei werden die Zeiger auf die Strings zunaechst
  281. *                 als Indices in die Tabelle geladen, die Anzahl der aus
  282. *                 der Datei zu ladenden Strings wird mitgezaehlt. Nachdem
  283. *                 alle Kombinationen eingelesen sind, wird die Stringtabelle
  284. *                 in das Array it_feld eingelesen.
  285. *
  286. *****************************************************************************/
  287.  
  288. void lies_tasten()
  289. {
  290.   FILE      *f;          /* Zeiger fuer Tastenbelegungsdatei */
  291.   short int i,           /* Schleifenzaehler */
  292.         j,           /* Schleifenzaehler */
  293.         index[MAX_COMM_ANZ];  /* Zwischenspeicher fuer Hilfstextnummern */
  294.   char      *hilf,       /* Hilfszeiger fuer Hilfstexte */
  295.         dummy [256]; /* String zum Einlesen der Hilfstexte */
  296.  
  297.   if (!(f = fopen ("tasten.inf","rb")))
  298.   {
  299.     anz = n_info = 0;
  300.     return;
  301.   }
  302.   if(fread(&anz,sizeof(short int),1,f) != 1) /* Anzahl der Befehle einlesen */
  303.   {
  304.     printf(PROMPT_NUMBERMISSING);
  305.     gets(0);
  306.     endwin();
  307.     exit(1);
  308.   }
  309.   anz++; /* In Datei steht letzter Index, also ist Anzahl 1 hoeher */
  310.   for (n_info=i=0;i<anz;i++) /* Alle Kombinationen einlesen */
  311.   {
  312.     /* Zuerst die Laenge des aktuellen Befehls einlesen */
  313.     if(fread (&comm_feld[i].blen,sizeof(short int),1,f) < 1)
  314.     {
  315.       printf(PROMPT_TOOFEWCOMBS);
  316.       gets(0);
  317.       endwin();
  318.       exit(1);
  319.     }
  320.     /* Jetzt Befehl selber einlesen */
  321.     fread (comm_feld[i].befehl,sizeof(short int),comm_feld[i].blen,f);
  322.     fread (&index[i],sizeof(short int),1,f); /* Index fuer Hilfstext */
  323.     comm_feld[i].info_text = NULL;
  324.     if(index[i] > -1)  /* Ueberhaupt Hilfstext fuer diesen Befehl ? */
  325.       for (n_info++,j=0;j<i;j++) /* Ja, dann checken, ob ein anderer */
  326.     if (index[j] == index[i]) /* Befehl schon diesen String hat. */
  327.     {
  328.       n_info--;     /* Nur einen weiteren String einlesen,  */
  329.       break;        /* falls neuer Index                    */
  330.     }
  331.   }
  332.   for (i=0;i<n_info;i++)  /* Hilfstexte einlesen */
  333.   {
  334.     if (!fgets (dummy,255,f))
  335.     {
  336.       printf(PROMPT_ERROR);
  337.       gets(0);
  338.       endwin();
  339.       exit(1);
  340.     }
  341.     dummy[strlen(dummy)-1] = '\0';              /* \n abschneiden */
  342.     it_feld[i] = hilf = strcpy(reserve_mem(strlen(dummy)+1),dummy);
  343.     for (j=0;j<=anz;j++)  /* Zeiger auf Hilfstext in comm_feld eintragen */
  344.       if (index[j] == i)
  345.     comm_feld[j].info_text = hilf;
  346.   }
  347.   fclose (f);
  348. }
  349.  
  350. /*****************************************************************************
  351. *
  352. *  Funktion       Tastenbelegung in Datei schreiben (schreib_tasten)
  353. *  --------
  354. *
  355. *  Beschreibung :
  356. *
  357. *****************************************************************************/
  358.  
  359. void schreib_tasten()
  360. {
  361.   FILE      *f;    /* Pointer fuer Ausgabedatei */
  362.   short int i,     /* Schleifenzaehler fuer Infotexte */
  363.         j,     /* Schleifenzaehler fuer Kommandos und String */
  364.         index; /* Stringindex des aktuellen Hilfstextes */
  365.  
  366.   unlink ("tasten.bak"); /* Fehlercode wird ignoriert */
  367.   if (rename ("tasten.inf", "tasten.bak"))
  368.     printf(PROMPT_NOBAK);
  369.   if (!(f = fopen ("tasten.inf","wb")))
  370.   {
  371.     printf(PROMPT_ERRWRITE);
  372.     exit(1);
  373.   }
  374.  
  375.   rearrange_it (); /* Es werden nicht mehr benötigte Info-Texte aus dem
  376.               Array gelöscht und das Array entsprechend
  377.               zusammengeschrumpft. Das ist nötig, damit nicht
  378.               beim Lesen der Datei zu wenig Texte eingelesen werden.*/
  379.   anz--; /* Es wird der letzte Index in die Datei geschrieben */
  380.   fwrite(&anz,sizeof(short int),1,f); /* Anzahl der Kombinationen schreiben */
  381.   anz++;
  382.   for(j=0;j<anz;j++) /* Alle Kombinationsstrings schreiben */
  383.   {
  384.     index = -1; /* Noch kein Info-String */
  385.     for(i=0;i<n_info;i++) /* Auf welchen String zeigt die Kombination ? */
  386.       if(it_feld[i] == comm_feld[j].info_text)
  387.       {
  388.     index = i; /* Stringindex merken */
  389.     break;
  390.       }
  391.     /* Zuerst die Laenge der Kombination, dann die Kombination selber */
  392.     /* und dann den Stringindex in die Datei schreiben */
  393.     fwrite(&comm_feld[j].blen,sizeof(short int),1,f);
  394.     fwrite(comm_feld[j].befehl,sizeof(short int),comm_feld[j].blen,f);
  395.     fwrite(&index,sizeof(short int),1,f);
  396.   }
  397.  
  398.   for(j=0;j<n_info;j++) /* Alle Infotexte schreiben */
  399.     fprintf(f,"%s\n",it_feld[j]);
  400.   fclose(f);
  401. }
  402.  
  403. /*****************************************************************************
  404. *
  405. *  Funktion       Infotexte aendern (change_strings)
  406. *  --------
  407. *
  408. *  Beschreibung : Der User gibt die Nummer des zu aendernden Strings ein.
  409. *                 Daraufhin bekommt er den alten String angezeigt. Er gibt
  410. *                 den neuen ein, der in it_feld an der Stelle des alten
  411. *                 eingetragen wird.
  412. *
  413. *****************************************************************************/
  414.  
  415. void change_strings()
  416. {
  417.   short int index,       /* Nummer des Strings */
  418.         j;           /* Zaehler zum Durchlaufen des Kommandoarrays */
  419.              /* und der Stringtabelle */
  420.   char      string[MAX_COMM_ANZ], /* Puffer fuer neuen String */
  421.         *old_text;   /* Zwischenspeicher fuer Adresse alter String */
  422.  
  423.   while(1)
  424.   {
  425.     for(j=0;j<n_info;j++) /* Hilfstexte anzeigen */
  426.       printw("%d.:  %s\r\n",j,it_feld[j]);
  427.     printw(PROMPT_NUMBERCHANGE); refresh();
  428.     scanw("%hd\n",&index);  /* Stringnummer einlesen */
  429.  
  430.     if(index >= n_info)   /* Keinen neuen String anlegen */
  431.       continue;
  432.     if(index == -1)       /* Abbruch bei -1 */
  433.       break;
  434.  
  435.     printw(PROMPT_OLDSTRING,it_feld[index]);
  436.     printw(PROMPT_STRING);refresh();
  437.     getstr(string);   /* Neuen String in Puffer einlesen */
  438.     free(old_text = it_feld[index]); /* Alten freigeben, Adresse merken */
  439.     /* Neuen String in dafuer allozierten Speicher kopieren und neue */
  440.     /* Adresse in it_feld eintragen */
  441.     it_feld[index] = strcpy(reserve_mem(strlen(string)+1),string);
  442.  
  443.     /* Zeigt der Stringzeiger eines anderen Kommandos auf den geaenderten */
  444.     /* String, dann wird auch dieser Zeiger auf den neuen String gesetzt. */
  445.     for(j=0;j<anz;j++)
  446.       if(comm_feld[j].info_text == old_text)
  447.     comm_feld[j].info_text = it_feld[index];
  448.   }
  449. }
  450.  
  451.  
  452. /*****************************************************************************
  453. *
  454. *  Funktion       Curses initialisieren (init)
  455. *  --------
  456. *
  457. *  Beschreibung : Curses wird aktiviert, das Terminal in den raw-mode
  458. *                 gesetzt, die Sondertasten und das Scrolling zugelassen.
  459. *
  460. *****************************************************************************/
  461.  
  462. void init()
  463. {
  464. #ifdef OS2
  465.   set_os2_raw (TRUE);       /* !!! muß erste Aktion sein !!! */
  466. #endif
  467.   initscr();
  468.   scrollok(stdscr,TRUE);
  469.   nonl();
  470. }
  471.  
  472. /*****************************************************************************
  473. *
  474. *  Funktion       Kommandostring aendern (change_kom)
  475. *  --------
  476. *
  477. *  Parameter    : index     :
  478. *                   Typ          : short int
  479. *                   Wertebereich : 0-anz
  480. *                   Bedeutung    : Nummer des zu aendernden Kommandos
  481. *
  482. *  Ergebnis     :
  483. *                   Typ          : int
  484. *                   Wertebereich : TRUE, FALSE
  485. *                   Bedeutung    : TRUE: Kombination war eindeutig
  486. *                                  FALSE: Kombination geriet in Konflikt
  487. *
  488. *  Beschreibung : Die alte Kombination wird angezeigt. Dann wird die neue
  489. *                 Kombination in das Feld temp eingelesen. Anschliessend
  490. *                 wird die neue Kombination auf ihre Eindeutigkeit getestet.
  491. *
  492. *****************************************************************************/
  493.  
  494. int change_kom(index)
  495. short int index;
  496. {
  497.   short int temp[MAX_COMM_LEN], /* Puffer zum Einlesen der Kombination */
  498.         i,                  /* Schleifenzaehler */
  499.         j,                  /* Schleifenzaehler fuer Tasten in temp */
  500.         k;                  /* Schleifenzaehler fuer Eindeutigkeitscheck */
  501.   char      string[MAX_COMM_ANZ]; /* Puffer fuer Eingabe Hilfstext */
  502.  
  503.   printw(PROMPT_OLDCOMB);
  504.   for(i=0;i<comm_feld[index].blen;i++)
  505.     printw("%d ",comm_feld[index].befehl[i]);
  506.  
  507.   printw(PROMPT_COMMAND, kom_names [index]);
  508.   printw(PROMPT_KEYS);
  509.   refresh();
  510.  
  511.   /* Befehl einlesen. Erreicht j den maximalen Index, so muss j noch   */
  512.   /* inkrementiert werden, da die nachfolgende Schleife davon ausgeht, */
  513.   /* dass j auch nach dem Lesen des / ionkrementiert wurde.            */
  514.   j=0;
  515.   noecho();
  516.   raw();
  517.   while((temp[j++] = getch()) != (short int) '/'
  518.      && (j < MAX_COMM_LEN || (j++,0)));
  519.   echo();
  520.   noraw();
  521.  
  522.   /* Eingegebene Kombination anzeigen: */
  523.   printw(PROMPT_NEWCOMB);
  524.   for(i=0;i<j-1;i++)
  525.     printw("%d ",temp[i]);
  526.   printw("\r\n");
  527.  
  528.   /* Befehl auf Eindeutigkeit checken */
  529.   for(j--,i=0;i<anz;i++)       /* j auf '/' setzen */
  530.     if(i != index) /* Bei aktueller Kombination nicht testen */
  531.     {
  532.       /* k auf das Ende des kuerzeren Kommandos setzen */
  533.       /* Solange wiederholen, bis k<0 oder Kommandos ungleich */
  534.       for(k=(comm_feld[i].blen > j ? j : comm_feld[i].blen)-1;
  535.       k >= 0 && comm_feld[i].befehl[k] == temp[k]; k--);
  536.       if(k == -1)   /* ein String Teil des anderen oder Strings identisch? */
  537.       {
  538.     printw(PROMPT_CONFLICT,i);
  539.     return(FALSE);
  540.       }
  541.     }
  542.   printw("\r\n");
  543.   /* Befehl eindeutig, dann Kombination im comm_feld uebernehmen */
  544.   memcpy(comm_feld[index].befehl,temp,j * sizeof(short int));
  545.  
  546.   if((comm_feld[index].blen = j) > 1) /* Bei Kommandos, die laenger */
  547.   { /* als ein Zeichen sind, wird nach einem Hilfstext gefragt.     */
  548.     for(j=0;j<n_info;j++) /* Hilfstexte anzeigen */
  549.       printw("%d.:  %s\r\n",j,it_feld[j]);
  550.     printw("\r\nString-Index (-1 fuer keinen String): ");refresh();
  551.     scanw("%hd",&j); /* Index fuer Hilfsstring zum Kommando einlesen */
  552.     if(j != -1) /* Wird Hilfsstring gewuenscht ? */
  553.     {
  554.       if(j >= n_info)  /* Neuer String ? */
  555.       {
  556.     printw(PROMPT_STRING); refresh(); /* Dann einlesen */
  557.     getstr(string);
  558.     it_feld[j = n_info++] = strcpy(reserve_mem(strlen(string)+1),string);
  559.       }
  560.       comm_feld[index].info_text = it_feld[j]; /* Stringzeiger eintragen */
  561.     }
  562.   }
  563.   else
  564.     comm_feld[index].info_text = NULL; /* Kein String, dann NULL eintragen */
  565.   return(TRUE);
  566. }
  567.  
  568. /******************************************************************************
  569. *
  570. * Funktion     : Eingabe neuer Tastenkombinationen steuern (hndl_koms)
  571. * --------------
  572. *
  573. * Beschreibung : Es wird nach der Nummer des zu aendernden Kommandos gefragt.
  574. *                Gibt der User eine Zahl ungleich -1 an, so wird die ent-
  575. *                sprechende Tastenkombination eingelesen. Ist die Nummer
  576. *                zu groa, wird sie auf die Nummer der ersten nicht belegten
  577. *                Kombination gesetzt.
  578. *                Gibt der User -1 ein, so wird die Funktion beendet.
  579. *
  580. ******************************************************************************/
  581.  
  582. void hndl_koms()
  583. {
  584.   short int index;
  585.  
  586.   do
  587.   {
  588.     printw(PROMPT_NUMBERCHANGE);
  589.     refresh();
  590.     scanw("%hd",&index);   /* Nummer der Kombination einlesen */
  591.     if(index == -1)        /* Bei -1 Schleife abbrechen       */
  592.       break;
  593.  
  594.     if(index >= anz)  /* Falls Nummer zu groa, eine Kombination mehr, */
  595.     {                 /* neue Kombination einlesen */
  596.       if(!change_kom(anz++)) /* Konflikt, dann anz wieder runter, da */
  597.     anz--;               /* keine neue Kombination entstand */
  598.     }
  599.     else
  600.       change_kom(index);
  601.   } while (1);
  602. }
  603.  
  604. /******************************************************************************
  605. *
  606. * Funktion     : Kommandonamen anzeigen (show_names)
  607. * --------------
  608. *
  609. * Beschreibung : Die Kommandonamen werden angezeigt. Ist der Bildschirm
  610. *                voll, wird ein Tastendruck erwartet.
  611. *
  612. ******************************************************************************/
  613.  
  614. void show_names()
  615. {
  616.   int i;
  617.  
  618.   for (i=0;i<anz;i++)
  619.   {
  620.     if(!((i+1)%20))  /* Bildschirm voll ? */
  621.     {
  622.       printw(PROMPT_KEYABORT);
  623.       refresh();
  624.       noecho();
  625.       raw();
  626.       if(getch() == 'a')
  627.       {
  628.     echo();
  629.     noraw();
  630.     break; /* Bei a for-Schleife abbrechen */
  631.       }
  632.       echo();
  633.       noraw();
  634.     }
  635.     printw("%3d : %s\r\n",i,kom_names[i]); /* Kommandonamen anzeigen */
  636.   }
  637.   refresh();
  638.   if((i+1)%20) /* Zum Abschluß nochmals auf Tastendruck warten */
  639.   {
  640.     printw(PROMPT_KEY);
  641.     refresh();
  642.     noecho();
  643.     raw();
  644.     getch();
  645.     noraw();
  646.     echo();
  647.   }
  648. }
  649.  
  650. /******************************************************************************
  651. *
  652. * Funktion     : Menue (menue)
  653. * --------------
  654. *
  655. * Ergebnis     :
  656. *                  Typ          : int
  657. *                  Wertebereich : 1-4
  658. *                  Bedeutung    : Gewaehlte Alternative
  659. *
  660. * Beschreibung : Die Alternativen werden angezeigt, der Nutzer mua eine
  661. *                auswaehlen. Die Nummer der ausgewaehlten Alternative wird
  662. *                als Integer zurueckgegeben.
  663. *
  664. ******************************************************************************/
  665.  
  666. int menue()
  667. {
  668.   char c;
  669.   
  670.   printw(PROMPT_MENU1);
  671.   printw(PROMPT_MENU2);
  672.   printw(PROMPT_MENU3);
  673.   printw(PROMPT_MENU4);
  674.   printw(PROMPT_MENU5);
  675.   refresh();
  676.   noecho();
  677.   raw();
  678.   while((c = getch()) < '1' && c > '4');
  679.   echo();
  680.   noraw();
  681.   printw("%c\r\n",c);
  682.   refresh();
  683.   return(c-'0');
  684. }
  685.  
  686. /*****************************************************************************
  687. *
  688. *  Funktion       Hauptprogramm (main)
  689. *  --------
  690. *
  691. *  Beschreibung : Curses wird initialisiert, die alte Tastaturbeledung aus
  692. *                 der Datei tasten.inf gelesen. Dann kann der User Tasten-
  693. *                 kombinationen aendern. Anschlieaend koennen die Hilfs-
  694. *                 texte geaendert werden. Ist das abgeschlossen, wird die
  695. *                 neue Tastaturbelegung in die Datei zurueckgeschrieben.
  696. *
  697. *****************************************************************************/
  698.  
  699. int main()
  700. {
  701.   int alt;
  702.  
  703.   init();
  704.   lies_tasten(); /* Bisherigen Tastenkombinationen einlesen */
  705.   do
  706.   {
  707.     switch(alt=menue()) /* Nutzereingabe lesen */
  708.     {
  709.       case 1:
  710.     hndl_koms();   /* Tastenkombinationen aendern */
  711.     break;
  712.       case 2:
  713.     change_strings(); /* Evtl. Stringinhalte aendern */
  714.     break;
  715.       case 3:
  716.     show_names(); /* Namen der Komandos anzeigen */
  717.     break;
  718.     }
  719.   } while (alt != 4); /* Solange, bis der User ENDE wuenscht */
  720.   endwin();
  721.   schreib_tasten(); /* Tastenbelegung wieder in Datei zurueckschreiben */
  722. }
  723.