home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / window / winedit / beispiel.c next >
Encoding:
C/C++ Source or Header  |  1993-07-28  |  26.8 KB  |  1,011 lines
  1.  
  2. /****************************************************************************
  3. Das nachfolgende Beispiel verdeutlicht das Zusammenwirken
  4. der einzelnen Komponenten der WINEDIT-Anwenderschnittstelle.
  5.  
  6. Zur Übersetzung des Programms stehen TC-Projektdatei und
  7. TC-Konfigurationsfile zur verfügung. Sicherzustellen ist, daß
  8. im TC-Menüpunkt Options/Directories die Pfade zum
  9. LIB-File W_TBC_LM.LIB und zum INCLUDE-File W_DEF.H eingetragen
  10. sind, oder sich diese im aktuellen Directory befinden.
  11. Weiter muß die Übersetzung im LARGE-MODEL erfolgen, da aus
  12. Platzgründen nur eine Libary für diese Modell beigefügt ist.
  13.  
  14. Auf eine Fehlerüberprüfung nach Aufruf von WINEDIT-Funktionen
  15. wurde der Übersicht halber weitgehend verzichtet.
  16.  
  17. Häufigste Fehlerursachen sind erfahrungsgemäß
  18.  
  19. - falscher Dateiname beim Laden einer Maskendatei mit w_load
  20.  
  21. - nicht ausreichend verfügbarer Speicherplatz beim Laden oder
  22.   Öffnen einer Maske;
  23.   es sollte überprüft werden, ob z.B. durch  Unterbinden des
  24.   Anlegens virtueller Bilder bei Aufruf von w_load Speicher
  25.   gespart werden kann.
  26.   es sollten selten benutzte Masken erst bei Bedarf geladen
  27.   und anschließend mit w_erase(..) sofort wieder gelöscht werden.
  28.  
  29.  
  30. - das vielfache Laden ein und derselben Maske dadurch, daß der
  31.   Ladevorgang erst bei Bedarf z.B. in einem Unterprogramm erfolgt,
  32.   ein Löschen der Maske mit w_erase(..) jedoch bei Verlassen des
  33.   Unterprogramms nicht erfolgt. Es ist durchaus zulässig, eine
  34.   Maske mehrfach zu laden; nur ist irgendwann unweigerlich der
  35.   Speicher voll.
  36.  
  37. - ein zu kleiner Stackbereich des Programms; dieser läßt
  38.   sich bekanntermaßen setzen mit z.B.
  39.  
  40.   extern unsigned int _stklen = 16384;
  41.  
  42.  
  43. Im Beispielprogramm werden die einzelnen Masken erst bei Bedarf
  44. zugeladen und anschließend wieder gelöscht. Möglich wäre natürlich
  45. auch, alle Masken am Anfang des Programms einmalig zu Laden; dadurch
  46. werden Verzögerungszeiten beim Nachladen vermieden, der Speicherbedarf
  47. ist jedoch um einiges größer.
  48.  
  49. Um die Wirkung der Konfigurationsfunktionen zu w_switch(..) zu
  50. ergründen, empfiehlt sich ein Herumspielen an diesen und
  51. Betrachten der Ergebnisse;
  52. ****************************************************************************/
  53.  
  54.  
  55. /*
  56. W_DEF.H enhält die Prototypen der WINEDIT-Funktionen
  57. und definiert einige Konstanten
  58. */
  59. #include <w_def.h>
  60.  
  61. #include <stdio.h>
  62. #include <stdlib.h>
  63. #include <dos.h>
  64. #include <dir.h>
  65. #include <string.h>
  66. #include <mem.h>
  67.  
  68.  
  69.  
  70. /**************************************************************************
  71. Gibt verschiedene Hilfstexte aus
  72. ***/
  73. void hilfe(void);
  74.  
  75. /**************************************************************************
  76. Ermöglich die Anwahl eines Dateinamens
  77. ***/
  78. int  datei_menue(char name[MAXPATH],int mode);
  79.  
  80. /**************************************************************************
  81. Ermöglicht die Anwahl eines Ascii-Zeichens
  82. ***/
  83. int  ascii_waehlen(void);
  84.  
  85. /**************************************************************************
  86. Ermöglicht die Anwahl eines Bildschirm-Attributes
  87. ***/
  88. int  attribut_waehlen(int altes_attribut);
  89.  
  90. /**************************************************************************
  91. Baut ein (teilweise) dreistufiges Menü auf
  92. ***/
  93. void menue(void);
  94.  
  95.  
  96.  
  97. void main(void)
  98. {
  99. int m;
  100. char s[MAXPATH];
  101.  
  102. w_init(0);
  103. /*
  104. Initialisierung,
  105. Parameter 0 bewirkt einen direkten Zugriff auf den Bildspeicher
  106. Returnwert zeigt an, ob Maus angeschlossen ist
  107. */
  108.  
  109.  
  110. m=w_load("hmenue.msk",1);
  111. /*
  112. Das Hauptmenü wird ohne Anlegen eines virtuellen Bildes geladen,
  113. über die Maskennummer in m wird das Hauptmenü zukünftig angesprochen
  114. */
  115.  
  116. w_open(m);
  117. /*
  118. Das Hauptmenü wird auf den Schirm ausgegeben
  119. */
  120.  
  121. do
  122.     switch(w_switch(m))
  123.         /*
  124.         In w_switch erfolgt die Auswahl aus dem Hauptmenü, die
  125.         einzelnen anwählbaren Stellen im Hauptmenü sind bei
  126.         Erstellung der Maske definiert und nummeriert worden.
  127.         */
  128.         {
  129.         case 0:
  130.             hilfe();
  131.             break;
  132.         case 1:
  133.             datei_menue(strcpy(s,"*.*"),1);
  134.             break;
  135.         case 2:
  136.             ascii_waehlen();
  137.             break;
  138.         case 3:
  139.             attribut_waehlen(0x07);
  140.             break;
  141.         case 4:
  142.             menue();
  143.             break;
  144.         default:
  145.             break;
  146.         }
  147. while(w_switch_last_key(m)!= KEY_ESC &&
  148.       w_switch_last_key(m)!= MOUSE_R_B);
  149. /*
  150. Abbruch nur, wenn die letzte Taste in w_switch ESC
  151. oder linke Maustaste war.
  152. */
  153.  
  154.  
  155. w_close();
  156. /*
  157. Das Hauptmenü wird vom Bildschirm genommen, der
  158. ursprüngliche Bildinhalt zurückgesichert. Eine
  159. Referenznummer ist nicht erforderlich, da die
  160. Masken in einem Maskenstapel verwaltet werden und
  161. somit immer die oberste Maske im Stapel
  162. geschlossen wird.
  163. */
  164. v_clrscr();
  165. w_deinit();
  166. /*
  167. Beseitigt und löscht alle Maskenbestandteile im Speicher;
  168. */
  169. }
  170.  
  171.  
  172. /***************************************************************************/
  173. int ascii_waehlen(void)
  174. {
  175. int i;
  176. int m;
  177.  
  178. m=w_load("ascii.msk",1);
  179. /*
  180. Maske von Platte laden
  181. */
  182.  
  183. w_switch_matrix(m,1,0,0,0,0);
  184. /*
  185. Beschleunigte Anwahl wegen Maxtrix-artiger Anordnung
  186. der Positionen möglich; Dies ist nur bei einer großen
  187. Anzahl an Positionen relevant.
  188. Entfernt man diesen Aufruf, so wird man einen
  189. Zeitverzug nach Aufruf von w_switch bemerken.
  190. In dieser Zeit wird dann die Anordnung
  191. der einzelnen Anwahlpositionen zueinander überprüft.
  192. */
  193.  
  194. w_open(m);
  195. /*
  196. Maske ausgeben auf Schirm
  197. */
  198.  
  199. i=w_switch(m);
  200. /*
  201. Auswahl durchführen
  202. */
  203.  
  204. w_close();
  205. /*
  206. Maske vom Schirm nehmen
  207. */
  208.  
  209. w_erase(m);
  210. /*
  211. Da die Maske bei jedem Unterprogrammaufruf neu geladen wird,
  212. muß sie natürlich bei verlassen des Unterprogramms gelöscht
  213. werden
  214. */
  215.  
  216. if(i<0)
  217.     return(i);
  218. else
  219.     return(i+32);
  220. }
  221.  
  222. /***************************************************************************/
  223. int attribut_waehlen(int altes_attribut)
  224. {
  225. int i,m;
  226.  
  227. m=w_load("attrib.msk",1);
  228.  
  229. w_switch_mark_mode(m,1);
  230. /*
  231. Markierung der Anwahlpositionen mit Pfeilen
  232. statt mit Attribut
  233. */
  234.  
  235. w_switch_pos(m,altes_attribut);
  236. /*
  237. Bei Start markierte Position setzen;
  238. normalerweise wird bei Position 0 begonnen,
  239. hier nun bei Position altes_attribut
  240. */
  241.  
  242. w_switch_matrix(m,1,0,0,0,0);
  243. w_open(m);
  244. i=w_switch(m);
  245. w_close();
  246. w_erase(m);
  247. return(i);
  248. }
  249.  
  250.  
  251.  
  252.  
  253. /***************************************************************************/
  254. void menue(void)
  255. {
  256. int i,m[40],s,ok0,ok1,ok2;
  257.  
  258. m[ 0]=w_load("m0-00.msk",1);
  259. m[ 1]=w_load("m1-00.msk",1);
  260. m[ 2]=w_load("m1-01.msk",1);
  261. m[ 3]=w_load("m1-02.msk",1);
  262. m[ 4]=w_load("m1-03.msk",1);
  263. m[ 5]=w_load("m1-04.msk",1);
  264. m[ 6]=w_load("m2-00.msk",1);
  265. m[ 7]=w_load("m2-01.msk",1);
  266. m[ 8]=w_load("m2-02.msk",1);
  267. m[ 9]=w_load("m2-03.msk",1);
  268. /*
  269. Alle Menüs und Untermenüs laden
  270. */
  271.  
  272. for(i=0;i<10;++i)
  273.     if(m[i]<0)
  274.         {
  275.         printf("\nFehler beim Laden von Nummer %d",i);
  276.         w_deinit();
  277.         exit(-1);
  278.         }
  279.  
  280.  
  281. for(s=0;s<10;++s)
  282.     {
  283.     w_switch_mouse_cr(m[s],1);
  284.     w_switch_mouse_esc(m[s],1);
  285.     }
  286. /*
  287. Hier wird die w_switch(..) so konfiguriert, daß lediglich durch
  288. Positionierung des Mauszeigers eine Anwahl erfolgt.
  289. Weiter ist das Verlassen eines Untermenüs über beliebige
  290. Menühirachien hinweg mittels Mauszeiger möglich.
  291.  
  292. Der Wert dieser Funktionen läß sich am besten erfahren, in dem
  293. man sie testweise entfernt.
  294. */
  295.  
  296.  
  297. if(!w_open(m[0]))
  298.     {
  299.     printf("\nFehler %d beim Öffnen ",w_error());
  300.     w_deinit();
  301.     exit(-1);
  302.     }
  303. /*
  304. So könnte eine Fehlermeldung aussehen
  305. */
  306.  
  307.  
  308. do
  309.     {
  310.     ok0=0;
  311.     switch(s=w_switch(m[0]))
  312.         {
  313.         case 0:
  314.             w_open(m[s+1]);
  315.             ok1=0;
  316.             do
  317.                 {
  318.                 switch(w_switch(m[s+1]))
  319.                     {
  320.                     case 0:
  321.                         w_open(m[6]);
  322.                         ok2=0;
  323.                         do
  324.                             {
  325.                             switch(w_switch(m[6]))
  326.                                 {
  327.                                 case 0:
  328.                                     /*
  329.                                     Hier und folgend sind
  330.                                     die anwählbaren Aktionen
  331.                                     einzusetzen
  332.                                     */
  333.                                     break;
  334.                                 case 1:
  335.                                     break;
  336.                                 case 3:
  337.                                     break;
  338.                                 case -1:
  339.                                     ok2=1;
  340.                                     break;
  341.                                 default:
  342.                                     break;
  343.                                 }
  344.                             }
  345.                         while(!ok2);
  346.                         w_close();
  347.                         break;
  348.                     case 1:
  349.                         w_open(m[7]);
  350.                         ok2=0;
  351.                         do
  352.                             {
  353.                             switch(w_switch(m[7]))
  354.                                 {
  355.                                 case 0:
  356.                                     break;
  357.                                 case 1:
  358.                                     break;
  359.                                 case 3:
  360.                                     break;
  361.                                 case -1:
  362.                                     ok2=1;
  363.                                     break;
  364.                                 default:
  365.                                     break;
  366.                                 }
  367.                             }
  368.                         while(!ok2);
  369.                         w_close();
  370.                         break;
  371.                     case 2:
  372.                         w_open(m[8]);
  373.                         ok2=0;
  374.                         do
  375.                             {
  376.                             switch(w_switch(m[8]))
  377.                                 {
  378.                                 case 0:
  379.                                     break;
  380.                                 case 1:
  381.                                     break;
  382.                                 case 3:
  383.                                     break;
  384.                                 case -1:
  385.                                     ok2=1;
  386.                                     break;
  387.                                 default:
  388.                                     break;
  389.                                 }
  390.                             }
  391.                         while(!ok2);
  392.                         w_close();
  393.                         break;
  394.                     case 3:
  395.                         w_open(m[9]);
  396.                         ok2=0;
  397.                         do
  398.                             {
  399.                             switch(w_switch(m[9]))
  400.                                 {
  401.                                 case 0:
  402.                                     break;
  403.                                 case 1:
  404.                                     break;
  405.                                 case 3:
  406.                                     break;
  407.                                 case -1:
  408.                                     ok2=1;
  409.                                     break;
  410.                                 default:
  411.                                     break;
  412.                                 }
  413.                             }
  414.                         while(!ok2);
  415.                         w_close();
  416.                         break;
  417.                     case 4:
  418.                         break;
  419.                     case -1:
  420.                         ok1=1;
  421.                         break;
  422.                     default:
  423.                         break;
  424.                     }
  425.                 }
  426.             while(!ok1);
  427.             w_close();
  428.             break;
  429.         case 1:
  430.             w_open(m[s+1]);
  431.             ok1=0;
  432.             do
  433.                 {
  434.                 switch(w_switch(m[s+1]))
  435.                     {
  436.                     case 0:
  437.                     case 1:
  438.                     case 2:
  439.                     case 3:
  440.                     case 4:
  441.                     case 5:
  442.                         break;
  443.                     case -1:
  444.                         ok1=1;
  445.                         break;
  446.                     default:
  447.                         break;
  448.                     }
  449.                 }
  450.             while(!ok1);
  451.             w_close();
  452.             break;
  453.         case 2:
  454.             w_open(m[s+1]);
  455.             ok1=0;
  456.             do
  457.                 {
  458.                 switch(w_switch(m[s+1]))
  459.                     {
  460.                     case 0:
  461.                     case 1:
  462.                     case 2:
  463.                     case 3:
  464.                     case 4:
  465.                     case 5:
  466.                         break;
  467.                     case -1:
  468.                         ok1=1;
  469.                         break;
  470.                     default:
  471.                         break;
  472.                     }
  473.                 }
  474.             while(!ok1);
  475.             w_close();
  476.             break;
  477.         case 3:
  478.             w_open(m[s+1]);
  479.             ok1=0;
  480.             do
  481.                 {
  482.                 switch(w_switch(m[s+1]))
  483.                     {
  484.                     case 0:
  485.                     case 1:
  486.                     case 2:
  487.                     case 3:
  488.                     case 4:
  489.                     case 5:
  490.                         break;
  491.                     case -1:
  492.                         ok1=1;
  493.                         break;
  494.                     default:
  495.                         break;
  496.                     }
  497.                 }
  498.             while(!ok1);
  499.             w_close();
  500.             break;
  501.         case 4:
  502.             w_open(m[s+1]);
  503.             ok1=0;
  504.             do
  505.                 {
  506.                 switch(w_switch(m[s+1]))
  507.                     {
  508.                     case 0:
  509.                     case 1:
  510.                     case 2:
  511.                     case 3:
  512.                     case 4:
  513.                     case 5:
  514.                         break;
  515.                     case -1:
  516.                         ok1=1;
  517.                         break;
  518.                     default:
  519.                         break;
  520.                     }
  521.                 }
  522.  
  523.             while(!ok1);
  524.             w_close();
  525.             break;
  526.         case -1:
  527.             ok0=1;
  528.             break;
  529.         default:
  530.             break;
  531.         }
  532.     }
  533. while(!ok0);
  534. w_close();
  535. for(i=0;i<10;++i)
  536.     w_erase(m[i]);
  537. }
  538.  
  539.  
  540.  
  541. /***************************************************************************/
  542. void hilfe(void)
  543. {
  544. int i,m[6],s,ok;
  545. int akt;
  546.  
  547. m[ 0]=w_load("h0.msk",1);
  548. m[ 1]=w_load("h2.msk",1);
  549. m[ 2]=w_load("h3.msk",1);
  550. m[ 3]=w_load("h1.msk",1);
  551. m[ 4]=w_load("h4.msk",1);
  552.  
  553. for(i=0;i<5;++i)
  554.     if(m[i]<0)
  555.         {
  556.         printf("\nFehler beim Laden von Nummer %d",i);
  557.         w_deinit();
  558.         exit(-1);
  559.         }
  560.  
  561.  
  562. akt=0;
  563. ok=0;
  564. do
  565.     {
  566.     w_open(m[akt]);
  567.     switch(s=w_switch(m[akt]))
  568.         {
  569.         case 0:
  570.         case 1:
  571.         case 2:
  572.         case 3:
  573.             if(s>=akt)
  574.                akt=s+1;
  575.             else
  576.                akt=s;
  577.             w_close();
  578.             break;
  579.         case -1:
  580.             w_close();
  581.             ok=1;
  582.         default:
  583.             break;
  584.         }
  585.     }
  586. while(!ok);
  587.  
  588. for(i=0;i<5;++i)
  589.     w_erase(m[i]);
  590. }
  591.  
  592.  
  593.  
  594.  
  595. #define FELDER       40   /* Felder der Maske*/
  596. #define SPALTEN       4   /* Felder pro Zeile der Maske */
  597. #define DATEIEN     256   /* Maximum an einlesbaren Dateien, erweiterbar ! */
  598.  
  599.  
  600. static char dateiname[DATEIEN][13]; /*Speichert die Dateinamen*/
  601. static int anzahl=0;                /*Dateien + Subdirectories im Pfad*/
  602. static int scroll=0;                /*Anzahl der (gescrollten Zeilen)*SPALTEN*/
  603. static int maske;                   /*Maskenreferenznummer*/
  604.  
  605.  
  606. static void vshow(void);
  607.  
  608. /*****************************************************************************/
  609. int datei_menue(char name[MAXPATH],int mode)
  610. {
  611.  
  612. struct ffblk merkmal;
  613. int i,ret;
  614. int newdir=1;                         /*Neues Directory wurde angewaehlt*/
  615. int anzfile;                           /*Summe der Dateien im Pfad*/
  616. int ok=0;                           /*Schleifendeterminator*/
  617. int aktpos=0;                       /*Aktuelle Dateinummer*/
  618. int viewpos=0;                      /*Aktuelles Feld in der Maske*/
  619. int res;
  620. int wechsel=1;                      /*Kontrolliert Maskenrefresh*/
  621. int taste;
  622.  
  623. char drive[MAXDRIVE];
  624. char dir[MAXDIR];
  625. char fname[MAXFILE];
  626. char ext[MAXEXT];
  627. char pfad[MAXPATH];
  628. char aktpfad[MAXPATH];
  629. char buffer[MAXPATH];
  630. char *bufferp;
  631.  
  632. /*
  633. Maskenbeschreibung wird aus einer Datei in den Speicher geladen;
  634. Der zweite Parameter mit dem Wert 0 bewirkt, daß zu dieser Maske
  635. ein virtueller Bildschirm angelegt wird.
  636. */
  637.  
  638. maske=w_load("file.msk",0);
  639. if(maske<0)
  640.     {
  641.     printf("\nFehler %d beim Laden der Maske file.msk",w_error());
  642.     w_deinit();
  643.     exit(-1);
  644.     }
  645. w_switch_matrix(maske,1,1,1,1,1);
  646. /*
  647. a) Matrix-artige Anordnung
  648. b) Bei Cursorbewegungen über die Kanten der Maske hinaus
  649.    Abbruch der Funktion w_switch(..). Dies ist zur
  650.    Realisierung einer Scroll-Funktion sinnvoll.
  651. */
  652. w_switch_break_on_key(maske,2);
  653. w_open(maske);
  654. strcpy(buffer,strupr(name));
  655. while(1)
  656.     {
  657.     /*
  658.     Maske einlesen
  659.     */
  660.     w_in_break_on_key(1);
  661.     taste=w_in_last_key();
  662.     res=w_in_str(maske,40,MAXPATH,buffer,"");
  663.     if((res==-1) || ((res==-2)&&(taste==MOUSE_R_B)))
  664.         {
  665.         w_close();
  666.         w_erase(maske);
  667.         return(0);
  668.         }
  669.  
  670.     /*
  671.     Komplette Pfadbezeichnung erzeugen
  672.     */
  673.     strupr(buffer);
  674.  
  675.     if(strlen(buffer)==0)
  676.         strcat(buffer,"*.*");
  677.  
  678.     if(strlen(buffer)<2 || buffer[1]!=':')
  679.         /*
  680.         Laufwerk ergänzen
  681.         */
  682.         {
  683.         aktpfad[0]=getdisk()+'A';
  684.         aktpfad[1]=':';
  685.         bufferp=&buffer[0];
  686.         }
  687.     else
  688.         {
  689.         memcpy(aktpfad,buffer,2);
  690.         bufferp=&buffer[2];
  691.         }
  692.  
  693.     if(bufferp[0]!='\\')
  694.         /*
  695.         Aktuellen Pfad ergänzen
  696.         */
  697.         {
  698.         aktpfad[2]='\\';
  699.         getcurdir(aktpfad[0]+1-'A',aktpfad+3);
  700.         if(aktpfad[strlen(aktpfad)-1] != '\\')
  701.             strcat(aktpfad,"\\");
  702.         strcat(aktpfad,bufferp);
  703.         }
  704.     else
  705.         {
  706.         strcpy(aktpfad+2,bufferp);
  707.         }
  708.  
  709.  
  710.     while(newdir)
  711.         {
  712.         wechsel=1;
  713.         for(i=0;i<FELDER;++i)
  714.            /*
  715.            Felder löschen
  716.            */
  717.            {
  718.            w_vout_str(maske,i,"            ");
  719.            }
  720.         w_switch_pos(maske,0);
  721.  
  722.         fnsplit(aktpfad,drive,dir,fname,ext);
  723.         fnmerge(pfad,drive,dir,"*",NULL);
  724.  
  725.         anzahl=0;
  726.         ret=findfirst(aktpfad,&merkmal,0);
  727.         while(!ret && (anzahl < (DATEIEN-4)))
  728.             {
  729.             strcpy(&dateiname[anzahl++][0],merkmal.ff_name);
  730.             ret=findnext(&merkmal);
  731.             }
  732.  
  733.         anzfile=anzahl;
  734.         ret=findfirst(pfad,&merkmal,FA_DIREC);
  735.         while(!ret && (anzahl < (DATEIEN-2)) && mode)
  736.             {
  737.             if(merkmal.ff_attrib==FA_DIREC)
  738.                 {
  739.                 strcpy(&dateiname[anzahl][0],merkmal.ff_name);
  740.                 strcat(&dateiname[anzahl++][0],"\\");
  741.                 }
  742.              ret=findnext(&merkmal);
  743.              }
  744.  
  745.  
  746.         w_vout_str(maske,40,aktpfad);
  747.  
  748.         for(i=0;i<anzahl && i<FELDER;++i)
  749.            {
  750.            w_vout_str(maske,i,&dateiname[i][0]);
  751.            }
  752.  
  753.         /*
  754.         Virtuelles Bild ausgeben
  755.         */
  756.         w_vout(maske);
  757.         taste=0;
  758.         scroll=0;
  759.         ok=0;
  760.         do
  761.             {
  762.             if(anzahl==0)
  763.                 {
  764.                 w_out_str(maske,1,"KEINE DATEI");
  765.                 taste=KEY_ESC;
  766.                 break;
  767.                 }
  768.  
  769.  
  770.             if(scroll>0)
  771.                 w_vout_str(maske,41," ZURÜCK ");
  772.             else
  773.                 w_vout_str(maske,41,"        ");
  774.  
  775.             if((scroll+FELDER) < anzahl)
  776.                 w_vout_str(maske,42,"  VOR   ");
  777.             else
  778.                 w_vout_str(maske,42,"        ");
  779.  
  780.             i=anzahl-scroll-1;
  781.             if(i>=FELDER)
  782.                 i=FELDER-1;
  783.             w_switch_range(maske,0,i);
  784.             if(wechsel==1)
  785.                 {
  786.                 w_vout(maske);
  787.                 wechsel=0;
  788.                 }
  789.  
  790.             switch(i=w_switch(maske))
  791.                 {
  792.                 case -1:
  793.                     taste=KEY_ESC;
  794.                     ok=1;
  795.                     break;
  796.                 case -2:
  797.                     taste=w_switch_last_key(maske);
  798.                     viewpos=w_switch_pos(maske,-1);
  799.                     switch(taste)
  800.                         {
  801.             case MOUSE_L_B:
  802.                         case KEY_PGUP:
  803.                         case KEY_PGDN:
  804.                             if((w_xyon_field(maske,w_mouse_cur_x(),w_mouse_cur_y())==41) || (taste==KEY_PGUP))
  805.                                 {
  806.                                 scroll-=FELDER;
  807.                                 if(scroll < 0)
  808.                                     scroll=0;
  809.                                 wechsel=1;
  810.                                 vshow();
  811.                                 }
  812.                             else if((w_xyon_field(maske,w_mouse_cur_x(),w_mouse_cur_y())==42) || (taste==KEY_PGDN))
  813.                                 {
  814.                                 if((scroll+FELDER) < anzahl)
  815.                                     {
  816.                                     scroll+=FELDER;
  817.                                     if((scroll + viewpos) >= anzahl)
  818.                                         {
  819.                                         viewpos=anzahl-1-scroll;
  820.                                         w_switch_pos(maske,viewpos);
  821.                                         }
  822.                                     wechsel=1;
  823.                                     vshow();
  824.                                     }
  825.                                 }
  826.                             break;
  827.                         case KEY_C_D:
  828.                             if((scroll+FELDER) < anzahl)
  829.                                 {
  830.                                 scroll+=SPALTEN;
  831.                                 if((scroll + viewpos) >= anzahl)
  832.                                     {
  833.                                     viewpos=anzahl-1-scroll;
  834.                                     w_switch_pos(maske,viewpos);
  835.                                     }
  836.                                 wechsel=1;
  837.                                 vshow();
  838.                                 }
  839.                             break;
  840.                         case KEY_C_L:
  841.                             if((viewpos==0) && scroll>0)
  842.                                 {
  843.                                 scroll-=SPALTEN;
  844.                                 wechsel=1;
  845.                                 vshow();
  846.                                 }
  847.                             else if(viewpos>0)
  848.                                 {
  849.                                 viewpos-=1;
  850.                                 w_switch_pos(maske,viewpos);
  851.                                 }
  852.                             break;
  853.                         case KEY_C_R:
  854.                             if( ( (scroll+FELDER) < anzahl) && (viewpos==(FELDER-1)))
  855.                                 {
  856.                                 scroll+=SPALTEN;
  857.                                 wechsel=1;
  858.                                 vshow();
  859.                                 }
  860.                             else if((scroll+viewpos) < (anzahl-1))
  861.                                 {
  862.                                 viewpos+=1;
  863.                                 w_switch_pos(maske,viewpos);
  864.                                 }
  865.                             break;
  866.                         case KEY_C_U:
  867.                             if(scroll > 0)
  868.                                 {
  869.                                 scroll-=SPALTEN;
  870.                                 wechsel=1;
  871.                                 vshow();
  872.                                 }
  873.                             break;
  874.                         default:
  875.                             break;
  876.                         }
  877.                     break;
  878.                 default:
  879.                     if( (i>=0) && (i < anzahl))
  880.                         ok=1;
  881.                         taste=KEY_CR;
  882.                     break;
  883.                 }
  884.             if(!(i<0))
  885.                 {
  886.                 aktpos=i + scroll;
  887.                 viewpos=i;
  888.                 }
  889.             aktpos=scroll+viewpos;
  890.             }
  891.         while(!ok);
  892.  
  893.  
  894.         if((taste==KEY_ESC))
  895.             {
  896.             break;
  897.             }
  898.         else if(strnicmp(&dateiname[aktpos][0],"..\\",3)==0)
  899.             /*
  900.             Einen Pfad zurück
  901.             */
  902.             {
  903.             newdir=1;
  904.             *strrchr(dir,'\\')='\0';
  905.             if(strrchr(dir,'\\')!=NULL)
  906.                 *(1+strrchr(dir,'\\'))='\0';
  907.             else
  908.                 *dir='\0';
  909.             fnmerge(aktpfad,drive,dir,fname,ext);
  910.             }
  911.         else if(strnicmp(&dateiname[aktpos][0],".\\",3)==0)
  912.             /*
  913.             Root wurde angewählt
  914.             */
  915.             {
  916.             newdir=1;
  917.             strcpy(dir,"\\");
  918.             fnmerge(aktpfad,drive,dir,fname,ext);
  919.             }
  920.         else if((aktpos)>(anzfile-1))
  921.             {
  922.             newdir=1;
  923.             strcat(dir,&dateiname[aktpos][0]);
  924.             fnmerge(aktpfad,drive,dir,fname,ext);
  925.             }
  926.         else
  927.             {
  928.             newdir=0;
  929.             }
  930.         }
  931.  
  932.     if(taste==KEY_CR)
  933.         {
  934.         taste=0;
  935.         fnmerge(aktpfad,drive,dir,&dateiname[aktpos][0],NULL);
  936.         if(strlen(aktpfad)>79)
  937.             *(aktpfad+79)='\0';
  938.         /*
  939.         Pfad ,wenn möglich, um aktuellen Pfad verkürzen
  940.         */
  941.  
  942.         getcurdir(aktpfad[0]+1-'A',buffer);
  943.         if((getdisk()+'A')==aktpfad[0])
  944.             /*
  945.             Laufwerk im Pfad ist aktuelles Laufwerk
  946.             */
  947.             {
  948.             if(strncmp(buffer,aktpfad+3,strlen(buffer))==0 && strlen(buffer)!=0)
  949.                 /*
  950.                 Aktueller Pfad ist enthalten
  951.                 */
  952.                 {
  953.                 strcpy(name,aktpfad+4+strlen(buffer) /*+2 für Backslash*2 */ );
  954.                 }
  955.             else
  956.                 /*
  957.                 Nur das Laufwerk kann entfallen
  958.                 */
  959.                 {
  960.                 strcpy(name,aktpfad+2);
  961.                 }
  962.             }
  963.         else
  964.             {
  965.             name[0]=aktpfad[0];
  966.             name[1]=aktpfad[1];
  967.             if(strncmp(buffer,aktpfad+3,strlen(buffer))==0 && strlen(buffer)!=0)
  968.                 /*
  969.                 Aktueller Pfad ist enthalten
  970.                 */
  971.                 {
  972.                 strcpy(name+2,aktpfad+4+strlen(buffer));
  973.                 }
  974.             else
  975.                 /*
  976.                 Nichts kann entfallen
  977.                 */
  978.                 {
  979.                 strcpy(name+2,aktpfad+2);
  980.                 }
  981.             }
  982.         w_close();
  983.         w_erase(maske);
  984.         return(1);
  985.         }
  986.     }
  987. return(1);
  988. }
  989.  
  990.  
  991.  
  992. static void vshow(void)
  993. {
  994. int j;
  995.  
  996. /*Neue Belegung auf den virtuellen Schirm ausgeben*/
  997.  
  998. for(j=0;j<(anzahl-scroll) && j<FELDER;++j)
  999.     {
  1000.     w_vout_str(maske,j,&dateiname[j+scroll][0]);
  1001.     }
  1002.  
  1003. /*Rest löschen*/
  1004.  
  1005. for(j=(anzahl-scroll);j<FELDER;++j)
  1006.     {
  1007.     w_vout_str(maske,j,"            ");
  1008.     }
  1009. }
  1010.  
  1011.