home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / libs / plotlib.lha / Plot_1.lzh / Demo / Help.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-18  |  12.6 KB  |  350 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. * Filename : Help.c                                                                                            *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *    Comment : Diese File beinhaltet alle Funtionen für die                *
  8. *                        Darstellung des Helptextes.                                                    *
  9. *                                                                                                                                *
  10. *                        Die Helpfunktion hat ein eigenes Window welches            *
  11. *                        zuerst geöffnet wird.                                                                *
  12. *                        Danach wird die Umgebungsvariable Fplot.Hlp                    *
  13. *                        abgefragt, nach dem Standort des Helpfiles.                    *
  14. *                        Dieser wird dann geladen und die ersten Zeilen            *
  15. *                        werden dargestellt.                                                                    *
  16. *                        Über die verschiedenen Schalter kann man die                *
  17. *                        nächsten Zeilen darstellen.                                                    *
  18. *                                                                                                                                *
  19. *                        Der Helptext muss eine ASCII-Datei sein mit                    *
  20. *                        einer max. Zeilenlänge von 75 Charaktern. Wenn            *
  21. *                        die Zeile grösser ist, wird der Rest auf die                *
  22. *                        nächste Zeile geschrieben.                                                    *
  23. *                        Es werden max. 1500 Zeilen des Helptextes                        *
  24. *                        geladen.                                                                                        *
  25. *                                                                                                                                *
  26. *            Rev : V1.1                                                                                                *
  27. *                                                                                                                                *
  28. *    History : V1.0 erstellen dieses Files                                01.09.89    *
  29. *                        V1.1 korr. eines Fehlers in OpenHelp()      01.09.89    *
  30. *                                                                                                                                *
  31. *         Bugs : keine bekannten                                                                            *
  32. *                                                                                                                                *
  33. *        Autor : Oesch Silvano                                                                                *
  34. *                                                                                                                                *
  35. *        Datum : 01.09.89                                                                                        *
  36. *                                                                                                                                *
  37. ****************************************************************/
  38.  
  39. /****************************************************************
  40. *                                                                                                                                *
  41. * allgemeine Includedateien                                                                            *
  42. *                                                                                                                                *
  43. ****************************************************************/
  44.  
  45. #include <ctype.h>
  46. #include <exec/types.h>
  47. #include <intuition/intuition.h>
  48. #include <intuition/intuitionbase.h>
  49. #include <mylib/mylib.h>
  50. #include <stdlib.h>
  51. #include <stdio.h>
  52. #include <string.h>
  53. #include <dos.h>
  54. #include <graphics/gfxbase.h>
  55. #include <libraries/reqbase.h>
  56. #include <proto/reqproto.h>
  57.  
  58. /****************************************************************
  59. *                                                                                                                                *
  60. * programmspezifische Includedateien                                                        *
  61. *                                                                                                                                *
  62. ****************************************************************/
  63.  
  64. #include "Definitions.h"                        /* allgemeine Definitionen    */
  65. #include "Help.h"                                        /* Help Definitionen                */
  66. #include "Function.h"
  67.  
  68. /****************************************************************
  69. *                                                                                                                                *
  70. * externe Definitionen                                                                                    *
  71. *                                                                                                                                *
  72. ****************************************************************/
  73.  
  74. extern struct ReqBase *ReqBase;
  75. extern struct Screen *Sc;                        /* Screenpointer                        */
  76. extern struct Window *Mw;                        /* MainWindowpointer                */
  77. extern struct NewWindow helpwindow;    /* Referenz in Window.h            */
  78. extern USHORT chip sprite1[];                /* Referenz in Pointer.h        */
  79. extern int SCREENHOEHE;                            /* Screenhoehe                            */
  80.  
  81. extern char helpload[];                            /* Referenz in texte.h            */
  82. extern char abbruch[];                            /*            "                                        */
  83. extern char windowtext[];                        /*            "                                        */
  84. extern char speicher[];                            /*            "                                        */
  85.  
  86. /****************************************************************
  87. *                                                                                                                                *
  88. * globale Definitionen                                                                                    *
  89. *                                                                                                                                *
  90. ****************************************************************/
  91.  
  92. static struct Window *Hw;                        /* Windowpointer                        */
  93. static struct RastPort *HRp;                /* Rasport Helpwindow                */
  94. static char *textarray[MAXLINE];        /* Pointerarray of char            */
  95. static int    screenzeilen;                        /* Anzahl Zeilen pro screen    */
  96.  
  97. /****************************************************************
  98. *                                                                                                                                *
  99. *    Funktion : OpenHelp()                                                                                    *
  100. *                                                                                                                                *
  101. *****************************************************************
  102. *                                                                                                                                *
  103. *        Input : None                                                                                                *
  104. *                                                                                                                                *
  105. *     Output : int Zeilen                                                                                    *
  106. *                                Zeilen ist die Anzahl geladener Zeilen vom            *
  107. *                                Datenfile.                                                                            *
  108. *                                Wenn Zeilen == NULL dann ist ein Fehler                    *
  109. *                                beim laden aufgetretten.                                                *
  110. *                                                                                                                                *
  111. *****************************************************************
  112. *                                                                                                                                *
  113. *    Comment : Diese Routine öffnet den Helpfile. Der Name                    *
  114. *                        wird in der Umgebungsvariable Fplot.Hlp                            *
  115. *                        definiert.                                                                                    *
  116. *                        Wenn fopen erfolgreich, werden alle Zeilen                    *
  117. *                        geladen, bis MAXLINE oder EOF erreicht.                            *
  118. *                        Danach wird Fplot.Hlp wieder geschlossen und                *
  119. *                        mit den gelesenen Zeilen in die aufrufende                    *
  120. *                        Routine zurück verzweigt.                                                        *
  121. *                                                                                                                                *
  122. *            Rev : V1.1                                                                                                *
  123. *                                                                                                                                *
  124. *    History : V1.0 erstellen dieses Files                                01.09.89    *
  125. *                        V1.1 korr. beim einlesen von Fplot.help                            *
  126. *                                 bis und mit MAXLINE überschreiben                            *
  127. *                                 des Speichers                                                01.09.89    *
  128. *                                                                                                                                *
  129. *         Bugs : keine bekannten                                                                            *
  130. *                                                                                                                                *
  131. *        Autor : Oesch Silvano                                                                                *
  132. *                                                                                                                                *
  133. *        Datum : 01.09.89                                                                                        *
  134. *                                                                                                                                *
  135. ****************************************************************/
  136.     
  137. int OpenHelp()
  138. {
  139.     char    *helpfile,                                /* Pointer auf FileNamen        */
  140.                 *buffer,                                    /* Pointer auf Strings            */
  141.                 line[LINESIZE];                        /* Inputzeile vom File            */
  142.     FILE    *help;                                        /* Filepointer                            */
  143.  
  144.     int erfolg,                                            /* genereller Rückgabewert    */
  145.             zeilen=FALSE,                                /* Funktionrückgabewert            */
  146.             laenge;                                            /* Länge vom Inputstring        */
  147.  
  148.     helpfile = getenv(helpname);        /* Hole FileNamen                        */
  149.     if (helpfile)                                        /* Ist Namen vorhanden ?        */
  150.     {                                                            /* Ja                                                */
  151.         help = fopen(helpfile,"r");    /* File öffnen zum lesen        */
  152.         if (help)
  153.         {
  154.             while((fgets(line,LINESIZE,help)!= NULL)&&(zeilen < MAXLINE))
  155.             {
  156.                 laenge = strlen(line);
  157.                 buffer = malloc (laenge);
  158.                 textarray[zeilen++]=buffer;
  159.                 erfolg = stccpy(buffer,line,laenge);
  160.             }
  161.             fclose(help);
  162.         }
  163.     }
  164.     return (zeilen);                                /* return mit Zeilen                */
  165. }
  166.  
  167. /****************************************************************
  168. *                                                                                                                                *
  169. *    Funktion : CloseHelp()                                                                                *
  170. *                                                                                                                                *
  171. *****************************************************************
  172. *                                                                                                                                *
  173. *        Input : int zeilen                                                                                    *
  174. *                                line ist die Anzahl eingelesener Zeilen                    *
  175. *                                                                                                                                *
  176. *     Output : Boolean                                                                                            *
  177. *                            TRUE    -> keine Fehler                                                            *
  178. *                            FALSE -> Fehler bei Speicherfreigabe                            *
  179. *                                                                                                                                *
  180. *****************************************************************
  181. *                                                                                                                                *
  182. *    Comment : Diese Routine gibt den Speicher für den Helptext        *
  183. *                        wieder an das System zurück.                                                *
  184. *                        Die auftrettenden Fehler bei der Speicher-                    *
  185. *                        rückgabe werden aufaddiert und am Schluss                        *
  186. *                        ausgewertet.                                                                                *
  187. *                                                                                                                                *
  188. *            Rev : V1.0                                                                                                *
  189. *                                                                                                                                *
  190. *    History : V1.0 erstellen dieses Files                                01.09.89    *
  191. *                                                                                                                                *
  192. *         Bugs : keine bekannten                                                                            *
  193. *                                                                                                                                *
  194. *        Autor : Oesch Silvano                                                                                *
  195. *                                                                                                                                *
  196. *        Datum : 01.09.89                                                                                        *
  197. *                                                                                                                                *
  198. ****************************************************************/
  199.  
  200. void CloseHelp(zeilen)
  201. int zeilen;                                                    /* Anzahl gelesener Zeilen    */
  202.     {
  203.         int i;                                                    /* Schleifenzähler                    */
  204.  
  205.         for (i=0;i<zeilen;i++)                    /* Für alle Felder                    */
  206.             free(textarray[i]);                        /* Speicher freigeben und        */
  207.     }
  208.  
  209. /****************************************************************
  210. *                                                                                                                                *
  211. *    Funktion : PrintPage()                                                                                *
  212. *                                                                                                                                *
  213. *****************************************************************
  214. *                                                                                                                                *
  215. *        Input : int zeile         Startfeld ab dem geschrieben                        *
  216. *                                                 werden soll.                                                        *
  217. *                                                                                                                                *
  218. *     Output : None                                                                                                *
  219. *                                                                                                                                *
  220. *****************************************************************
  221. *                                                                                                                                *
  222. *    Comment : Diese Routine schreibt eine Bildschirmseite ab            *
  223. *                        der Position von [zeile].                                                        *
  224. *                                                                                                                                *
  225. *            Rev : V1.0                                                                                                *
  226. *                                                                                                                                *
  227. *    History : V1.0 erstellen dieses Files                                01.09.89    *
  228. *                                                                                                                                *
  229. *         Bugs : keine bekannten                                                                            *
  230. *                                                                                                                                *
  231. *        Autor : Oesch Silvano                                                                                *
  232. *                                                                                                                                *
  233. *        Datum : 01.09.89                                                                                        *
  234. *                                                                                                                                *
  235. ****************************************************************/
  236.  
  237. void PrintPage(zeile)
  238.     int zeile;                                                /* Startwert vom textarray    */
  239.     {
  240.         int i,                                                    /* Schleifenzähler                    */
  241.                 y=SOT+TEXTSIZE/2;                        /* Konstante                                */
  242.  
  243.         Rechteck(    HRp,                                    /* Rechteck Rastport                */
  244.                             2,                                        /* Farbe                                        */
  245.                             TEXTSIZE,                            /* linke Begrenzung                    */
  246.                             SOT,                                    /* obere Begrenzung                    */
  247.                             SCREENBREITE-TEXTSIZE,
  248.                                                                         /* untere Begrenzung                */
  249.                             (screenzeilen+1)*TEXTSIZE+SOT);
  250.                                                                         /* rechte Begrenzung                */
  251.         for ( i=0;i<screenzeilen;i++)        /* alle Zeilen des Screens    */
  252.             PrintText(HRp,textarray[i+zeile],
  253.         (SHORT)(2*TEXTSIZE),(SHORT)(i*TEXTSIZE+y),1);
  254.     }
  255.  
  256. /****************************************************************
  257. *                                                                                                                                *
  258. *    Funktion : Help                                                                                                *
  259. *                                                                                                                                *
  260. *****************************************************************
  261. *                                                                                                                                *
  262. *        Input : None                                                                                                *
  263. *                                                                                                                                *
  264. *     Output : Boolean                                                                                            *
  265. *                        Boolean für Fehler die nicht selber abgefangen            *
  266. *                                        sind.                                                                                *
  267. *                                        TRUE    -> kein Fehler                                                *
  268. *                                        FALSE -> Fehler                                                            *
  269. *                                                                                                                                *
  270. *****************************************************************
  271. *                                                                                                                                *
  272. *    Comment : Eine Datei wird geladen und angezeigt.                            *
  273. *                                                                                                                                *
  274. *            Rev : V1.0                                                                                                *
  275. *                                                                                                                                *
  276. *    History : V1.0 erstellen dieses Files                                01.09.89    *
  277. *                                                                                                                                *
  278. *         Bugs : keine bekannten                                                                            *
  279. *                                                                                                                                *
  280. *        Autor : Oesch Silvano                                                                                *
  281. *                                                                                                                                *
  282. *        Datum : 01.09.89                                                                                        *
  283. *                                                                                                                                *
  284. ****************************************************************/
  285.  
  286. int Help()
  287. {
  288.     struct IntuiMessage *message;
  289.     struct Gadget *gadmess;                    /* Gadget Message                        */
  290.  
  291.     int loop = TRUE,
  292.             i = 0,
  293.             zeilen;
  294.  
  295.     helpwindow.Screen = Sc;                    /* Init. MainWindowstruktur    */
  296.     helpwindow.Height = SCREENHOEHE;
  297.  
  298.     Hw = (struct Window *)OpenWindow (&helpwindow);
  299.     if (Hw == NULL)
  300.     {
  301.         SimpleRequest(windowtext);
  302.         return (TRUE);
  303.     }
  304.  
  305.     HRp = Hw->RPort;                                /* Rastport initialisieren    */
  306.     zeilen = OpenHelp();
  307.     screenzeilen = (SCREENHOEHE-SOT-TEXTSIZE)/TEXTSIZE;
  308.     if (zeilen == FALSE)
  309.     {
  310.         SimpleRequest(helpload);
  311.         CloseWindow ( Hw );
  312.         return ( TRUE );
  313.     }
  314.     PrintPage(i);
  315.     while (loop)
  316.     {
  317.         message = (struct IntuiMessage *)GetMsg(Hw->UserPort);
  318.         if (message==NULL)
  319.         {
  320.             ClearPointer(Hw);
  321.             Wait(1L << Hw->UserPort->mp_SigBit);
  322.             continue;
  323.         }
  324.         gadmess = (struct Gadget *)message->IAddress;
  325.         ReplyMsg(message);
  326.         SetPointer(Hw,sprite1,POINTERHOEHE,POINTERBREITE,
  327.                                                     POINTERSPOT,POINTERSPOT);
  328.         switch (gadmess->GadgetID)
  329.         {
  330.             case NEXTPAGE:
  331.                 i = i+screenzeilen;
  332.                 i = min(i,zeilen-screenzeilen-1);
  333.                 PrintPage(i);
  334.                 break;
  335.             case CANCEL:
  336.                 loop = FALSE;
  337.                 ClearPointer(Hw);
  338.                 break;
  339.             case PREVPAGE:
  340.                 i=i-screenzeilen;
  341.                 i=max(i,0);
  342.                 PrintPage(i);
  343.                 break;
  344.         }
  345.     }
  346.     CloseHelp(zeilen);
  347.     CloseWindow (Hw);
  348.     return(TRUE);
  349. }
  350.