home *** CD-ROM | disk | FTP | other *** search
/ ST-Computer Leser-CD 1999 January / STC_CD_01_1999.iso / base / pd_ph105 / easyfsel.c < prev    next >
C/C++ Source or Header  |  2000-01-08  |  15KB  |  478 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. #include <string.h>
  24. #include <ext.h>
  25. #include <stdlib.h>
  26.  
  27. DTA Dta;
  28.  
  29. #define _sysbase    (0x4f2l)
  30.  
  31. /* -------------------------------------------------------------------- */
  32. /*        Globale Variablen                                                */
  33. /* -------------------------------------------------------------------- */
  34. DTAX My_dta;
  35.  
  36. /* -------------------------------------------------------------------- */
  37. /*         lokale Funktionsprototypen                                        */
  38. /* -------------------------------------------------------------------- */
  39.  
  40. long * get_cookie_ptr(long cookie_name);
  41. int cmp_maske(char *str,char *maske);
  42.  
  43. /*------------------------------------------------------------------*/
  44. /*    BOOLEAN easy_fsel(BYTE *pfad, BYTE *dateiname, BYTE *text)        */
  45. /*                                                                    */
  46. /*    Zeigt die Fileselectorbox je nach AES-Version und 'FSEL'-Cookie    */
  47. /*    an und übernimmt die Auswertung.                                */
  48. /*    Bei einer AES-Version >= 0x0014 oder gesetztem 'FSEL-Cookie'    */
  49. /*    wird fsel_exinput() aufgerufen, sonst fsel_input().                */
  50. /*                                                                    */
  51. /*    Parameter:Pfad und Dateiname, mit denen die Fileselectorbox     */
  52. /*                        aufgerufen werden soll.                        */
  53. /*    Rückgabe :TRUE, wenn alles glattging und der Benutzer OK ge-    */
  54. /*                drückt hat, FALSE falls ein Fehler aufgetreten ist    */
  55. /*                oder Abbruch gewählt wurde.    Der neue Pfad steht        */
  56. /*                in 'pfad', der ausgewählte Dateiname in dateiname'.    */
  57. /*------------------------------------------------------------------*/
  58.  
  59. BOOLEAN easy_fsel(BYTE *pfad, BYTE *dateiname, BYTE *text)
  60. {
  61.     WORD button;
  62.     WORD result;
  63.     LONG c_wert = 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. /*            long lof(FILE *stream)                                    */
  120. /*                                                                    */
  121. /* Ermittelt die Länge eines offenen Files                            */
  122. /*                                                                    */
  123. /*                                                                    */
  124. /*        Parameter: das File                                            */
  125. /*        Rückgabe : Länge des Files                                    */
  126. /*                                                                    */
  127. /*        (c) Dimitri Junker                                            */
  128. /*------------------------------------------------------------------*/
  129.  
  130.  
  131. long lof(FILE *stream)
  132. {    long pos,len;
  133.     pos=ftell(stream);
  134.     fseek(stream,0,SEEK_END);
  135.     len=ftell(stream);
  136.     fseek(stream,pos,SEEK_SET);
  137.     return(len);
  138. }
  139.  
  140. /*------------------------------------------------------------------*/
  141. /*            BOOLEAN get_cookie(long cookie_name, LONG *cookie_value)*/
  142. /*            Ermittelt den Wert eines Cookies                        */
  143. /*                                                                    */
  144. /*        Parameter:     cookie_name: Name des zu suchenden Cookies        */
  145. /*                    *cookie_value: Pointer für die Rückgabe            */
  146. /*        Rückgabe :     0,1: 1=erfolgreich                                */
  147. /*                    falls 1: Wert des Cookies in cookie_value        */
  148. /*                    cookie_value kann NULL sein, dann wird nur die    */
  149. /*                    Existenz des Cookies getestet                    */
  150. /*                                                                    */
  151. /*        (c) Dimitri Junker                                            */
  152. /*                                                                    */
  153. /*------------------------------------------------------------------*/
  154.  
  155. BOOLEAN get_cookie(long cookie_name, LONG *cookie_value)
  156. {
  157.     LONG *cookie;
  158.     int ret=1;
  159.     
  160.     /* Zuerst einen Zeiger auf den Cookie holen */
  161.  
  162.     cookie = get_cookie_ptr(cookie_name);
  163.  
  164.     /* Ist der Cookiejar vorhanden ? */
  165.     
  166.     if(!cookie)
  167.         ret=0;
  168.     else
  169.     {    if(!cookie[0])
  170.             ret=0;
  171.         else
  172.         {    if(cookie_value)
  173.                 *cookie_value=cookie[1];
  174.         }
  175.     }
  176.     return(ret);
  177. }
  178. /*------------------------------------------------------------------*/
  179. /*    long get_cookie_jar()                                            */
  180. /*                                                                    */
  181. /*    Ermittelt die Adresse des Cookie Jar.                            */
  182. /*                                                                    */
  183. /*    Parameter:keine                                                     */
  184. /*    Rückgabe :Adresse, falls der Cookie Jar gefunden wurde,            */
  185. /*              NULL falls kein Cookie-Jar                            */
  186. /*  Besonderheit: mu₧ per Supexec aufgerufen werden                    */
  187. /*    (c) by Dimitri Junker 1996                                        */
  188. /*------------------------------------------------------------------*/
  189.  
  190. long  get_cookie_jar()
  191. {
  192.     LONG *cookiejar;
  193.  
  194.     cookiejar = *((LONG **) 0x5a0L);
  195.     return((long)cookiejar);
  196. }
  197. /*------------------------------------------------------------------*/
  198. /*    long *get_cookie_ptr(BYTE *cookie_name)                            */
  199. /*                                                                    */
  200. /*    Sucht nach einem Cookie 'cookie_name' und liefert dessen         */
  201. /*    Adresse zurück.                                                    */
  202. /*                                                                    */
  203. /*    Parameter:Name des Cookies                                         */
  204. /*    Rückgabe :Adresse, falls der Cookie gefunden wurde,                */
  205. /*              Adresse des NULL-cookie falls nicht vorhanden            */
  206. /*              NULL falls kein Cookie-Jar                            */
  207. /*    (c) by Dimitri Junker 1996                                        */
  208. /*------------------------------------------------------------------*/
  209.  
  210. long * get_cookie_ptr(long cookie_name)
  211. {
  212.     LONG *cookiejar;
  213.  
  214.     /* Zuerst einen Zeiger auf den Cookiejar holen */
  215.  
  216.     cookiejar = (long *)Supexec(get_cookie_jar);
  217.  
  218.     /* Ist der Cookiejar vorhanden ? */
  219.     
  220.     if(!cookiejar)
  221.         return(NULL);
  222.     else
  223.     {
  224.         do
  225.         {
  226.             /* Ist es unser Cookie ? */
  227.             if(*cookiejar== cookie_name)
  228.                 break;
  229.             else
  230.             {
  231.                 /* nächster Cookie aus Jar */
  232.                 cookiejar = &(cookiejar[2]);
  233.             }
  234.         } 
  235.         while(cookiejar[0]);  /* solange nicht NULL-Cookie */
  236.     
  237.         return(cookiejar);;
  238.   }
  239. }
  240.  
  241. /*------------------------------------------------------------------*/
  242. /*    long get_act_pd()                                                */
  243. /*                                                                    */
  244. /*    Gibt die Basepage des aktuellen Proz. zurück                    */
  245. /*                                                                    */
  246. /*    Parameter:    keiner                                                */
  247. /*    Rückgabe :Die Funktion liefert als Ergebnis den Pointer,         */
  248. /*        allerdings als long, wegen Supexec                             */
  249. /*    (c) by Dimitri Junker 1996                                        */
  250. /*    nach Profibuch S.185                                            */
  251. /*    Besonderheit: mu₧ per Supexec aufgerufen werden                    */
  252. /*------------------------------------------------------------------*/
  253. long get_act_pd(void)
  254. {    BASPAG *bp;
  255.     SYSHDR *os;
  256.     
  257.     os=*(SYSHDR **)_sysbase;
  258.     os=os->os_base;
  259.     bp=*os->_run;
  260.     return((long)bp);
  261. }
  262.  
  263. /*------------------------------------------------------------------*/
  264. /*    BOOLEAN exist(const BYTE *dateiname)                            */
  265. /*                                                                    */
  266. /*    Überprüft, ob die Datei 'dateiname' existiert.                    */
  267. /*                                                                    */
  268. /*    Parameter:Name der Datei.                                        */
  269. /*    Rückgabe :TRUE, falls die Datei existiert, FALSE wenn nicht.    */
  270. /*------------------------------------------------------------------*/
  271.  
  272. BOOLEAN exist(const BYTE *dateiname)
  273. {
  274.     if(fsfirst(dateiname, FA_READONLY | FA_HIDDEN | FA_SYSTEM |
  275.                                                 FA_ARCHIVE) == 0)
  276.         return TRUE;
  277.     else
  278.         return FALSE;
  279. }
  280. /*------------------------------------------------------------------*/
  281. /*    int fsfirst( const char *filename, int attr );                    */
  282. /*                                                                    */
  283. /*    Wie das gro₧e Vorbild, aber auch für alternative Filesysteme    */
  284. /*                                                                    */
  285. /*    Parameter:f_name: Filename, Pfad o.ä. der angepa₧t werden soll    */
  286. /*              pfad:      Pfad für den es getestet wird                    */        
  287. /*    Rückgabe :Die Funktion liefert als Ergebnis 0, wenn eine Datei    */
  288. /*              gefunden werden konnte, ansonsten einen Fehlercode.    */
  289. /*            die eigentliche Rückgabe geschiet in My_dta                */
  290. /*    (c) by Dimitri Junker 1996                                        */
  291. /*------------------------------------------------------------------*/
  292.  
  293. int fsfirst( const char *filename, int attr )
  294. {    static int first=1;
  295.     int rueck;
  296.     XATTR xdummy;
  297.     long ldummy;
  298.     if(first)
  299.     {    first=0;
  300.         Fsetdta(&Dta);
  301.         My_dta.d_flags=0;
  302.         My_dta.d_max_name=FILENAME_MAX;
  303.         My_dta.d_max_pfad=PATH_MAX;
  304.         My_dta.d_fname=malloc(My_dta.d_max_name+My_dta.d_max_pfad+4);
  305.         My_dta.d_fname=&My_dta.d_fname[4];
  306.         My_dta.d_pfad=&My_dta.d_fname[My_dta.d_max_name];
  307.         My_dta.d_sattr=attr;
  308.         if(Pdomain(-1)==1)
  309.         {    if((My_dta.d_handle=Dopendir(".",0))!=-32l)
  310.             {    My_dta.d_flags=DTF_DO;
  311.                 if(Fxattr(0,".",&xdummy)!=-32)
  312.                     My_dta.d_flags|=DTF_FX;
  313.                 if(Dxreaddir(FILENAME_MAX,My_dta.d_handle,My_dta.d_fname,&xdummy,&ldummy)!=-32)
  314.                     My_dta.d_flags|=DTF_FX;
  315.                 Dclosedir(My_dta.d_handle);
  316.             }
  317.         }
  318.     }
  319.     else
  320.     {    if((My_dta.d_flags&DTF_DO)!=0)
  321.             Dclosedir(My_dta.d_handle);
  322.     }
  323.     if((My_dta.d_flags&DTF_DO)!=0)
  324.     {    trenn_pfad(My_dta.d_pfad,My_dta.d_maske,filename);
  325.         if(((My_dta.d_handle=Dopendir(My_dta.d_pfad,0))&0xff000000l)==0l)
  326.             rueck=fsnext();
  327.         else
  328.             rueck=(int)My_dta.d_handle;
  329.     }
  330.     else
  331.     {    if((rueck=Fsfirst(filename,attr))==0)
  332.         {    memcpy(&My_dta,&Dta,(int)offsetof(DTAX,d_max_pfad));
  333.             strcpy(My_dta.d_fname,Dta.d_fname);
  334.         }
  335.         My_dta.d_max_pfad=PATH_MAX;
  336.         My_dta.d_max_name=12;
  337.     }
  338.     return(rueck);
  339. }
  340. /*------------------------------------------------------------------*/
  341. /*    void trenn_pfad(char *pfad,char *name,char *file)                */
  342. /*                                                                    */
  343. /*    Bastelt Pfad- und Dateinamen auseinander,                         */
  344. /*    Gegenteil von build_filename.                                    */
  345. /*    dabei endet der Pfad mit '\\'                                    */
  346. /*                                                                    */
  347. /*    Parameter:            file    = File mit Pfad+Name                */
  348. /*                        pfad    = Pfadname.                            */
  349. /*                        name     = Dateiname.                        */
  350. /*            file und pfad dürfen gleich sein                        */
  351. /*    war nicht Teil des Originals, also von DYJ                        */
  352. /*------------------------------------------------------------------*/
  353.  
  354. void trenn_pfad(char *pfad,char *name,const char *file)
  355. {     char *ptr;
  356.     if(file!=pfad)
  357.         strcpy(pfad,file);
  358.     if((ptr=strrchr(pfad,'\\'))==NULL)
  359.         ptr=pfad;                    /* dann ist wohl alles nur Name    */
  360.     else
  361.         ptr++;
  362.     strcpy(name,ptr);
  363.     *ptr='\0';
  364. }
  365. /*------------------------------------------------------------------*/
  366. /*    int fsnext(void);                                                */
  367. /*                                                                    */
  368. /*    Wie das gro₧e Vorbild, aber auch für alternative Filesysteme    */
  369. /*                                                                    */
  370. /*    Parameter:nur die in My_dta                                        */
  371. /*    Rückgabe :Die Funktion liefert als Ergebnis 0, wenn eine Datei    */
  372. /*              gefunden werden konnte, ansonsten einen Fehlercode.    */
  373. /*            die eigentliche Rückgabe geschiet in My_dta                */
  374. /*    (c) by Dimitri Junker 1996                                        */
  375. /*------------------------------------------------------------------*/
  376. int fsnext(void)
  377. {    int rueck;
  378.     XATTR xattr;
  379.     char name[PATH_MAX+FILENAME_MAX];
  380.     long xret=-32l;
  381.     if((My_dta.d_flags&DTF_DO)==0)
  382.     {    if((rueck=Fsnext())==0)
  383.         {    memcpy(&My_dta,&Dta,(int)offsetof(DTAX,d_max_pfad));
  384.             strcpy(My_dta.d_fname,Dta.d_fname);
  385.         }
  386.     }
  387.     else
  388.     {    do
  389.         {    if((My_dta.d_flags&DTF_DX)==0)
  390.                 rueck=(int)Dreaddir(My_dta.d_max_name,My_dta.d_handle,&My_dta.d_fname[-4]);
  391.             else
  392.                 rueck=(int)Dxreaddir(My_dta.d_max_name,My_dta.d_handle,&My_dta.d_fname[-4],&xattr,&xret);
  393.             switch(rueck)
  394.             {    case 0:
  395.                     rueck=1-cmp_maske(My_dta.d_fname,My_dta.d_maske);
  396.                     break;
  397.                 case -64:
  398.                     My_dta.d_max_name*=2;
  399.                     My_dta.d_fname=realloc(&My_dta.d_fname[-4],My_dta.d_max_name+My_dta.d_max_pfad+4);
  400.                     My_dta.d_fname=&My_dta.d_fname[4];
  401.                     My_dta.d_pfad=&My_dta.d_fname[My_dta.d_max_name];
  402.                     rueck=1;
  403.                     break;
  404.             }
  405.             if(!rueck)    /* dann noch die Attribute testen    */
  406.             {    if((My_dta.d_flags&(DTF_DX|DTF_FX))==DTF_FX)
  407.                 {    build_filename(name,My_dta.d_pfad,My_dta.d_fname);
  408.                     xret=Fxattr(0,name,&xattr);
  409.                 }
  410.                 if(!xret)
  411.                 {    if((xattr.attr&(~My_dta.d_sattr))==0)
  412.                     {    My_dta.d_attrib=xattr.attr;
  413.                         My_dta.d_time=xattr.mtime;
  414.                         My_dta.d_date=xattr.mdate;
  415.                         My_dta.d_length=xattr.size;
  416.                     }
  417.                     else
  418.                         rueck=1;
  419.                 }
  420.             }
  421.         }while(rueck==1);
  422.     }
  423.     return(rueck);
  424. }
  425. /*------------------------------------------------------------------*/
  426. /*    int cmp_maske(char *str,char *maske);                            */
  427. /*                                                                    */
  428. /*    Prüft ob str mit maske verträglich ist.                            */
  429. /*                                                                    */
  430. /*    Parameter:    str ein String                                        */
  431. /*                maske die maske, mit * und ?                        */
  432. /*  Achtung *? ist nicht =* sondern irgendwas gefolgt von  '?'        */
  433. /*    Rückgabe :Die Funktion liefert als Ergebnis 1, wenn             */
  434. /*             beide verträglich sind, sonst 0                        */
  435. /*    (c) by Dimitri Junker 1996                                        */
  436. /*------------------------------------------------------------------*/
  437. int cmp_maske(char *str,char *maske)
  438. {    char *m_ptr,*s_ptr;
  439.     int gleich=-1;
  440.     m_ptr=maske;
  441.     s_ptr=str;
  442.     while(gleich==-1)
  443.     {    switch((int)*m_ptr)
  444.         {    case '*':
  445.                 if(*(++m_ptr))
  446.                 {    if((s_ptr=strchr(s_ptr,(int)m_ptr[1]))==NULL)
  447.                         gleich=0;
  448.                     else
  449.                         m_ptr++;
  450.                 }
  451.                 else
  452.                     gleich=1;
  453.                 break;
  454.             case '?':
  455.                 if(*s_ptr)
  456.                 {    s_ptr++;
  457.                     m_ptr++;
  458.                 }
  459.                 else
  460.                     gleich=0;
  461.                 break;
  462.             case '\0':
  463.                 gleich=(*s_ptr=='\0');
  464.                 break;
  465.             default:
  466.                 if(*s_ptr==*m_ptr)
  467.                 {    s_ptr++;
  468.                     m_ptr++;
  469.                 }
  470.                 else
  471.                     gleich=0;
  472.         }
  473.     }
  474.     return(gleich);
  475. }
  476.  
  477. /*----------------------- Ende der Datei. --------------------------*/
  478.