home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser 1998 October / STC_CD_10_1998.iso / BASE / PD_PATCH / EASYFSEL.C next >
C/C++ Source or Header  |  1998-09-26  |  7KB  |  234 lines
  1. /********************************************************************/
  2. /*    EASYFSEL.C                                                        */
  3. /*                                                                    */
  4. /*    Routine zum leichten und AES-Versions abhängigen Aufruf der        */
  5. /*    GEM-Fileselectorbox mit Auswertung des 'FSEL' - Cookies.        */
  6. /*    Au₧erdem sind einige Routinen zum Umgang mit Dateien enthalten,    */
  7. /*    sowie zum Suchen eines Cookies.                                    */
  8. /*                                                                    */
  9. /*    Version : 1.27                                                    */
  10. /*    Datum   : 15.06.1992                                            */
  11. /*    Autor        : Andreas Papula (falls nicht anders angegeben)        */
  12. /*                                                                    */
  13. /*    Copyright 1992 by MAXON Computer GmbH                            */
  14. /********************************************************************/
  15.  
  16. /*------------------------------------------------------------------*/
  17. /*    Include-Files einbinden.                                        */
  18. /*------------------------------------------------------------------*/
  19.  
  20. #include "easyfsel.h"
  21. #include <aes.h>
  22. #include <stddef.h>
  23. DTA Dta;
  24.  
  25. #define _sysbase    (0x4f2l)
  26.  
  27. /* -------------------------------------------------------------------- */
  28. /*        Globale Variablen                                                */
  29. /* -------------------------------------------------------------------- */
  30.  
  31. /* -------------------------------------------------------------------- */
  32. /*         lokale Funktionsprototypen                                        */
  33. /* -------------------------------------------------------------------- */
  34.  
  35. long * get_cookie_ptr(long cookie_name);
  36.  
  37. /*------------------------------------------------------------------*/
  38. /*    BOOLEAN easy_fsel(BYTE *pfad, BYTE *dateiname, BYTE *text)        */
  39. /*                                                                    */
  40. /*    Zeigt die Fileselectorbox je nach AES-Version und 'FSEL'-Cookie    */
  41. /*    an und übernimmt die Auswertung.                                */
  42. /*    Bei einer AES-Version >= 0x0014 oder gesetztem 'FSEL-Cookie'    */
  43. /*    wird fsel_exinput() aufgerufen, sonst fsel_input().                */
  44. /*                                                                    */
  45. /*    Parameter:Pfad und Dateiname, mit denen die Fileselectorbox     */
  46. /*                        aufgerufen werden soll.                        */
  47. /*    Rückgabe :TRUE, wenn alles glattging und der Benutzer OK ge-    */
  48. /*                drückt hat, FALSE falls ein Fehler aufgetreten ist    */
  49. /*                oder Abbruch gewählt wurde.    Der neue Pfad steht        */
  50. /*                in 'pfad', der ausgewählte Dateiname in dateiname'.    */
  51. /*------------------------------------------------------------------*/
  52.  
  53. BOOLEAN easy_fsel(BYTE *pfad, BYTE *dateiname, BYTE *text)
  54. {
  55.     WORD button;
  56.     WORD result;
  57.     LONG c_wert = 0;
  58.     char *blank;
  59.     /* DYJ ' ' im Pfad- und Dateinamen eliminieren*/
  60.     if((blank=strchr(pfad,' '))!=NULL)
  61.         *blank=0;
  62.     if((blank=strchr(dateiname,' '))!=NULL)
  63.         *blank=0;
  64.     /* Entsprechend der Version und des 'FSEL' - Cookies */
  65.     /* fsel_input() oder fsel_exinput() aufrufen */
  66.  
  67.     if(_GemParBlk.global[0] < 0x0140 && get_cookie('FSEL', &c_wert) == FALSE)
  68.         result = fsel_input(pfad, dateiname, &button);
  69.     else
  70.         result = fsel_exinput(pfad, dateiname, &button, text);
  71.  
  72.     /* Wenn Fehler aufgetreten oder Abbruch ausgewählt */
  73.     if(result == 0 || button == 0)
  74.         return FALSE;
  75.     else
  76.         return TRUE;
  77. }
  78.  
  79. /*------------------------------------------------------------------*/
  80. /*    VOID build_filename(BYTE *dest, BYTE *pfad, BYTE *dateiname)    */
  81. /*                                                                    */
  82. /*    Bastelt Pfad- und Dateinamen zusammen.                            */
  83. /*                                                                    */
  84. /*    Parameter:dest      = Zielstring.                                */
  85. /*                        pfad      = Pfadname.                        */
  86. /*                        dateiname = Dateiname.                        */
  87. /*    Rückgabe :Das Ergebnis befindet sich in dest.                    */
  88. /*------------------------------------------------------------------*/
  89.  
  90. VOID build_filename(BYTE *dest, BYTE *pfad, BYTE *dateiname)
  91. {
  92.     BYTE *xyz;
  93.  
  94.     strcpy(dest, pfad);
  95.     xyz = strrchr(dest, (int) '\\');
  96.     strcpy(++xyz, dateiname);
  97. }
  98.  
  99.  
  100. /*------------------------------------------------------------------*/
  101. /*            BYTE *get_akt_path(BYTE *path)                            */
  102. /*                                                                    */
  103. /*            Gibt das aktuelle Laufwerk und dessen Pfad zurück.        */
  104. /*                                                                    */
  105. /*        Parameter: Zeiger auf einen String.                            */
  106. /*        Rückgabe : Zeiger auf das aktuelle Laufwerk und Directory.    */
  107. /*------------------------------------------------------------------*/
  108.  
  109. BYTE *get_akt_path(BYTE *path)
  110. {
  111.     strcpy(path, " :");
  112.     path[0] = 'A' + getdisk();  /* Laufwerk */
  113.     getcurdir(0, path+2);                /* Directory */
  114.     strcat(path,"\\");
  115.     return(path);
  116. }
  117.  
  118.  
  119. /* Ermittelt die Länge eines offenen Files    */
  120. long lof(FILE *stream)
  121. {    long pos,len;
  122.     pos=ftell(stream);
  123.     fseek(stream,0,SEEK_END);
  124.     len=ftell(stream);
  125.     fseek(stream,pos,SEEK_SET);
  126.     return(len);
  127. }
  128. BOOLEAN get_cookie(long cookie_name, LONG *cookie_value)
  129. {
  130.     LONG *cookie;
  131.     int ret=1;
  132.     
  133.     /* Zuerst einen Zeiger auf den Cookie holen */
  134.  
  135.     cookie = get_cookie_ptr(cookie_name);
  136.  
  137.     /* Ist der Cookiejar vorhanden ? */
  138.     
  139.     if(!cookie)
  140.         ret=0;
  141.     else
  142.     {    if(!cookie[0])
  143.             ret=0;
  144.         else
  145.             *cookie_value=cookie[1];
  146.     }
  147.     return(ret);
  148. }
  149. /*------------------------------------------------------------------*/
  150. /*    long get_cookie_jar()                                            */
  151. /*                                                                    */
  152. /*    Ermittelt die Adresse des Cookie Jar.                            */
  153. /*                                                                    */
  154. /*    Parameter:keine                                                     */
  155. /*    Rückgabe :Adresse, falls der Cookie Jar gefunden wurde,            */
  156. /*              NULL falls kein Cookie-Jar                            */
  157. /*  Besonderheit: mu₧ per Supexec aufgerufen werden                    */
  158. /*    (c) by Dimitri Junker 1996                                        */
  159. /*------------------------------------------------------------------*/
  160.  
  161. long  get_cookie_jar()
  162. {
  163.     LONG *cookiejar;
  164.  
  165.     cookiejar = *((LONG **) 0x5a0L);
  166.     return((long)cookiejar);
  167. }
  168. /*------------------------------------------------------------------*/
  169. /*    long *get_cookie_ptr(BYTE *cookie_name)                            */
  170. /*                                                                    */
  171. /*    Sucht nach einem Cookie 'cookie_name' und liefert dessen         */
  172. /*    Adresse zurück.                                                    */
  173. /*                                                                    */
  174. /*    Parameter:Name des Cookies                                         */
  175. /*    Rückgabe :Adresse, falls der Cookie gefunden wurde,                */
  176. /*              Adresse des NULL-cookie falls nicht vorhanden            */
  177. /*              NULL falls kein Cookie-Jar                            */
  178. /*    (c) by Dimitri Junker 1996                                        */
  179. /*------------------------------------------------------------------*/
  180.  
  181. long * get_cookie_ptr(long cookie_name)
  182. {
  183.     LONG *cookiejar;
  184.  
  185.     /* Zuerst einen Zeiger auf den Cookiejar holen */
  186.  
  187.     cookiejar = (long *)Supexec(get_cookie_jar);
  188.  
  189.     /* Ist der Cookiejar vorhanden ? */
  190.     
  191.     if(!cookiejar)
  192.         return(NULL);
  193.     else
  194.     {
  195.         do
  196.         {
  197.             /* Ist es unser Cookie ? */
  198.             if(*cookiejar== cookie_name)
  199.                 break;
  200.             else
  201.             {
  202.                 /* nächster Cookie aus Jar */
  203.                 cookiejar = &(cookiejar[2]);
  204.             }
  205.         } 
  206.         while(cookiejar[0]);  /* solange nicht NULL-Cookie */
  207.     
  208.         return(cookiejar);;
  209.   }
  210. }
  211.  
  212. /*----------------------- Ende der Datei. --------------------------*/
  213.     /*------------------------------------------------------------------*/
  214. /*    long get_act_pd()                                                */
  215. /*                                                                    */
  216. /*    Gibt die Basepage des aktuellen Proz. zurück                    */
  217. /*                                                                    */
  218. /*    Parameter:    keiner                                                */
  219. /*    Rückgabe :Die Funktion liefert als Ergebnis den Pointer,         */
  220. /*        allerdings als long, wegen Supexec                             */
  221. /*    (c) by Dimitri Junker 1996                                        */
  222. /*    nach Profibuch S.185                                            */
  223. /*    Besonderheit: mu₧ per Supexec aufgerufen werden                    */
  224. /*------------------------------------------------------------------*/
  225. long get_act_pd(void)
  226. {    BASPAG *bp;
  227.     SYSHDR *os;
  228.     
  229.     os=*(SYSHDR **)_sysbase;
  230.     os=os->os_base;
  231.     bp=*os->_run;
  232.     return((long)bp);
  233. }
  234.