home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / text+faqs / time_guide / source / t_bestellen.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-14  |  74.3 KB  |  2,537 lines
  1. /*********************************************************
  2.  * Time Disk Bestellungsprogramm für die Time.guide        *
  3.  *                (Mein allererstes C Programm)                        *
  4.  *********************************************************
  5.  * Autor:                    Manfred Tremmel                        *
  6.  * Programmiersprache:    C                                            *
  7.  * Compilier:                Maxon C++ (ANSI-C-Modus)            *
  8.  *********************************************************/
  9.  
  10. /* Versionsstring festlegen (fürs Shellkomando Version)    */ 
  11. char VersionID[] = "$VER: T_Bestellen 1.51 (14.06.95)";
  12.  
  13. /* C-Include für String-Operationen                                */
  14. #include <string.h>
  15. #include <stdlib.h>
  16. /* C-Include für Dateioperationen (laden, speichern)        */
  17. #include <stdio.h>
  18.  
  19. /* AMIGA-Includes für die Exec.library                            */
  20. #include <clib/exec_protos.h>
  21. #include <exec/memory.h>
  22. /* AMIGA-Include für die AmigaGuide.library                    */
  23. #include <clib/amigaguide_protos.h>
  24. /* AMIGA-Include für die graphics.library                        */
  25. #include <clib/graphics_protos.h>
  26. /* AMIGA-Include für die intuition.library                    */
  27. #include <clib/intuition_protos.h>
  28. /* AMIGA-Include für die gadtools.library                        */
  29. #include <clib/gadtools_protos.h>
  30. /* AMIGA-Include für die asl.library                            */
  31. #include <clib/asl_protos.h>
  32. /* AMIGA-Include für die locale.library                        */
  33. #include <clib/locale_protos.h>
  34. /* AMIGA-Include für die icon.library                            */
  35. #include <clib/icon_protos.h>
  36. /* AMIGA-Include für die commodities.library                    */
  37. #include <clib/commodities_protos.h>
  38. #include <clib/alib_protos.h>
  39.  
  40. /* AMIGA-Include, das die ganzen pragma/#? included        */
  41. #include <pragma/all_lib.h>
  42.  
  43. /* AMIGA-Include, daß das Programm WB-Startfähig macht    */
  44. #include <workbench/startup.h>
  45. #include <wbstartup.h>
  46.  
  47. /* Texte, die der User zu Gesicht kriegt (via Local-lib.)*/
  48. #include "T_Locale.h"
  49.  
  50. /* Structur für die Intuition.library                            */
  51. struct IntuitionBase    *IntuitionBase        = NULL;
  52. /* Structur für die graphics.library                            */
  53. struct GfxBase            *GfxBase                = NULL;
  54. /* Structur für die gadtools.library                            */
  55. struct Library            *GadToolsBase        = NULL;
  56. /* Structur für die AmigaGuide.library                            */
  57. struct Library            *AmigaGuideBase    = NULL;
  58. /* Structur für die Asl.library                                    */
  59. struct Library            *AslBase                = NULL;
  60. /* Structur für die locale.library                                */
  61. struct LocaleBase        *LocaleBase            = NULL;
  62. /* Structur für die icon.library                                    */
  63. struct IconBase        *IconBase            = NULL;
  64. /* Structur für die commodities.library                        */
  65. struct CxBase            *CxBase                = NULL;
  66. CxObj    *broker, *filter, *sender, *translate;
  67. #define EVT_HOTKEY 1L
  68.  
  69. /* Signal-Flag-Variablen für die Abfrag eingehender        */
  70. /* Nachrichten (Window und Commodity)                            */
  71. ULONG wndsigflag, cxsigflag;
  72.  
  73. /* Structur für den Asl-Filerequester                            */
  74. struct FileRequester    *fr;
  75. /* Structur für einen einfachen Info-Requester                */
  76. struct EasyStruct        es;
  77.  
  78.  
  79. /* Dient dazu, eine neue Liste anzulegen                        */
  80. void NewList(struct List *);
  81.  
  82. /* OS 3.x indikator NOS (New Operating System)                */
  83. BOOL NOS = TRUE;
  84. /* Anzahl sichtbarer Einträge im Listview-Gadget            */
  85. /* Unter OS 2.x sind es nur 11 unter 3.x 12 Einträge     */
  86. int  LVSicht = 12;
  87.  
  88. /* Globale Variablen definieren                                    */
  89. /* Einstellungen:                                                        */
  90. struct Einst {
  91.     char AName[30];            /* Absender:    Name                */
  92.     char AStrasse[30];        /* Absender:    Straße            */
  93.     char AOrt[30];                /* Absender:    Ort                */
  94.     char EName[30];            /* Empfänger:    Name                */    
  95.     char EStrasse[30];        /* Empfänger:    Straße            */
  96.     char EOrt[30];                /* Empfänger:    Ort                */
  97.     long Abstand;                /* Druckbeginnabstand            */
  98.     UWORD Versart;                /* Versandart                        */
  99.     char KundNr[30];            /* Absender:    Kundennummer    */
  100. };
  101.  
  102. struct Einst P1;                /* Konkrete Strukt. festlegen    */
  103.  
  104. /* Struktur der Diskettenliste (nur der Diskettenname)    */
  105. struct VDB{
  106.     char Name[15];                /* Diskettennamen                    */
  107. };
  108.  
  109. /* Structur zur Verwaltung der Diskettenliste anlegen        */
  110. struct VDBnode{
  111.     struct    Node n;
  112.     struct    VDB  d;
  113. };
  114.  
  115. /* erzeugt eine Liste, in die die einzelen VDBs kommen    */
  116. struct List vdblist;
  117.  
  118. /* vdblist enthält den aktuellen Eintrag oder NULL            */
  119. struct VDBnode *currentvdb;
  120.  
  121. /* Dateiname des Einstellungs-Files                                */
  122. char Einst_File[128] = "T_Best.dat";
  123.  
  124. /* Datei zwischengemerkter Disketten                            */
  125. char T_Remember[128] = "T:Time_Remember.dat";
  126.  
  127. /* Variablen für das Einbinden als Commodity                    */
  128. BYTE CX_Priority = 0;
  129. BOOL CX_Popup = TRUE;
  130. char CX_Popkey[30] = "ctrl alt t";
  131.  
  132. /* Titel des Fensters                                                */
  133. char WinTitel[50];
  134. /* Funktion GetString holt einen Text aus dem Puffer        */
  135. #define GetString( g )    ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  136. /* Funktion GetNumber holt eine Nummer aus dem Puffer        */
  137. #define GetNumber( g )    ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  138.  
  139. /* Die Nummern der Gadgets mit konkreten Bezeichnung        */
  140. #define GD_Diskliste        0        /* Diskettenliste                */
  141. #define GD_NeueDisk        1        /* Neu Button                    */
  142. #define GD_DiskLoeschen    2        /* Löschen Button                */
  143. #define GD_Zahlart        3        /* Zahlart MX-Button            */
  144. #define GD_Drucken        4        /* Drucken Button                */
  145. #define GD_Abbrechen        5        /* Abbrechen Button            */
  146. #define GD_AName            6        /* Absender: Name                */
  147. #define GD_AStrasse        7        /* Absender: Strasse            */
  148. #define GD_AOrt            8        /* Absender: Ort                */
  149. #define GD_KundNr            9        /* Kundennummer                */
  150. #define GD_EName            10        /* Empfänger: Name            */
  151. #define GD_EStrasse        11        /* Empfänger: Strasse        */
  152. #define GD_EOrt            12        /* Empfänger: Ort                */
  153. #define GD_DiskAender    13        /* Disk ändern                    */
  154. #define GD_Abstand        14        /* Abstand zum Druckbeginn    */
  155.  
  156. /* Anzahl der Gadgets definieren (0 bis 14 = 15)            */
  157. #define Bestellen_CNT                                    15
  158.  
  159. /* Die Nummern der Menus mit Konkreten Bezeichnungen        */
  160. #define MENU_FOO_OPA        1        /* Öffnen - Einstellungen    */
  161. #define MENU_FOO_OPB        2        /* Öffnen - Diskliste        */
  162. #define MENU_FOO_SPA        3        /* Speichern - Einstell.    */
  163. #define MENU_FOO_SPB        4        /* Speichern - Diskliste    */
  164. #define MENU_FOO_SAA        5        /* Speichern als -Einstell.*/
  165. #define MENU_FOO_SAB        6        /* Speichern als -Diskliste*/
  166. #define MENU_FOO_DRU        7        /* Drucken                        */
  167. #define MENU_FOO_INF        8        /* Information                    */
  168. #define MENU_FOO_HID        9        /* Verbergen                    */
  169. #define MENU_FOO_END        10        /* Ende                            */    
  170.  
  171. /* Screenstruktur löschen                                            */
  172. struct Screen            *Scr = NULL;
  173. /* Public Screen Name löschen                                        */
  174. UBYTE                        *PubScreenName = NULL;
  175. /* DrawInfo deklarieren und löschen                                */
  176. struct DrawInfo        *dri = NULL;
  177. /* VisualInfo löschen                                                */
  178. APTR                        VisualInfo = NULL;
  179. /* Window Struktur löschen                                            */
  180. struct Window            *BestellenWnd = NULL;
  181. /* Gadget Struktur löschen                                            */
  182. struct Gadget            *BestellenGList = NULL;
  183. /* Menu Struktur löschen                                            */
  184. struct Menu                *BestellenMenus = NULL;
  185. /* NewBroker Structur (zur Einbindung als Commodity)        */
  186. struct NewBroker        newbroker = {NULL, NULL, NULL, NULL,
  187.                                     NULL, NULL, NULL, NULL, NULL};
  188.  
  189. /* Anzahl GadgetStrukturen festlegen (15)                        */
  190. struct Gadget            *BestellenGadgets[15];
  191. /* Breite des Fensters (wird nach Fontbreite umgerechnet)*/
  192. UWORD                        BestellenWidth = 460;
  193. /* Höhe des Fenster (wird nach Fonthöhe umgerechnet)        */
  194. UWORD                        BestellenHeight = 250;
  195. /* Struktur Textatribute mit Fontinformationen definieren*/
  196. struct TextAttr        *Font, Attr;
  197. /* Definiere Felder für die Fontbreite und Höhe                */
  198. UWORD                        FontX, FontY;
  199. /* Definiere Felder für den minimalabstand des Fensters    */
  200. UWORD                        OffX, OffY;
  201. /* Definiere Felder für tatsächliche Pos. des Fensters    */
  202. UWORD                        WinX = 0;
  203. UWORD                        WinY = 0;
  204. /* Position im Listview-Gadget                                    */
  205. long                        ListPos = 0;
  206.  
  207. /* Textatribrute für das Fenster                                    */
  208. struct TextFont        *BestellenFont = NULL;
  209.  
  210. /* Texte für das Zahlungsform-MX-Gadget                        */
  211. UBYTE *Gadget300Labels[] = {
  212.     NULL,
  213.     NULL,
  214.     NULL,
  215.     NULL };
  216.  
  217. /* Zusätzliche Texte und deren Position                        */
  218. struct IntuiText BestellenIText[] = {
  219.     1, 0, JAM1,45, 014, NULL, NULL, NULL,
  220.     1, 0, JAM1,45, 132, NULL, NULL, NULL };
  221.  
  222. /* Anzahl zusätzlicher Texte                                        */
  223. #define Bestellen_TNUM 2
  224.  
  225. /* MenuStruktur füllen                                                */
  226. struct NewMenu BestellenNewMenu[] = {
  227.     NM_TITLE, NULL, NULL,    0, 0L, NULL,
  228.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  229.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_OPA),
  230.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_OPB),
  231.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  232.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SPA),
  233.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SPB),
  234.      NM_ITEM, NULL, NULL,    0, 0L, NULL,
  235.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SAA),
  236.       NM_SUB, NULL, NULL,    0, 0L, (void *)(MENU_FOO_SAB),
  237.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_DRU),
  238.      NM_ITEM, (STRPTR)NM_BARLABEL, NULL,    0, 0L, NULL,
  239.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_INF),
  240.      NM_ITEM, (STRPTR)NM_BARLABEL, NULL,    0, 0L, NULL,
  241.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_HID),
  242.      NM_ITEM, NULL, NULL,    0, 0L, (void *)(MENU_FOO_END),
  243.       NM_END, NULL, NULL,    0, 0L, NULL
  244. };
  245.  
  246. /* Gadgettypen definieren                                            */
  247. UWORD BestellenGTypes[] = {
  248.     LISTVIEW_KIND,
  249.     BUTTON_KIND,
  250.     BUTTON_KIND,
  251.     MX_KIND,
  252.     BUTTON_KIND,
  253.     BUTTON_KIND,
  254.     STRING_KIND,
  255.     STRING_KIND,
  256.     STRING_KIND,
  257.     STRING_KIND,
  258.     STRING_KIND,
  259.     STRING_KIND,
  260.     STRING_KIND,
  261.     STRING_KIND,
  262.     INTEGER_KIND
  263. };
  264.  
  265. /* Gadgets festlegen                                                    */
  266. struct NewGadget BestellenNGad[] = {
  267.     242,  24, 115, 156, NULL, NULL, GD_Diskliste, PLACETEXT_ABOVE, NULL, NULL,
  268.     242, 195,  47,  20, NULL, NULL, GD_NeueDisk, PLACETEXT_IN, NULL, NULL,
  269.     289, 195,  68,  20, NULL, NULL, GD_DiskLoeschen, PLACETEXT_IN, NULL, NULL,
  270.     361,  52,  17,   9, NULL, NULL, GD_Zahlart, PLACETEXT_RIGHT, NULL, NULL,
  271.       4, 225,  88,  20, NULL, NULL, GD_Drucken, PLACETEXT_IN, NULL, NULL,
  272.     366, 225,  88,  20, NULL, NULL, GD_Abbrechen, PLACETEXT_IN, NULL, NULL,
  273.      71,  28, 161,  20, NULL, NULL, GD_AName, PLACETEXT_LEFT, NULL, NULL,
  274.      71,  50, 161,  20, NULL, NULL, GD_AStrasse, PLACETEXT_LEFT, NULL, NULL,
  275.      71,  72, 161,  20, NULL, NULL, GD_AOrt, PLACETEXT_LEFT, NULL, NULL,
  276.      71,  94, 161,  20, NULL, NULL, GD_KundNr, PLACETEXT_LEFT, NULL, NULL,
  277.      71, 147, 161,  20, NULL, NULL, GD_EName, PLACETEXT_LEFT, NULL, NULL,
  278.      71, 169, 161,  20, NULL, NULL, GD_EStrasse, PLACETEXT_LEFT, NULL, NULL,
  279.      71, 191, 161,  20, NULL, NULL, GD_EOrt, PLACETEXT_LEFT, NULL, NULL,
  280.     242, 174, 115,  20, NULL, NULL, GD_DiskAender, 0, NULL, NULL,
  281.     361,  24,  86,  20, NULL, NULL, GD_Abstand, PLACETEXT_ABOVE, NULL, NULL
  282. };
  283.  
  284. /* Tags zu den Gadgets                                                */
  285. ULONG BestellenGTags[] = {
  286.     (GTLV_ShowSelected), 0, (GT_Underscore), '_', (TAG_DONE),
  287.     (GT_Underscore), '_', (TAG_DONE),
  288.     (GT_Underscore), '_', (TAG_DONE),
  289.     (GTMX_Labels), (ULONG)&Gadget300Labels[ 0 ], (GT_Underscore), '_', (TAG_DONE),
  290.     (GT_Underscore), '_', (TAG_DONE),
  291.     (GT_Underscore), '_', (TAG_DONE),
  292.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  293.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  294.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  295.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  296.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  297.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  298.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 29, (GT_Underscore), '_', (TAG_DONE),
  299.     (STRINGA_ExitHelp), TRUE, (GTST_MaxChars), 14, (TAG_DONE),
  300.     (STRINGA_ExitHelp), TRUE, (GTIN_Number), 0, (GTIN_MaxChars), 3, (GT_Underscore), '_', (TAG_DONE)
  301. };
  302.  
  303. /* Vordefinieren sämtlicher im Programm vorkommender        */
  304. /* Unterprogramme                                                        */
  305.  
  306. /* Positionen nach Fontbreite umrechnen                        */
  307. static UWORD ComputeX( UWORD value );
  308.  
  309. /* Positionen nach Fonthöhe umrechnen                            */
  310. static UWORD ComputeY( UWORD value );
  311.  
  312. /* Computerbreite und -höhe Bestimmen                            */
  313. static void ComputeFont( UWORD width, UWORD height );
  314.  
  315. /* Voreinstellungen fürs Fenster (Screen vorbereiten)        */
  316. int SetupScreen( void );
  317.  
  318. /* Sreen wieder zurücksetzen                                        */
  319. void CloseDownScreen( void );
  320.  
  321. /* Texte und BevelBoxes aufs Fenster zeichnen                */
  322. void BestellenRender( void );
  323.  
  324. /* Fenster öffenen                                                    */
  325. int OpenBestellenWindow( void );
  326.  
  327. /* Fenster wieder dicht machen                                    */
  328. void CloseBestellenWindow( void );
  329.  
  330. /*    Gadtools-Gadget einschalten                                     */
  331. void gt_OnGadget( struct Gadget     *gad, struct Window        *w );
  332.  
  333. /*    ...und wieder aus...                                                */
  334. void gt_OffGadget( struct Gadget     *gad, struct Window    *w );
  335.  
  336. /*  String-Gadgets mit nem string füllen                        */
  337. void gt_SetString( struct Gadget    *gad,
  338.                    struct Window    *w,
  339.                    char                *string );
  340.  
  341. /* und nachschaun, welcher drinnen steckt                        */
  342. char * gt_GetString( struct Gadget    *gad );
  343.  
  344. /* Integer-Gadgets mit ner Zahl füllen                            */
  345. void gt_SetInteger( struct Gadget    *gad,
  346.                     struct Window    *w,
  347.                     LONG            value );
  348.  
  349. /* und nachschaun, welche drinnen steckt                        */
  350. LONG gt_GetInteger( struct Gadget    *gad );
  351.  
  352. /* Liste anhängen                                                        */
  353. void gt_AttachList(    struct Gadget     *lv,
  354.                     struct Window     *w,
  355.                      struct List     *list );
  356.  
  357. /* Aktuellen Eintrag setzen                                        */
  358. void gt_SetLV( struct Gadget    *gad,
  359.                struct Window    *w,
  360.                ULONG            value);
  361.  
  362. /* x-ten Eintrag aus einer Exec-Liste holen */
  363. struct Node * gt_GetListEntry( struct List *l,
  364.                                int num );
  365.  
  366. /* Nummer einer Node aus einer Liste feststellen            */
  367. int gt_GetListEntryNum(    struct List *l,
  368.                         struct Node *n );
  369.  
  370. /* Anzahl Einträge einer Liste zählen                            */
  371. int gt_GetListNumEntries( struct List *l );
  372.  
  373. /* Gadgets ein oder Ausschalten                                    */
  374. void checkonoff( void );
  375.  
  376. /* Neuer Eintrag in die Liste    aufnehmen                        */
  377. void newvdb( void );
  378.  
  379. /* Libraries öffnen                                                    */
  380. BOOL OpenAll();
  381.  
  382. /* Libraries schließen                                                */
  383. void CloseAll();
  384.  
  385. /* Unterprogramm zum Einlesen der Einstellungen                */
  386. void EinstLesen();
  387.  
  388. /* Unterprogramm zum Schreiben der Einstellungen            */
  389. void EinstSchreiben();
  390.  
  391. /* Sortiert einen neuen Eintrag in die Liste ein.            */
  392. long NeuerEintrag(char *Eintrag);
  393.  
  394. /* Einen Eintrag aus der Liste entfernen                        */
  395. void EintragLoeschen();
  396.  
  397. /* Unterprogramm zum Einlesen der Time-Diskettendaten        */
  398. void DatenLesen();
  399.  
  400. /* Unterprogramm zum Schreiben der Time-Diskettendaten    */
  401. void DatenSchreiben( struct List *l);
  402.  
  403. /* Die Bestellung auf eine Postkarte Drucken                    */
  404. void Drucken( struct List *l );
  405.  
  406. /* Window mit den Voreingestellten Daten füllen                */
  407. void Winfuell();
  408.  
  409. /* Wenn jemand versucht ein Gadget zu erdrücken                */
  410. BOOL Abfrage_Gadgetup( struct Gadget *gad, long code);
  411.  
  412. /* Jemand hat das Menu benutzt                                    */
  413. BOOL Abfrage_Menuepick( UWORD code);
  414.  
  415. /* Eine handelsübliche Taste wurde gedrückt                    */
  416. BOOL Abfrage_Vanillakey( struct Gadget *gad, UWORD code);
  417.  
  418. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  419. void Abfrage_Rawkey( struct Gadget *gad, UWORD code, struct Gadget *gd);
  420.  
  421. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  422. void Abfrage_Menuhelp( UWORD code);
  423.  
  424. /* Localisierte Texte einlesen (wenn vorhanden)                */
  425. void LocaleLesen();
  426.  
  427.  
  428. /* Positionen nach Fontbreite umrechnen                        */
  429. static UWORD ComputeX( UWORD value )
  430. {
  431.     return(( UWORD )((( FontX * value ) + 3 ) / (UWORD)7 ));
  432. }
  433.  
  434. /* Positionen nach Fonthöhe umrechnen                            */
  435. static UWORD ComputeY( UWORD value )
  436. {
  437.     return(( UWORD )((( FontY * value ) + 6 ) / (UWORD)12 ));
  438. }
  439.  
  440. /* Computerbreite und -höhe Bestimmen                            */
  441. static void ComputeFont( UWORD width, UWORD height )
  442. {
  443.     /* Voreingestellten Font benutzen                            */
  444.     Font = &Attr;
  445.     /* Fontname bestimmen                                            */
  446.     Font->ta_Name = (STRPTR)Scr->RastPort.Font->tf_Message.mn_Node.ln_Name;
  447.     /* Fonthöhe bestimmen                                            */
  448.     Font->ta_YSize = FontY = Scr->RastPort.Font->tf_YSize;
  449.     /* Fontbreite bestimmen                                            */
  450.     FontX = Scr->RastPort.Font->tf_XSize;
  451.  
  452.     /* minimaler horizontaler Abstand                            */
  453.     OffX = Scr->WBorLeft;
  454.     /* minimaler vertikaler Abstand                                */
  455.     OffY = Scr->RastPort.TxHeight + Scr->WBorTop + 1;
  456.  
  457.     /* Überprüfen, ob das Fenster nicht zu groß wird        */ 
  458.     if ( width && height ) {
  459.         /* Wenn es horizontal zu groß wird, oder                */
  460.         if (( ComputeX( width ) + OffX + Scr->WBorRight ) > Scr->Width )
  461.             goto UseTopaz;
  462.         /* vertikal, dann benutze den Topas 8 Font            */
  463.         if (( ComputeY( height ) + OffY + Scr->WBorBottom ) > Scr->Height )
  464.             goto UseTopaz;
  465.     }
  466.     return;
  467.  
  468. /* Topas Font verwenden, weils Fenster sonst zu groß wird*/
  469. UseTopaz:
  470.     Font->ta_Name = (STRPTR)"topaz.font";
  471.     FontX = FontY = Font->ta_YSize = 8;
  472. }
  473.  
  474. /* Voreinstellungen fürs Fenster (Screen vorbereiten)        */
  475. int SetupScreen( void )
  476. {
  477.     /* Schaun, ob wir nen PubScreen verwenden können        */
  478.     if ( ! ( Scr = LockPubScreen( PubScreenName )))
  479.         return( 1L );
  480.  
  481.     /* Schrifthöhe und -breit bestimmen                            */
  482.     ComputeFont( 0, 0 );
  483.  
  484.     /* Visualinfo setzen (Zeiger, wo es sichtbar wird)        */
  485.     if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  486.         return( 2L );
  487.  
  488.     /* wenn alles glatt gegangen ist, 0 zurückgeben            */
  489.     return( 0L );
  490. }
  491.  
  492. /* Sreen wieder zurücksetzen                                        */
  493. void CloseDownScreen( void )
  494. {
  495.     /* falls wir ein VisualInfo gekriegt haben, freigeben    */
  496.     if ( VisualInfo ) {
  497.         FreeVisualInfo( VisualInfo );
  498.         VisualInfo = NULL;
  499.     }
  500.  
  501.     /* PubScreen wieder zurücksetzen                                */
  502.     if ( Scr        ) {
  503.         UnlockPubScreen( NULL, Scr );
  504.         Scr = NULL;
  505.     }
  506. }
  507.  
  508. /* Texte und BevelBoxes aufs Fenster zeichnen                */
  509. void BestellenRender( void )
  510. {
  511.     struct IntuiText    it;
  512.     UWORD            cnt;
  513.  
  514.     /* Font berechnen                                                    */
  515.     ComputeFont( BestellenWidth, BestellenHeight );
  516.  
  517.     /* Absenderumrandende BevelBox zeichnen                    */
  518.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 10 ),
  519.                     OffY + ComputeY( 24 ),
  520.                     ComputeX( 227 ),
  521.                     ComputeY( 94 ),
  522.                     GT_VisualInfo, VisualInfo, GTBB_Recessed, TRUE, TAG_DONE );
  523.     /* Empfängerumrandende BevelBox zeichnen                    */
  524.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 10 ),
  525.                     OffY + ComputeY( 143 ),
  526.                     ComputeX( 227 ),
  527.                     ComputeY( 72 ),
  528.                     GT_VisualInfo, VisualInfo, GTBB_Recessed, TRUE, TAG_DONE );
  529.         /* Allumrandende BevelBox zeichnen                            */
  530.     DrawBevelBox( BestellenWnd->RPort, OffX + ComputeX( 2 ),
  531.                     OffY + ComputeY( 3 ),
  532.                     ComputeX( 453 ),
  533.                     ComputeY( 218 ),
  534.                     GT_VisualInfo, VisualInfo, TAG_DONE );
  535.  
  536.     /* Texte ausgeben                                                    */
  537.     for ( cnt = 0; cnt < Bestellen_TNUM; cnt++ ) {
  538.         /* Text aufbereiten                                            */
  539.         CopyMem(( char * )&BestellenIText[ cnt ], ( char * )&it, (long)sizeof( struct IntuiText ));
  540.         /* Font festlegen                                                */
  541.         it.ITextFont = Font;
  542.         /* horizontale Position festlegen                        */
  543.         it.LeftEdge  = OffX + ComputeX( it.LeftEdge ) - ( IntuiTextLength( &it ) >> 1 );
  544.         /* vertikale Position festlegen                            */
  545.         it.TopEdge   = OffY + ComputeY( it.TopEdge ) - ( Font->ta_YSize >> 1 );
  546.         /* Text ausgeben                                                */
  547.         PrintIText( BestellenWnd->RPort, &it, 0, 0 );
  548.     }
  549. }
  550.  
  551. /* Fenster öffenen                                                    */
  552. int OpenBestellenWindow( void )
  553. {
  554.     /* NewGadget Struktur konkret anlegen                        */
  555.     struct NewGadget    ng;
  556.     /* Gadget Struktur konkret anlegen                            */
  557.     struct Gadget    *g;
  558.     /* Zwei laufvariable definieren                                */
  559.     UWORD        lc, tc;
  560.     /* Für die horizontale und vertikale Größe                */
  561.     UWORD        ww, wh;
  562.  
  563.     /* Fontröße berechnen                                            */
  564.     ComputeFont( BestellenWidth, BestellenHeight );
  565.  
  566.     /* absolute Fenstergröße horizontal berechnen            */
  567.     ww = ComputeX( BestellenWidth );
  568.     /* absolute Fenstergröße vertikal berechnen                */
  569.     wh = ComputeY( BestellenHeight );
  570.  
  571.     /* Font öffnen, wenns fehlschlägt, Fehler zurückgeben    */
  572.     if ( ! ( BestellenFont = OpenDiskFont( Font )))
  573.         return( 5L );
  574.  
  575.     /* Liste fürs erstellen der Gadgets erstellen            */
  576.     if ( ! ( g = CreateContext( &BestellenGList )))
  577.         return( 1L );
  578.  
  579.     /* wiederhole, bis alle Gadgets erstellt sind            */
  580.     for( lc = 0, tc = 0; lc < Bestellen_CNT; lc++ )
  581.     {
  582.         /* Speicherbereich in dem die Liste definiert ist    */
  583.         /* an die Liste ranhängen                                    */
  584.         CopyMem((char * )&BestellenNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  585.  
  586.         /* VisualInfo an die Gadgetstructur übergeben        */
  587.         ng.ng_VisualInfo = VisualInfo;
  588.         /* Font fürs Gadget festlegen                                */
  589.         ng.ng_TextAttr   = Font;
  590.         /* horizontale Position errechnen                        */
  591.         ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  592.         /* vertikale Position errechnen                            */
  593.         ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  594.         /* Breite berechnen                                            */
  595.         ng.ng_Width      = ComputeX( ng.ng_Width );
  596.         /* und die Höhe berechnen                                    */
  597.         ng.ng_Height     = ComputeY( ng.ng_Height);
  598.  
  599.         /* Das ganze können wir jetzt mal herstellen            */
  600.         BestellenGadgets[ lc ] = g = CreateGadgetA((ULONG)BestellenGTypes[ lc ], g, &ng, ( struct TagItem * )&BestellenGTags[ tc ] );
  601.  
  602.         /* tc erhöhen                                                    */
  603.         while( BestellenGTags[ tc ] ) tc += 2;
  604.         tc++;
  605.  
  606.         /* Bei einem Fehler, brechen wir die Sache ab        */
  607.         if ( NOT g )
  608.             return( 2L );
  609.     }
  610.  
  611.     /* Menus noch vorbereiten                                        */
  612.     /* Unter OS 3.x                                                     */
  613.     if( NOS )
  614.     {
  615.         /* Verwenden wir die Prefs-Menü-Farben                    */
  616.         dri = GetScreenDrawInfo( Scr );
  617.         if ( ! ( BestellenMenus = CreateMenus( BestellenNewMenu, GTMN_FrontPen, dri->dri_Pens[BARDETAILPEN], GTMN_NewLookMenus, TRUE, TAG_DONE )))
  618.             return( 3L );
  619.     }
  620.     /* unter OS 2.x                                                    */
  621.     else
  622.     {
  623.         /* können wir standardmäßig die Farbe 0 verwenden    */
  624.         if ( ! ( BestellenMenus = CreateMenus( BestellenNewMenu, GTMN_FrontPen, 0L, TAG_DONE )))
  625.             return( 3L );
  626.     }
  627.  
  628.     /* und herstellen                                                    */
  629.     LayoutMenus( BestellenMenus, VisualInfo, TAG_DONE );
  630.  
  631.     /* Abstand von Oben ermitteln                                    */
  632.     if (WinX > 0)
  633.     {
  634.         if ((WinX + ww + OffX + Scr->WBorRight) > Scr->Width)
  635.         {
  636.             WinX = (Scr->Width - (ww + OffX + Scr->WBorRight));
  637.         }
  638.     }
  639.     else
  640.     {
  641.         WinX = (Scr->Width  - (ww + OffX + Scr->WBorRight )) / (UWORD)2;
  642.     }
  643.  
  644.     /* Abstand von Oben ermitteln                                    */
  645.     if (WinY > 0)
  646.     {
  647.         if ((WinY + wh + OffY + Scr->WBorBottom) > Scr->Height)
  648.         {
  649.             WinY = (Scr->Height - (wh + OffY + Scr->WBorBottom));
  650.         }
  651.     }
  652.     else
  653.     {
  654.         WinY = (Scr->Height - (wh + OffY + Scr->WBorBottom)) / (UWORD)2;
  655.     }
  656.  
  657.     /* Schon können wir es wagen, das Fenster zu öffnen    */
  658.     if ( ! ( BestellenWnd = OpenWindowTags( NULL,
  659.                 WA_Left,                WinX,
  660.                 WA_Top,                WinY,
  661.                 WA_Width,            ww + OffX + Scr->WBorRight,
  662.                 WA_Height,            wh + OffY + Scr->WBorBottom,
  663.                 WA_IDCMP,            IDCMP_CLOSEWINDOW|IDCMP_GADGETUP|IDCMP_GADGETDOWN|IDCMP_MENUHELP|IDCMP_MENUPICK|IDCMP_VANILLAKEY|IDCMP_GADGETHELP|IDCMP_RAWKEY,
  664.                 WA_Flags,            WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_NEWLOOKMENUS,
  665.                 WA_Gadgets,            BestellenGList,
  666.                 WA_Title,            WinTitel,
  667.                 WA_ScreenTitle,    (UBYTE *)AppStrings[MSG_ScreenName],
  668.                 WA_PubScreen,        Scr,
  669.                 WA_MenuHelp,        TRUE,
  670.                 WA_NewLookMenus,    TRUE,
  671.                 TAG_DONE )))
  672.     return( 4L );
  673.  
  674.     /* Signalbit des Fensters für abfrage merken                */
  675.     wndsigflag = 1L << BestellenWnd->UserPort->mp_SigBit;
  676.     /* Hängen wir das Menu noch dran                                */
  677.     SetMenuStrip( BestellenWnd, BestellenMenus );
  678.     /* Kurzer refresh, sonst schmiert uns das Ding ab        */
  679.     GT_RefreshWindow( BestellenWnd, NULL );
  680.  
  681.     /* Die Bevel Boxen und ein wenig Text draufzeichnen    */
  682.     BestellenRender();
  683.  
  684.     /* Fenster ist offen!                                            */
  685.     CX_Popup = TRUE;
  686.  
  687.     /* Gadgets sperren oder öffnen, wenn nötigt                */
  688.     checkonoff();
  689.  
  690.     /* HelpControl unter 3.x starten, wegen der Hilfe        */
  691.     if( NOS )
  692.     {
  693.         HelpControl(BestellenWnd, HC_GADGETHELP);
  694.     }
  695.  
  696.     /* Alles Klar Boss                                                */
  697.     return( 0L );
  698. }
  699.  
  700. /* Fenster wieder dicht machen                                    */
  701. void CloseBestellenWindow( void )
  702. {
  703.     /* Hat das mit den Menus hingehaun?                            */
  704.     if ( BestellenMenus      )
  705.     {
  706.         /* Vom Fenster abmontieren                                    */
  707.         ClearMenuStrip( BestellenWnd );
  708.         /* und freigeben                                                */
  709.         FreeMenus( BestellenMenus );
  710.         /* Vermerken, daß alles gelöscht wurde                    */
  711.         BestellenMenus = NULL;
  712.     }
  713.  
  714.     /* Konnte das Fenster geöffnet werden                        */
  715.     if ( BestellenWnd        )
  716.     {
  717.         /* Position des Fensters festhalten                        */
  718.         if( !(WinX = BestellenWnd->LeftEdge))
  719.             WinX = 1;
  720.         if( !(WinY = BestellenWnd->TopEdge))
  721.             WinY = 1;
  722.         if ( currentvdb );
  723.             ListPos = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  724.         /* dann machen wir es wieder zu (wird kalt drausen)*/
  725.         CloseWindow( BestellenWnd );
  726.         /* und vermerken das mal eben                                */
  727.         BestellenWnd = NULL;
  728.         CX_Popup = FALSE;
  729.     }
  730.  
  731.     /* Konnten die Gadgets erzeugt werden                        */
  732.     if ( BestellenGList      )
  733.     {
  734.         /* Befreien wir sie wieder                                    */
  735.         FreeGadgets( BestellenGList );
  736.         /* und vermerken auch dieses                                */
  737.         BestellenGList = NULL;
  738.     }
  739.  
  740.     /* Na, können Sie es sich denken? Konnte der Font...    */
  741.     if ( BestellenFont )
  742.     {
  743.         /* Dann schließen wir auch diesen                        */
  744.         CloseFont( BestellenFont );
  745.         /* und schreibens uns hinter die Löffel                */
  746.         BestellenFont = NULL;
  747.     }
  748. }
  749.  
  750. /*    Gadtools-Gadget einschalten                                     */
  751. void gt_OnGadget( struct Gadget     *gad,
  752.                   struct Window        *w )
  753. {
  754.     GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, FALSE, TAG_DONE );
  755. }
  756.  
  757. /*    ...und wieder aus...                                                */
  758. void gt_OffGadget( struct Gadget     *gad,
  759.                    struct Window    *w )
  760. {
  761.     GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, TRUE, TAG_DONE );
  762. }
  763.  
  764. /*  String-Gadgets mit nem string füllen                        */
  765. void gt_SetString( struct Gadget    *gad,
  766.                    struct Window    *w,
  767.                    char                *string )
  768. {
  769.     GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  770. }
  771.  
  772. /* und nachschaun, welcher drinnen steckt                        */
  773. char * gt_GetString( struct Gadget    *gad )
  774. {
  775.     struct StringInfo *si = gad->SpecialInfo;
  776.  
  777.     if( si )
  778.         return( ( char * ) si->Buffer );
  779.     else
  780.         return( NULL );
  781. }
  782.  
  783. /* Integer-Gadgets mit ner Zahl füllen                            */
  784. void gt_SetInteger( struct Gadget    *gad,
  785.                     struct Window    *w,
  786.                     LONG            value )
  787. {
  788.     GT_SetGadgetAttrs( gad, w, NULL, GTIN_Number, value, TAG_DONE );
  789. }
  790.  
  791. /* und nachschaun, welche drinnen steckt                        */
  792. LONG gt_GetInteger( struct Gadget    *gad )
  793. {
  794.     struct StringInfo *si = gad->SpecialInfo;
  795.  
  796.     if( si )
  797.         return( si->LongInt );
  798.     else
  799.         return( NULL );
  800.  
  801. }
  802.  
  803. /* Listenverwaltung für Listview-Gadgets                        */
  804.  
  805. /* Liste anhängen
  806.  * "list" kann ~0 (-1) sein, dann ist kein Listenzugriff möglich
  807.  */
  808.  
  809. void gt_AttachList(    struct Gadget     *lv,
  810.                     struct Window     *w,
  811.                      struct List     *list )
  812. {
  813.     GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  814. }
  815.  
  816. /* Aktuellen Eintrag setzen
  817.  * incl. Automatischem Positionieren, wenn der Eintrag außerhalb
  818.  * des sichtbaren Bereichs ist (maximal 12 Einträge darstellbar)
  819.  */
  820. void gt_SetLV( struct Gadget    *gad,
  821.                struct Window    *w,
  822.                ULONG            value)
  823. {
  824.     ULONG i;
  825.     /* sollte ein Eintrag ausgewählt sein,                        */
  826.     if( value >= 0 )
  827.     {
  828.         /* schau nach, welcher ganz oben in der Liste steht*/
  829.         GT_GetGadgetAttrs( gad, w, NULL, GTLV_Top, &i, TAG_DONE );
  830.         /* ist er größer als der gewählte,                        */
  831.         if(value < i)
  832.         {
  833.             /* dann rutschen wir ein wenig hoch in der Liste*/
  834.             i = value;
  835.             GT_SetGadgetAttrs( gad, w, NULL, GTLV_Top, i, TAG_DONE );
  836.         }
  837.         /* sollte er zu hoch sein,                                    */
  838.         else if((value - i) > (LVSicht - 2))
  839.         {
  840.             /* müssen wir die Liste ein wenig runterblätten    */
  841.             i = value - (LVSicht - 1);
  842.             GT_SetGadgetAttrs( gad, w, NULL, GTLV_Top, i, TAG_DONE );
  843.         }
  844.     }
  845.     /* Nun können der Eintrag ausgewählt werden.                */
  846.     GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  847. }
  848.  
  849. /* x-ten Eintrag aus einer Exec-Liste holen */
  850. struct Node * gt_GetListEntry( struct List *l,
  851.                                int num )
  852. {
  853.     int count = 0;
  854.     struct Node *n = l->lh_Head;
  855.  
  856.     while( n->ln_Succ )
  857.     {
  858.         if( num==count ) return( n );
  859.         n = n->ln_Succ;
  860.         count++;
  861.     }
  862.     return( NULL );
  863. }
  864.  
  865. /* Nummer einer Node aus einer Liste feststellen
  866.  * -1 falls nicht in Liste
  867.  */
  868. int gt_GetListEntryNum(    struct List *l,
  869.                         struct Node *n )
  870. {
  871.     int count = 0;
  872.     struct Node *r = l->lh_Head;
  873.  
  874.     while( r->ln_Succ )
  875.     {
  876.         if( r==n ) return( count );
  877.         r = r->ln_Succ;
  878.         count++;
  879.     }
  880.     return( -1 );
  881. }
  882.  
  883. /* Anzahl Einträge einer Liste zählen                            */
  884. int gt_GetListNumEntries( struct List *l )
  885. {
  886.     int count = 0;
  887.     struct Node *n = l->lh_Head;
  888.  
  889.     while( n->ln_Succ )
  890.     {
  891.         n = n->ln_Succ;
  892.         count++;
  893.     }
  894.  
  895.     return( count );
  896. }
  897.  
  898. /* Gadgets ein oder Ausschalten                                    */
  899. void checkonoff( void )
  900. {
  901.     /* Wenn ein Eintrag aus der Liste angewählt ist,        */
  902.     if( currentvdb ) 
  903.     {
  904.         /* schalte die Gadgets ein                                    */
  905.         gt_OnGadget( BestellenGadgets[ GD_DiskLoeschen ], BestellenWnd );
  906.         gt_OnGadget( BestellenGadgets[ GD_DiskAender ], BestellenWnd );
  907.     }
  908.     else
  909.     {
  910.         /* ansonsten brauchen wir sie gerade mal nicht        */
  911.         gt_OffGadget( BestellenGadgets[ GD_DiskLoeschen ], BestellenWnd );
  912.         gt_OffGadget( BestellenGadgets[ GD_DiskAender ], BestellenWnd );
  913.     }
  914. }
  915.  
  916. /* Neuer Eintrag in die Liste    aufnehmen                        */
  917. void newvdb( void )
  918. {
  919.     /* Neue Sturktur anlegen                                        */
  920.     struct VDBnode *new;
  921.  
  922.     /* Speicher dafür reservieren                                    */
  923.     new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  924.  
  925.     /* Nur weitermachen, wenn es geklappt hat                    */
  926.     if( !new )
  927.         return;
  928.  
  929.     /* den neuen Satz zum aktuellen machen                        */
  930.     currentvdb = new;
  931.     new->n.ln_Name = new->d.Name;
  932.  
  933.     /* der neue Satz lautet vorrübergehend "- ??? -"        */
  934.     strcpy( new->d.Name, "- ??? -" );
  935.  
  936.     /* Liste abhängen                                                    */
  937.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, (struct List *) ~0 );
  938.  
  939.     /* Priorität = ASCII-Wert des ersten Buchstaben            */
  940.     new->n.ln_Pri     = - new->d.Name[0];
  941.  
  942.     /* an die Liste nach Prioritäten sortiert anhängen        */    
  943.     Enqueue( &vdblist, (struct Node *) new );
  944.  
  945.     /* geänderte Liste wieder anhängen                            */
  946.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  947.  
  948.     /* im ListviewGadget aktivieren                                */
  949.     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) new));
  950.  
  951.     /* Wenn die Gadgets abgeschaltet sind, einschalten        */
  952.     checkonoff();
  953.  
  954.     /* den "- ??? -" ins String Gadget schreiben und zur    */
  955.     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  956.  
  957.     /* Änderung aktivieren, oder wollen Sie eine Test Disk*/
  958.     ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  959. }
  960.  
  961. /* Libraries öffnen                                                    */
  962. BOOL OpenAll()
  963. {
  964.     /* Kick 2.0 muß vorhanden sein                                */
  965.     /* Library-Versionen mind. 37                                    */
  966.  
  967.     /* Intuition.library in der 37er Version öffnen (3.x)    */
  968.     IntuitionBase = (struct IntuitionBase *)
  969.         OpenLibrary("intuition.library",37L);
  970.  
  971.     /* Graphics.library öffnen                                        */
  972.     GfxBase = (struct GfxBase *)
  973.         OpenLibrary("graphics.library",37L);
  974.  
  975.     /* GadTools.library öffnen                                        */
  976.    GadToolsBase = (struct Library *)
  977.         OpenLibrary("gadtools.library",37L);
  978.  
  979.     /* Wenn das geklappt hat                                        */
  980.     if( GadToolsBase )
  981.     {
  982.         /* OS 3.0 (V39) oder höher vorhanden?                    */
  983.         if( (GadToolsBase->lib_Version) > 38U )
  984.         {
  985.             NOS = TRUE;
  986.             LVSicht = 12;
  987.         }
  988.         else
  989.         {
  990.             NOS = FALSE;
  991.             LVSicht = 11;
  992.         }
  993.     }
  994.  
  995.     /* Asl.library öffnen (nicht zwindend notwendig)        */
  996.     AslBase       =
  997.         OpenLibrary("asl.library", 37L);
  998.  
  999.     /* AmigaGuide.library (nicht zwingend notwendig)        */
  1000.     AmigaGuideBase =
  1001.         OpenLibrary("amigaguide.library", 0L);
  1002.  
  1003.     /* Locale.library (nicht zwingend notwendig)                */
  1004.     LocaleBase = (struct LocaleBase *)
  1005.         OpenLibrary("locale.library", 38L);
  1006.  
  1007.     /* Icon.library (nicht zwingend notwendig)                */
  1008.     IconBase = (struct IconBase *)
  1009.         OpenLibrary("icon.library", 37L);
  1010.  
  1011.     /* Commodities.library öffnen                                    */
  1012.     CxBase = (struct CxBase *)
  1013.         OpenLibrary("commodities.library", 37L);
  1014.  
  1015.     /* Hat es nicht geklappt, Fehler zurückgeben                */
  1016.     if(! CxBase            ||
  1017.         ! GadToolsBase    ||
  1018.         ! GfxBase        ||
  1019.         ! IntuitionBase)
  1020.         return FALSE;
  1021.     return TRUE;
  1022. }
  1023.  
  1024. /* Libraries schließen                                                */
  1025. void CloseAll()
  1026. {
  1027.     /* locale.library schließen, wenn sie offen ist            */
  1028.     if( CxBase )
  1029.         CloseLibrary( ( struct Library *)CxBase );
  1030.     /* Icon.library schließen, wenn sie offen ist            */
  1031.     if( IconBase )
  1032.         CloseLibrary( ( struct Library *)IconBase );
  1033.     /* locale.library schließen, wenn sie offen ist            */
  1034.     if( LocaleBase )
  1035.         CloseLibrary( ( struct Library *)LocaleBase );
  1036.     /* AmigaGuide.library schließen, wenn sie offen ist    */
  1037.     if( AmigaGuideBase )
  1038.         CloseLibrary( ( struct Library *)AmigaGuideBase );
  1039.     /* Asl.library schließen, wenn sie offen ist                */
  1040.     if( AslBase )
  1041.         CloseLibrary( ( struct Library *)AslBase );
  1042.     /* GadTools.library schließen, wenn sie offen ist        */
  1043.     if( GadToolsBase )
  1044.         CloseLibrary( ( struct Library *)GadToolsBase );
  1045.     /* Graphics.library schließen, wenn sie offen ist        */
  1046.     if( GfxBase )
  1047.         CloseLibrary( ( struct Library *)GfxBase );
  1048.     /* Intuition.library schließen, wenn sie offen ist        */
  1049.     if( IntuitionBase )
  1050.         CloseLibrary( ( struct Library *)IntuitionBase );
  1051.     return;
  1052. }
  1053.  
  1054. /* Unterprogramm zum Einlesen der Einstellungen                */
  1055. void EinstLesen()
  1056. {
  1057.     /* Datei öffnen                                                    */
  1058.     BPTR is;
  1059.     is = Open(Einst_File,MODE_OLDFILE);
  1060.     /* Wenn das geklappt hat,                                        */
  1061.     if(is)
  1062.     {
  1063.         /* lies die Einstellungen                                    */
  1064.         Read(is, &P1, sizeof( P1 ));
  1065.         /* Schließ die Datei wieder                                */
  1066.         Close(is);
  1067.     }
  1068. }
  1069.  
  1070. /* Unterprogramm zum Schreiben der Einstellungen            */
  1071. void EinstSchreiben()
  1072. {
  1073.     /* Datei öffnen                                                    */
  1074.     BPTR os;
  1075.     os = Open(Einst_File, MODE_NEWFILE);
  1076.     /* Wenn das geklappt hat,                                        */
  1077.     if(os)
  1078.     {
  1079.         /* schreib die Einstellungen                                */
  1080.         Write(os, &P1, sizeof( P1 ));
  1081.         /* Schließ die Datei wieder                                */
  1082.         Close(os);
  1083.     }
  1084. }
  1085.  
  1086. /* Sortiert einen neuen Eintrag in die Liste ein.            */
  1087. long NeuerEintrag(char *Eintrag)
  1088. {
  1089.     long Entries;
  1090.     long i;
  1091.     struct VDBnode *n;
  1092.     struct VDBnode *m;
  1093.  
  1094.     /* Anzahl der bereits existierenden Eintragungen        */
  1095.     Entries = gt_GetListNumEntries( &vdblist );
  1096.  
  1097.     /* Schleife vom Ende bis zum Anfang der Liste            */
  1098.     for( i = Entries-1; i >= 0; i--) 
  1099.     {
  1100.         /* Eintrag aus der Liste Holen                            */
  1101.         m = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1102.  
  1103.         /* Der Eintrag ist bereits vorhanden -> ignorieren    */
  1104.         if(strcmp(m->d.Name, Eintrag)==0)
  1105.             return i;
  1106.  
  1107.         /* Die richtige Stelle wurde gefunden -> Einfügen    */
  1108.         if(strcmp(m->d.Name, Eintrag)<0)
  1109.         {
  1110.             /* Speicher alokieren                                    */
  1111.             n = AllocVec( sizeof( *n ), MEMF_CLEAR );
  1112.             if( n )
  1113.             {
  1114.                 /* die ganze Sache aufbereiten                    */
  1115.                 strcpy(n->d.Name, Eintrag);
  1116.                 n->n.ln_Name = n->d.Name;
  1117.                 n->n.ln_Pri  = - n->d.Name[0];
  1118.                 /* und dahinter anhängen                            */
  1119.                 Insert( &vdblist, (struct Node *) n, (struct Node *) m );
  1120.             }
  1121.             /* Eingefügte Pos. = i+1, das geben wir zurück    */
  1122.             return ++i;
  1123.         }
  1124.     }
  1125.  
  1126.     /* Kein kleinerer Eintrag gefunden?                            */
  1127.     n = AllocVec( sizeof( *n ), MEMF_CLEAR );
  1128.     if( n )
  1129.     {
  1130.         /* die ganze Sache aufbereiten                            */
  1131.         strcpy(n->d.Name, Eintrag);
  1132.         n->n.ln_Name = n->d.Name;
  1133.         n->n.ln_Pri  = - n->d.Name[0];
  1134.         /* dann setz ihn vorne dran                                */
  1135.         AddHead( &vdblist, (struct Node *) n );
  1136.     }
  1137.     /* Eingefügte Position = 0, das geben wir zurück        */
  1138.     return 0;
  1139. }
  1140.  
  1141. /* Einen Eintrag aus der Liste entfernen                        */
  1142. void EintragLoeschen()
  1143. {
  1144.     long i;
  1145.     /* Wenn ein Eintrag ausgewählt ist                            */
  1146.     if(currentvdb)
  1147.     {
  1148.         /* Die Nummer des Eintrags bestimmen                    */
  1149.         i = gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb);
  1150.         /* Ist diese > 0, wird der nächste Eintrag eins kl.*/
  1151.         if(i > 0)
  1152.             i--;
  1153.         /* Ansonsten 0 (der Beginn der Liste)                    */
  1154.         else
  1155.             i = 0;
  1156.         /* Liste abhängen                                                */
  1157.         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  1158.         /* Den Eintrag entfernen                                    */
  1159.         Remove( (struct Node *) currentvdb );
  1160.         /* ebenso den passenden Vektor                            */
  1161.         FreeVec( currentvdb );
  1162.         /* Liste wieder anhängen                                    */
  1163.         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  1164.         /* Neuer aktueller Eintrag (wenn Liste nicht leer)    */
  1165.         if (IsListEmpty( &vdblist ))
  1166.         {
  1167.             currentvdb = NULL;
  1168.             /* Feld darunter löschen                                */
  1169.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  1170.         }
  1171.         else
  1172.         {
  1173.             currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1174.             /* Neuen aktuellen Eintag in der Liste auswählen*/
  1175.             gt_SetLV( BestellenGadgets[ GD_Diskliste ], BestellenWnd, i );
  1176.             /* und im Feld darunter anzeigen                        */
  1177.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1178.         }
  1179.         /* Wenn keiner mehr drinnen ist, Gad. abschalten    */
  1180.         checkonoff();
  1181.     }
  1182. }
  1183.  
  1184. /* Unterprogramm zum Einlesen der Time-Diskettendaten        */
  1185. void DatenLesen()
  1186. {
  1187.     FILE *is;
  1188.     char lespuf[15];
  1189.  
  1190.     /* Liste initialisieren                                            */
  1191.     NewList( &vdblist );
  1192.     /* Bei Beginn noch keinen aktuellen Eintrag                */
  1193.     currentvdb = NULL;
  1194.  
  1195.     /* Datei öffnen zum lesen (read -> "r")                    */
  1196.     is = fopen(T_Remember, "r");
  1197.     if(is)
  1198.     {
  1199.         /* Solange was in der Datei steckt, lesen                */
  1200.         while(fgets(lespuf, 14, is))
  1201.         {
  1202.             /* und an die Liste dranhängen                        */
  1203.             NeuerEintrag(lespuf);
  1204.         }
  1205.         /* Hinterher die Datei wieder dicht machen            */
  1206.         fclose(is);
  1207.     }
  1208. }
  1209.  
  1210. /* Unterprogramm zum Schreiben der Time-Diskettendaten    */
  1211. void DatenSchreiben( struct List *l )
  1212. {
  1213.     int i = 0;
  1214.     struct Node *n = l->lh_Head;
  1215.     struct VDBnode *a;
  1216.     FILE *os;
  1217.  
  1218.     /* Datei zum Schreiben öffnen (write -> "w")                */
  1219.     os = fopen(T_Remember, "w");
  1220.     /* Hat das öffnen hingehauen                                    */
  1221.     if(os)
  1222.     {
  1223.         /* Die Liste von Anfang bis Schluß durchackern    */
  1224.         while( n->ln_Succ )
  1225.         {
  1226.             n = n->ln_Succ;
  1227.             a = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1228.             i++;
  1229.             /* Disknamen reinschreiben                            */
  1230.             fputs( a->d.Name, os );
  1231.             fputc( '\n', os);
  1232.         }
  1233.         /* Wenns öffnen geklappt hat, dann Datei schließ*/
  1234.         fclose(os);
  1235.     }
  1236. }
  1237.  
  1238. /* Die Bestellung auf eine Postkarte Drucken                    */
  1239. void Drucken( struct List *l )
  1240. {
  1241.     /* Einen Schreibpuffer für die aufbereiten der Zeilen    */
  1242.     char Schreibpuf[1000];
  1243.     char Zeilenpuf[60];
  1244.     char i;
  1245.     struct VDBnode *a;
  1246.     struct Node *n = l->lh_Head;
  1247.  
  1248.     FILE *os;
  1249.     /* Requester vorbereiten                                        */
  1250.     es.es_StructSize    = sizeof(struct EasyStruct);
  1251.     es.es_Flags            = 0;
  1252.  
  1253.     /* Datei zum drucken oder speichern öffnen                */
  1254.     os = fopen("PRT:", "w");
  1255.     /* Hats geklappt?                                                    */
  1256.     if(os)
  1257.     {
  1258.         /* Requester zur Aufford. die Postkarte einzul.        */
  1259.         es.es_Title            = AppStrings[MSG_DruReqTitel];
  1260.         es.es_TextFormat    = AppStrings[MSG_DruReqText1];
  1261.         es.es_GadgetFormat= AppStrings[MSG_DruReqWahl];
  1262.  
  1263.         /* Wenn er mit Drucken bestätigt wurde    i > 0            */
  1264.         i = EasyRequest(BestellenWnd, &es, NULL);
  1265.  
  1266.         /* Falls i > 0 drucken/speichern                            */
  1267.         if(i)
  1268.         {
  1269.             strcpy(Schreibpuf, '\0');
  1270.             /* Die Leerzeilen zu Beginn einfügen                */
  1271.             for( i = 0; i < P1.Abstand; i++)
  1272.             {
  1273.                 strcat(Schreibpuf, "\n")
  1274.             }
  1275.             /* Die Zeile mit dem Absendernamen drucken und    */
  1276.             strcat(Schreibpuf, "  ");
  1277.             strcat(Schreibpuf, P1.AName);
  1278.             strcat(Schreibpuf, "\n\n");
  1279.             /* Die Zeile mit der Kundennummer drucken und    */
  1280.             strcat(Schreibpuf, AppStrings[MSG_DruText0]);
  1281.             strcat(Schreibpuf, P1.KundNr);
  1282.             strcat(Schreibpuf, "\n\n");
  1283.             /* Die Zeile mit der Absenderstraße drucken und    */
  1284.             strcat(Schreibpuf, "  ");
  1285.             strcat(Schreibpuf, P1.AStrasse);
  1286.             strcat(Schreibpuf, "\n\n");
  1287.             /* Die Zeile mit dem Absenderort drucken und        */
  1288.             strcat(Schreibpuf, "  ");
  1289.             strcat(Schreibpuf, P1.AOrt);
  1290.             strcat(Schreibpuf, "\n\n");
  1291.             /* Die Zeile mit dem Empfängernamen drucken und    */
  1292.             strcat(Schreibpuf, "                             ");
  1293.             strcat(Schreibpuf, P1.EName);
  1294.             strcat(Schreibpuf, "\n\n\n\n");
  1295.             /* Die Zeile mit der Empf.straße drucken und        */
  1296.             strcat(Schreibpuf, "                             ");
  1297.             strcat(Schreibpuf, P1.EStrasse);
  1298.             strcat(Schreibpuf, "\n\n\n\n");
  1299.             /* zuguterletzt den Empfängerort drucken und        */
  1300.             strcat(Schreibpuf, "                             ");
  1301.             strcat(Schreibpuf, P1.EOrt);
  1302.             strcat(Schreibpuf, "\f");
  1303.             if (fputs( Schreibpuf, os ) == DOSTRUE)
  1304.             {
  1305.                 /* Schreiben klappte nicht                            */
  1306.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1307.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText1];
  1308.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1309.  
  1310.                 EasyRequest(BestellenWnd, &es, NULL);
  1311.                 os = NULL;
  1312.             }
  1313.         }
  1314.         /* und schließe die Datei wieder                            */
  1315.         fclose(os);
  1316.     }
  1317.  
  1318.     /* Datei zum drucken oder speichern öffnen                */
  1319.     os = fopen("PRT:", "w");
  1320.     /* Hats geklappt?                                                    */
  1321.     if(os)
  1322.     {
  1323.         /* Die Aufforderung, die Postkarte umzudrehen        */
  1324.         es.es_Title            = AppStrings[MSG_DruReqTitel];
  1325.         es.es_TextFormat    = AppStrings[MSG_DruReqText2];
  1326.         es.es_GadgetFormat= AppStrings[MSG_DruReqWahl];
  1327.  
  1328.         /* Wenn er mit Drucken bestätigt wurde                    */
  1329.         i = EasyRequest(BestellenWnd, &es, NULL);
  1330.  
  1331.         /* Wenn i > 0                                                    */
  1332.         if(i)
  1333.         {
  1334.             strcpy(Schreibpuf, '\0');
  1335.             /* Die Leerzeilen zu Beginn einfügen                */
  1336.             for( i = 0; i < P1.Abstand; i++)
  1337.             {
  1338.                 strcat(Schreibpuf, "\n")
  1339.             }
  1340.             /* Ein Text, der klar macht, was wir wollen        */
  1341.             strcat(Schreibpuf, AppStrings[MSG_DruText1]);
  1342.             /* Nachschaun, welche Zahlungsart aktuell ist    */
  1343.             switch( P1.Versart )
  1344.             {
  1345.                 /* Nachnahme,                                            */
  1346.                 case 0:
  1347.                     strcat(Schreibpuf, AppStrings[MSG_DruText2]);
  1348.                     break;
  1349.                 /* Vorkasse oder                                        */
  1350.                 case 1:
  1351.                     strcat(Schreibpuf, AppStrings[MSG_DruText3]);
  1352.                     break;
  1353.                 /* gegen Rechnung                                        */
  1354.                 default:
  1355.                     strcat(Schreibpuf, AppStrings[MSG_DruText4]);
  1356.                     break;
  1357.             }
  1358.             strcpy(Zeilenpuf, "  ");
  1359.             i = 0;
  1360.             /* Nun zu den Disketten selbst                        */
  1361.             while( n->ln_Succ )
  1362.             {
  1363.                 /* Zunächst holen wir mal die Diskbezeichn.,    */
  1364.                 n = n->ln_Succ;
  1365.                 a = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1366.                 i++;
  1367.                 /* schaun ob in der Zeile noch Platz ist,        */
  1368.                 if((strlen(a->d.Name) + strlen(Zeilenpuf)) > 52 )
  1369.                 {
  1370.                     /* wenn nicht, drucken wir die alte und    */
  1371.                     strcat( Schreibpuf, Zeilenpuf );
  1372.                     strcat( Schreibpuf, "\n");
  1373.                     /* beginnen eine neue                            */
  1374.                     strcpy(Zeilenpuf, "  ");
  1375.                 }
  1376.                 /* nun können wir getrost die Diskettenbez.    */
  1377.                 strcat(Zeilenpuf, a->d.Name);
  1378.                 /* gefolgt von einem Komma dranhängen            */
  1379.                 strcat(Zeilenpuf, ", ");
  1380.             }
  1381.             /* Da die letzte Zeile nicht gedruckt wurde,        */
  1382.             /* holen wir das nach und                                */
  1383.             strcat( Schreibpuf, Zeilenpuf );
  1384.             /* hängen eine Leerzeile dran.                        */
  1385.             strcat( Schreibpuf, "\n\n" );
  1386.             /* In der Hoffnung das es auch wirklich flott    */
  1387.             /* geht, danken wir dafür schon im Voraus,        */
  1388.             strcat(Schreibpuf, AppStrings[MSG_DruText5]);
  1389.             if (fputs( Schreibpuf, os ) == DOSTRUE)
  1390.             {
  1391.                 /* Schreiben klappte nicht                            */
  1392.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1393.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText1];
  1394.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1395.  
  1396.                 EasyRequest(BestellenWnd, &es, NULL);
  1397.             }
  1398.         }
  1399.         /* und schließen die Datei wieder                        */
  1400.         fclose(os);
  1401.     }
  1402.     /* Konnte die Datei jedoch nicht geöffnet werden,        */
  1403.     else
  1404.     {
  1405.         /* wird der Benuter per Requester Informiert            */
  1406.         es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  1407.         es.es_TextFormat    = AppStrings[MSG_ErrorReqText2];
  1408.         es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  1409.  
  1410.         EasyRequest(BestellenWnd, &es, NULL);
  1411.     }
  1412. }
  1413.  
  1414. /* Window mit den Voreingestellten Daten füllen                */
  1415. void Winfuell()
  1416. {
  1417.     /* Daten in das ListView Gadget einbauen                    */
  1418.     gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  1419.  
  1420.     /* Voreinstellungen einbauen                                    */
  1421.     GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1422.                                 GTMX_Active, P1.Versart,
  1423.                                 TAG_DONE);
  1424.     gt_SetString( BestellenGadgets[ GD_AName ], BestellenWnd, P1.AName );
  1425.     gt_SetString( BestellenGadgets[ GD_AStrasse ], BestellenWnd, P1.AStrasse);
  1426.     gt_SetString( BestellenGadgets[ GD_AOrt ], BestellenWnd, P1.AOrt);
  1427.     gt_SetString( BestellenGadgets[ GD_KundNr ], BestellenWnd, P1.KundNr );
  1428.  
  1429.     gt_SetString( BestellenGadgets[ GD_EName ], BestellenWnd, P1.EName );
  1430.     gt_SetString( BestellenGadgets[ GD_EStrasse ], BestellenWnd, P1.EStrasse);
  1431.     gt_SetString( BestellenGadgets[ GD_EOrt ], BestellenWnd, P1.EOrt);
  1432.  
  1433.     gt_SetInteger( BestellenGadgets[ GD_Abstand ], BestellenWnd, P1.Abstand);
  1434.     /* momentan nicht benötigte Gadgets sperren                */
  1435.     checkonoff();
  1436. }
  1437.  
  1438. /* Wenn jemand versucht ein Gadget zu erdrücken                */
  1439. BOOL Abfrage_Gadgetup( struct Gadget *gad, long code)
  1440. {
  1441.     char Merken[15];
  1442.     long i = 0;
  1443.     BOOL terminated = FALSE;    
  1444.  
  1445.     /* Wenn die Help-Taste der Grund fürs Beenden des G.    */
  1446.     if(code==95)
  1447.     {
  1448.         /* Rufen wir die Rawkey-Abfrage auf (HELP-Behandl.)*/
  1449.         Abfrage_Rawkey(gad,code,gad);
  1450.         /* mehr gibts nicht zu tun, also ab nach Hause        */
  1451.         return terminated;
  1452.     }
  1453.  
  1454.     /* mal sehen, auf welches G. der User es abgesehen hat*/
  1455.     switch( gad->GadgetID )
  1456.     {
  1457.         /* Jemand hat auf die Liste geklickt                    */
  1458.         case GD_Diskliste:
  1459.             /* dann gibts einen neuen aktuellen Eintrag        */
  1460.             currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, code );
  1461.             /* eventuell gesperrte Gadgets freigeben            */
  1462.             checkonoff();
  1463.             /* Stringgadget unter der Liste füllen                */
  1464.             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1465.             /* und aktivieren                                            */
  1466.             ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  1467.             break;
  1468.  
  1469.         /* Jemand will ne neue Disk eingeben                    */
  1470.         case GD_NeueDisk:
  1471.             /* Dafür haben wir ein Unerprogramm                    */
  1472.             newvdb();
  1473.             break;
  1474.  
  1475.         /* Jemand will ne Disk löschen                            */
  1476.         case GD_DiskLoeschen:
  1477.             /* auch dafür gibts ein Unterprogramm                */
  1478.             EintragLoeschen();
  1479.             break;
  1480.         /* Zahlart wurde geändert                                    */
  1481.         case GD_Zahlart:
  1482.             /* einfach nur merken, das reicht schon            */
  1483.             P1.Versart = code;
  1484.             break;
  1485.         /* Drucken                                                        */
  1486.         case GD_Drucken:
  1487.             /* Druckroutine aufrufen                                */
  1488.             Drucken(&vdblist);
  1489.             break;
  1490.         /* Abbrechen                                                    */
  1491.         case GD_Abbrechen:
  1492.             /* zurückgeben, daß der User keine Lust mer hat    */
  1493.             terminated = TRUE;
  1494.             break;
  1495.         /* Absendername                                                */
  1496.         case GD_AName:
  1497.             /* Einfach nur den neuen Namen merken                */
  1498.             strcpy( P1.AName, gt_GetString( BestellenGadgets[ GD_AName ]) );
  1499.             break;
  1500.         /* Absenderstraße                                                */
  1501.         case GD_AStrasse:
  1502.             /* Einfach nur die neue Straße merken                */
  1503.             strcpy( P1.AStrasse, gt_GetString( BestellenGadgets[ GD_AStrasse ]) );
  1504.             break;
  1505.         /* Absenderort                                                    */
  1506.         case GD_AOrt:
  1507.             /* Einfach nur den Ort merken                            */
  1508.             strcpy( P1.AOrt, gt_GetString( BestellenGadgets[ GD_AOrt ]) );
  1509.             break;
  1510.         /* Kundennummer                                                */
  1511.         case GD_KundNr:
  1512.             /* Einfach nur die Kundennummer merken                */
  1513.             strcpy( P1.KundNr, gt_GetString( BestellenGadgets[ GD_KundNr ]) );
  1514.             break;
  1515.         /* Empfängername                                                */
  1516.         case GD_EName:
  1517.             /* Einfach nur den Namen merken                        */
  1518.             strcpy( P1.EName, gt_GetString( BestellenGadgets[ GD_EName ]) );
  1519.             break;
  1520.         /* Empfängerstrasse                                            */
  1521.         case GD_EStrasse:
  1522.             /* Einfach nur die Strasse merken                    */
  1523.             strcpy( P1.EStrasse, gt_GetString( BestellenGadgets[ GD_EStrasse ]) );
  1524.             break;
  1525.         /* Empfängerort                                                */
  1526.         case GD_EOrt:
  1527.             /* Einfach nur den Ort merken                            */
  1528.             strcpy( P1.EOrt, gt_GetString( BestellenGadgets[ GD_EOrt ]) );
  1529.             break;
  1530.         /* Diskette neu angelegt oder alte ändern                */
  1531.         case GD_DiskAender:
  1532.             /* Den neuen Namen Merken                                */
  1533.             strcpy(Merken, gt_GetString( BestellenGadgets[ GD_DiskAender ]) );
  1534.             /* Wenn er sich nicht geändert hat, ignorieren    */
  1535.             if(strcmp(currentvdb->d.Name, Merken)==0) {}
  1536.             /* aber sonst                                                */
  1537.             else
  1538.             {
  1539.                 /* löschen wir den alten Eintrag                    */
  1540.                 EintragLoeschen();
  1541.                 /* Hängen die Liste ab                                */
  1542.                 gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, (struct List *) ~0 );
  1543.                 /* den neuen Eintrag an (Position merken)        */
  1544.                 i = NeuerEintrag( Merken );
  1545.                 /* hängen die Liste wieder dran                    */
  1546.                 gt_AttachList( BestellenGadgets[GD_Diskliste], BestellenWnd, &vdblist );
  1547.                 /* aktivieren den neuen Eintrag                    */
  1548.                 gt_SetLV( BestellenGadgets[GD_Diskliste], BestellenWnd, i );
  1549.                 /* merken ihn uns als aktuellen                    */
  1550.                 currentvdb = (struct VDBnode *) gt_GetListEntry( &vdblist, i );
  1551.                 /* schalten alle Gadgets an und                    */
  1552.                 checkonoff();
  1553.                 /* setzen den Namen ins Feld unter der Liste    */
  1554.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1555.             }
  1556.             break;
  1557.         /* Abstand fürs Drucken                                        */
  1558.         case GD_Abstand:
  1559.             /* Den Abstand einfach nur merken                    */
  1560.             P1.Abstand = gt_GetInteger( BestellenGadgets[ GD_Abstand ]);
  1561.             break;
  1562.         /* Dürfte nicht vorkommen, aber sicher ist sicher!    */
  1563.         default:
  1564.             break;
  1565.     }
  1566.     /* Und ab nach Hause, mit Rückgabewert, ob Schluß ist    */
  1567.     return(terminated);
  1568. }
  1569.  
  1570. /* Jemand hat das Menu benutzt                                    */
  1571. BOOL Abfrage_Menuepick( UWORD code)
  1572. {
  1573.     /* Struktur für den Requester, falls wir ihn brauchen    */
  1574.     char Verzeichnis[128];
  1575.     struct MenuItem *item;
  1576.     struct VDBnode *n;
  1577.     unsigned i;
  1578.     BOOL terminated = FALSE;
  1579.     item = ItemAddress(BestellenMenus, code);
  1580.  
  1581.     /* Nichts ausgewählt, dann zurück                            */
  1582.     if( !item )
  1583.         return terminated;
  1584.  
  1585.     /* mal schaun, was ausgewählt wurde                            */
  1586.     switch ( (int)MENU_USERDATA(item) )
  1587.     {
  1588.         /* Menupunkt Öffnen Adressen/Einstellungen            */
  1589.         case MENU_FOO_OPA:
  1590.             /* Wenn die Asl.library geöffnet werden konnte    */
  1591.             if( AslBase )
  1592.             {
  1593.                 /* Verzeichnis ermitteln                            */
  1594.                 i = (unsigned)((STRPTR)PathPart(Einst_File) - (STRPTR)Einst_File);
  1595.                 strncpy(Verzeichnis,Einst_File,i);
  1596.                 Verzeichnis[i] = 0;
  1597.                 /* Öffne einen einfachen Filerequester            */
  1598.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1599.                                                                                         ASL_Dir, Verzeichnis,
  1600.                                                                                         ASL_File, FilePart(Einst_File),
  1601.                                                                                         TAG_DONE))
  1602.                 {
  1603.                     if(AslRequest(fr,NULL))
  1604.                     {
  1605.                         /* Der neue Filerequester setzt sich    */
  1606.                         /* aus Drawer und File zusammen.            */
  1607.                         strcpy(Einst_File, fr->fr_Drawer);
  1608.                         strcat(Einst_File, fr->fr_File);
  1609.                         /* Gut, schreibe die Bestellung            */
  1610.                         EinstLesen();
  1611.                         /* Und auf den Bildschirm damit            */
  1612.                         Winfuell();
  1613.                     }
  1614.                     FreeAslRequest(fr);
  1615.                 }
  1616.             }
  1617.             break;
  1618.  
  1619.         /* Menupunkt Öffnen Diskettenliste                        */
  1620.         case MENU_FOO_OPB:
  1621.             /* Wenn die Asl.library geöffnet werden konnte    */
  1622.             if( AslBase )
  1623.             {
  1624.                 /* Verzeichnis ermitteln                            */
  1625.                 i = (unsigned)((STRPTR)PathPart(T_Remember) - (STRPTR)T_Remember);
  1626.                 strncpy(Verzeichnis,T_Remember,i);
  1627.                 Verzeichnis[i] = 0;
  1628.                 /* Öffne einen einfachen Filerequester            */
  1629.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1630.                                                                                         ASL_Dir, Verzeichnis,
  1631.                                                                                         ASL_File, FilePart(T_Remember),
  1632.                                                                                         TAG_DONE))
  1633.                 {
  1634.                     if(AslRequest(fr,NULL))
  1635.                     {
  1636.                         /* Der neue Filerequester setzt sich    */
  1637.                         /* aus Drawer und File zusammen.            */
  1638.                         strcpy(T_Remember, fr->fr_Drawer);
  1639.                         strcat(T_Remember, fr->fr_File);
  1640.                         /* Liste abhängen                                */
  1641.                         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, (struct List *) ~0 );
  1642.                         /* Alte Liste löschen                        */
  1643.                         while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  1644.                         {
  1645.                             FreeVec(n);
  1646.                         }
  1647.                         /* Gut, schreibe die Bestellung            */
  1648.                         DatenLesen();
  1649.                         /* Liste wieder dranhängen                    */
  1650.                         gt_AttachList( BestellenGadgets[ GD_Diskliste ], BestellenWnd, &vdblist );
  1651.                         /* Bearbeitungsgadget löschen                */
  1652.                         gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, "");
  1653.                         /* Gadgets ausblenden                        */
  1654.                         checkonoff();
  1655.                     }
  1656.                     FreeAslRequest(fr);
  1657.                 }
  1658.             }
  1659.             break;
  1660.  
  1661.         /* Menupunkt Speichern Adressen/Einstellungen        */
  1662.         case MENU_FOO_SPA:
  1663.             EinstSchreiben();
  1664.             break;
  1665.  
  1666.         /* Menupunkt Speichern Diskettenliste                    */
  1667.         case MENU_FOO_SPB:
  1668.             DatenSchreiben(&vdblist);
  1669.             break;
  1670.  
  1671.         /* Menupunkt Speichern als ... Adressen/Einstell.    */
  1672.         case MENU_FOO_SAA:
  1673.             /* Wenn die Asl.library geöffnet werden konnte    */
  1674.             if( AslBase )
  1675.             {
  1676.                 /* Verzeichnis ermitteln                            */
  1677.                 i = (unsigned)((STRPTR)PathPart(Einst_File) - (STRPTR)Einst_File);
  1678.                 strncpy(Verzeichnis,Einst_File,i);
  1679.                 Verzeichnis[i] = 0;
  1680.                 /* Öffne einen einfachen Filerequester            */
  1681.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1682.                                                                                         ASL_Dir, Verzeichnis,
  1683.                                                                                         ASL_File, FilePart(Einst_File),
  1684.                                                                                         TAG_DONE))
  1685.                 {
  1686.                     if(AslRequest(fr,NULL))
  1687.                     {
  1688.                         /* Der neue Filerequester setzt sich    */
  1689.                         /* aus Drawer und File zusammen.            */
  1690.                         strcpy(Einst_File, fr->fr_Drawer);
  1691.                         strcat(Einst_File, fr->fr_File);
  1692.                         EinstSchreiben();
  1693.                     }
  1694.                     FreeAslRequest(fr);
  1695.                 }
  1696.             }
  1697.             break;
  1698.  
  1699.         /* Menupunkt Speichern als ... Diskettenliste        */
  1700.         case MENU_FOO_SAB:
  1701.             /* Wenn die Asl.library geöffnet werden konnte    */
  1702.             if( AslBase )
  1703.             {
  1704.                 /* Verzeichnis ermitteln                            */
  1705.                 i = (unsigned)((STRPTR)PathPart(T_Remember) - (STRPTR)T_Remember);
  1706.                 strncpy(Verzeichnis,T_Remember,i);
  1707.                 Verzeichnis[i] = 0;
  1708.                 /* Öffne einen einfachen Filerequester            */
  1709.                 if (fr = ( struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  1710.                                                                                         ASL_Dir, Verzeichnis,
  1711.                                                                                         ASL_File, FilePart(T_Remember),
  1712.                                                                                         TAG_DONE))
  1713.                 {
  1714.                     if(AslRequest(fr,NULL))
  1715.                     {
  1716.                         /* Der neue Filerequester setzt sich    */
  1717.                         /* aus Drawer und File zusammen.            */
  1718.                         strcpy(T_Remember, fr->fr_Drawer);
  1719.                         strcat(T_Remember, fr->fr_File);
  1720.                         DatenSchreiben( &vdblist );
  1721.                     }
  1722.                     FreeAslRequest(fr);
  1723.                 }
  1724.             }
  1725.             break;
  1726.  
  1727.         /* Menupunkt Drucken                                            */
  1728.         case MENU_FOO_DRU:
  1729.             /* Unterprogramm zum Drucken starten                */
  1730.             Drucken(&vdblist);
  1731.             break;
  1732.  
  1733.         /* Menupunkt Information                                    */
  1734.         case MENU_FOO_INF:
  1735.             /* Starten wir nen kleinen Inforequester            */
  1736.             es.es_StructSize    = sizeof(struct EasyStruct);
  1737.             es.es_Flags            = 0;
  1738.             es.es_Title            = AppStrings[MSG_InfoReqTitel];
  1739.             es.es_TextFormat    = AppStrings[MSG_InfoReqText];
  1740.             es.es_GadgetFormat= AppStrings[MSG_InfoReqWahl];
  1741.  
  1742.             EasyRequest(BestellenWnd, &es, NULL);
  1743.             break;
  1744.  
  1745.         /* Menupunkt Verbergen                                        */
  1746.         case MENU_FOO_HID:
  1747.             /* Fenster schließen                                        */
  1748.             CloseBestellenWindow();
  1749.             break;
  1750.  
  1751.         /* Menupunkt Programm beenden                                */
  1752.         case MENU_FOO_END:
  1753.             /* gut, Rückgabewert auf Ende setzen                */
  1754.             terminated = TRUE;
  1755.             break;
  1756.  
  1757.         /* Sollte nicht vorkommen                                    */
  1758.         default:
  1759.             break;
  1760.     }
  1761.     /* Rückgabewert, ob der User weitermachen will            */
  1762.     return(terminated);
  1763. }
  1764.  
  1765. /* Eine handelsübliche Taste wurde gedrückt                    */
  1766. BOOL Abfrage_Vanillakey( struct Gadget *gad, UWORD code)
  1767. {
  1768.     BOOL terminated = FALSE;
  1769.  
  1770.     /* Wollen wir doch mal sehen, welche da benutzt wurde    */
  1771.     if ((code == AppStrings[MSG_GadgetKey1a][0]) ||
  1772.         (code == AppStrings[MSG_GadgetKey1b][0]))
  1773.         {
  1774.             /* ist ein Eintrag in der liste ausgewählt?        */
  1775.             if( currentvdb )
  1776.                 /* ja, dann aktiviere das Feld unter der Liste*/
  1777.                 ActivateGadget( BestellenGadgets[GD_DiskAender], BestellenWnd, NULL );
  1778.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1779.             {
  1780.                 /* nein, dann selektiere den ersten Eintrag    */
  1781.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, 0);
  1782.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1783.                 /* aktiviere alle Gadgets                            */
  1784.                 checkonoff();
  1785.                 /* und setz den Disknamen ins String-Gadget    */
  1786.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1787.             }
  1788.         }
  1789.  
  1790.         /* Neuer Listeneintrag                                        */
  1791.     else if ((code == AppStrings[MSG_GadgetKey2a][0]) ||
  1792.         (code == AppStrings[MSG_GadgetKey2b][0]))
  1793.         {
  1794.             /* dafür haben wir doch ein Unterprogramm            */
  1795.             newvdb();
  1796.         }
  1797.  
  1798.         /* Jemand will nen Diskeintrag löschen                    */
  1799.     else if ((code == AppStrings[MSG_GadgetKey3a][0]) ||
  1800.         (code == AppStrings[MSG_GadgetKey3b][0]))
  1801.         {
  1802.             /* Nur wenn ein Eintrag aktiviert ist löschen    */
  1803.             if( currentvdb )
  1804.                 EintragLoeschen();
  1805.         }
  1806.  
  1807.         /* Drucken                                                        */
  1808.     else if ((code == AppStrings[MSG_GadgetKey5a][0]) ||
  1809.         (code == AppStrings[MSG_GadgetKey5b][0]))
  1810.         {
  1811.             /* Druckroutine starten                                    */
  1812.             Drucken(&vdblist);
  1813.         }
  1814.  
  1815.         /* Abbrechen                                                    */
  1816.     else if ((code == AppStrings[MSG_GadgetKey6a][0]) ||
  1817.         (code == AppStrings[MSG_GadgetKey6b][0]))
  1818.         {
  1819.             /* Wenn er nimmer will, halten wir ihn nicht auf*/
  1820.             terminated = TRUE;
  1821.         }
  1822.  
  1823.         /* Absendername                                                */
  1824.     else if ((code == AppStrings[MSG_GadgetKey7a][0]) ||
  1825.         (code == AppStrings[MSG_GadgetKey7b][0]))
  1826.         {
  1827.             ActivateGadget( BestellenGadgets[GD_AName], BestellenWnd, NULL );
  1828.         }
  1829.  
  1830.         /* Absenderstraße                                                */
  1831.     else if ((code == AppStrings[MSG_GadgetKey8a][0]) ||
  1832.         (code == AppStrings[MSG_GadgetKey8b][0]))
  1833.         {
  1834.             ActivateGadget( BestellenGadgets[GD_AStrasse], BestellenWnd, NULL );
  1835.         }
  1836.  
  1837.         /* Absenderort                                                    */
  1838.     else if ((code == AppStrings[MSG_GadgetKey9a][0]) ||
  1839.         (code == AppStrings[MSG_GadgetKey9b][0]))
  1840.         {
  1841.             ActivateGadget( BestellenGadgets[GD_AOrt], BestellenWnd, NULL );
  1842.         }
  1843.  
  1844.         /* Kundennummer                                                */
  1845.     else if ((code == AppStrings[MSG_GadgetKey10a][0]) ||
  1846.         (code == AppStrings[MSG_GadgetKey10b][0]))
  1847.         {
  1848.             ActivateGadget( BestellenGadgets[GD_KundNr], BestellenWnd, NULL );
  1849.         }
  1850.  
  1851.         /* Empfängername                                                */
  1852.     else if ((code == AppStrings[MSG_GadgetKey11a][0]) ||
  1853.         (code == AppStrings[MSG_GadgetKey11b][0]))
  1854.         {
  1855.             ActivateGadget( BestellenGadgets[GD_EName], BestellenWnd, NULL );
  1856.         }
  1857.  
  1858.         /* Empfängerstraße                                            */
  1859.     else if ((code == AppStrings[MSG_GadgetKey12a][0]) ||
  1860.         (code == AppStrings[MSG_GadgetKey12b][0]))
  1861.         {
  1862.             ActivateGadget( BestellenGadgets[GD_EStrasse], BestellenWnd, NULL );
  1863.         }
  1864.  
  1865.         /* Empfänger Postleitzahl/Ort                                */
  1866.     else if ((code == AppStrings[MSG_GadgetKey13a][0]) ||
  1867.         (code == AppStrings[MSG_GadgetKey13b][0]))
  1868.         {
  1869.             ActivateGadget( BestellenGadgets[GD_EOrt], BestellenWnd, NULL );
  1870.         }
  1871.  
  1872.         /* Leerzeilen vorm Ausdruck                                */
  1873.     else if ((code == AppStrings[MSG_GadgetKey15a][0]) ||
  1874.         (code == AppStrings[MSG_GadgetKey15b][0]))
  1875.         {
  1876.             ActivateGadget( BestellenGadgets[GD_Abstand], BestellenWnd, NULL );
  1877.         }
  1878.  
  1879.         /* Zahlungsart Nachnahme                                    */
  1880.     else if ((code == AppStrings[MSG_VerKey1a][0]) ||
  1881.         (code == AppStrings[MSG_VerKey1b][0]))
  1882.         {
  1883.             P1.Versart = 0;
  1884.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1885.                                         GTMX_Active, P1.Versart,
  1886.                                         TAG_DONE);
  1887.         }
  1888.  
  1889.         /* Zahlungsart Vorkasse                                        */
  1890.     else if ((code == AppStrings[MSG_VerKey2a][0]) ||
  1891.         (code == AppStrings[MSG_VerKey2b][0]))
  1892.         {
  1893.             P1.Versart = 1;
  1894.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1895.                                         GTMX_Active, P1.Versart,
  1896.                                         TAG_DONE);
  1897.         }
  1898.  
  1899.         /* Zahlungsart Rechnung                                        */
  1900.     else if ((code == AppStrings[MSG_VerKey3a][0]) ||
  1901.         (code == AppStrings[MSG_VerKey3b][0]))
  1902.         {
  1903.             P1.Versart = 2;
  1904.             GT_SetGadgetAttrs( BestellenGadgets[ GD_Zahlart ], BestellenWnd, NULL, 
  1905.                                         GTMX_Active, P1.Versart,
  1906.                                         TAG_DONE);
  1907.         }
  1908.  
  1909.         /* andere Eingaben interressieren uns nicht            */
  1910.     else
  1911.         {
  1912.         }
  1913.     /* und der der obligatorische Rückgabewert                */
  1914.     return(terminated);
  1915. }
  1916.  
  1917. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  1918. void Abfrage_Rawkey( struct Gadget *gad, UWORD code, struct Gadget *gd)
  1919. {
  1920.     int i;
  1921.  
  1922.     /* Ein paar Sachen für einen AmigaGuide aufruf            */
  1923.     struct NewAmigaGuide sync = {NULL};
  1924.     static UBYTE *AG_ID[] = {
  1925.         "GD_Diskliste",
  1926.         "GD_NeueDisk",
  1927.         "GD_DiskLoeschen",
  1928.         "GD_Zahlart",
  1929.         "GD_Drucken",
  1930.         "GD_Abbrechen",
  1931.         "GD_AName",
  1932.         "GD_AStrasse",
  1933.         "GD_AOrt",
  1934.         "GD_KundNr",
  1935.         "GD_EName",
  1936.         "GD_EStrasse",
  1937.         "GD_EOrt",
  1938.         "GD_DiskAender",
  1939.         "GD_Abstand",
  1940.     };
  1941.  
  1942.     AMIGAGUIDECONTEXT MyHandle;
  1943.  
  1944.     switch ( code )
  1945.     {
  1946.         /* Cursor hoch (Listview hoch)                            */
  1947.         case 76:
  1948.             /* sollte überhaupt ein Eintrag aktiv sein        */
  1949.             if( currentvdb )
  1950.             {
  1951.                 /* kucken wir, welche Nummer der hat            */
  1952.                 i = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  1953.                 /* senken die Nummer um 1 und                        */
  1954.                 i--;
  1955.                 /* sollten wir noch nicht ganz oben sein        */
  1956.                 if(i >= 0)
  1957.                 {
  1958.                     /* haben wir einen neuen aktuellen Eintr.    */
  1959.                     currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, i);    
  1960.                     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1961.                     /* ab damit ins Feld unter der Liste        */
  1962.                     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1963.                 }
  1964.             }
  1965.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1966.             {
  1967.                 /* nein, dann selektiere den ersten Eintrag    */
  1968.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, 0);
  1969.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1970.                 /* aktiviere alle Gadgets                            */
  1971.                 checkonoff();
  1972.                 /* und setz den Disknamen ins String-Gadget    */
  1973.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1974.             }
  1975.             break;
  1976.  
  1977.         /* Cursor hoch (Listview hoch)                            */
  1978.         case 77:
  1979.             /* sollte überhaupt ein Eintrag aktiv sein        */
  1980.             if( currentvdb )
  1981.             {
  1982.                 /* kucken wir, welche Nummer der hat            */
  1983.                 i = gt_GetListEntryNum( &vdblist, (struct Node *) currentvdb );
  1984.                 /* erhöhen die Nummer um 1 und                    */
  1985.                 i++;
  1986.                 /* sollten wir noch nicht ganz unten sein,    */
  1987.                 if(i < gt_GetListNumEntries( &vdblist ))
  1988.                 {
  1989.                     /* haben wir einen neuen aktuellen Eintr.    */
  1990.                     currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, i);    
  1991.                     /* ab damit ins Feld unter der Liste        */
  1992.                     gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  1993.                     gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  1994.                 }
  1995.             }
  1996.             else if(gt_GetListNumEntries( &vdblist ) > 0)
  1997.             {
  1998.                 /* nein, dann selektiere den ersten Eintrag    */
  1999.                 currentvdb = (struct VDBnode *) gt_GetListEntry(&vdblist, gt_GetListNumEntries( &vdblist )-1 );
  2000.                 gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, gt_GetListEntryNum(&vdblist, (struct Node *) currentvdb));
  2001.                 /* aktiviere alle Gadgets                            */
  2002.                 checkonoff();
  2003.                 /* und setz den Disknamen ins String-Gadget    */
  2004.                 gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2005.             }
  2006.             break;
  2007.  
  2008.         /* Help-Taste gedrückt                                        */
  2009.         case 95:
  2010.             /* Ist die AmigaGuide Library geöffnet + OS 3.x    */
  2011.             if( AmigaGuideBase != NULL )
  2012.             {
  2013.                 /* Legen wir die Guide-Datei fest                */
  2014.                 sync.nag_Name    = "T_Bestellen.guide";
  2015.  
  2016.                 /* steht der Mauszeiger über keinem Gadget,    */
  2017.                 if(gd == NULL)
  2018.                     /* den defaultmäßigen Node setzen            */
  2019.                     sync.nag_Node    = "Window";
  2020.                 /* steht der Mauszeiger über einem Gadget,    */
  2021.                 else
  2022.                     /* wird dar passende Node gesetzt            */
  2023.                     sync.nag_Node = AG_ID[gd->GadgetID];
  2024.  
  2025.                 /* Gut, öffnen wir die Guide Datei                */
  2026.                 MyHandle = OpenAmigaGuide( &sync, NULL );
  2027.  
  2028.                 /* und schließen sie, wenn's öffnen klappte    */
  2029.                 if(MyHandle)
  2030.                     CloseAmigaGuide( MyHandle);
  2031.  
  2032.             }
  2033.             /* Ist die AmigaGuide Library nicht zu öffnen,    */
  2034.             else
  2035.             {
  2036.                 /* gibts ne Message, daß ohne AmigaGuide nix    */
  2037.                 /* los ist mit der OnlineHilfe                    */
  2038.                 es.es_StructSize    = sizeof(struct EasyStruct);
  2039.                 es.es_Flags            = 0;
  2040.                 es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  2041.                 es.es_TextFormat    = AppStrings[MSG_ErrorReqText3];
  2042.                 es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  2043.  
  2044.                 EasyRequest(BestellenWnd, &es, NULL);
  2045.             }
  2046.             break;
  2047.  
  2048.         /* Sonstige Tasten jucken mich derzeit nicht            */
  2049.         default:
  2050.             break;
  2051.     }
  2052. }
  2053.  
  2054. /* eine der Tasten die nix aufm Bildschirm hinterlassen    */
  2055. void Abfrage_Menuhelp( UWORD code)
  2056. {
  2057.     /* Ein paar Sachen für einen AmigaGuide aufruf            */
  2058.     struct NewAmigaGuide sync = {NULL};
  2059.  
  2060.     AMIGAGUIDECONTEXT MyHandle;
  2061.  
  2062.     /* Ist die AmigaGuide Library geöffnet + OS 3.x            */
  2063.     if( AmigaGuideBase != NULL )
  2064.     {
  2065.         /* Legen wir die Guide-Datei fest                        */
  2066.         sync.nag_Name    = "T_Bestellen.guide";
  2067.  
  2068.         /* steht der Mauszeiger über einem Menüpunkt?        */
  2069.         switch(code)
  2070.         {
  2071.             /* HELP beim Menü-Punkt Öffnen Adressen            */
  2072.             case 0:
  2073.                 sync.nag_Node    = "Menu_OPA";
  2074.                 break;
  2075.             /* HELP beim Menü-Punkt Öffnen Diskliste            */
  2076.             case 2048:
  2077.                 sync.nag_Node    = "Menu_OPB";
  2078.                 break;
  2079.             /* HELP beim Menü-Punkt Speichern Adressen        */
  2080.             case 32:
  2081.                 sync.nag_Node    = "Menu_SPA";
  2082.                 break;
  2083.             /* HELP beim Menü-Punkt Speichern Diskliste        */
  2084.             case 2080:
  2085.                 sync.nag_Node    = "Menu_SPB";
  2086.                 break;
  2087.             /* HELP beim Menü-Punkt Speichern als ... Adres.*/
  2088.             case 64:
  2089.                 sync.nag_Node    = "Menu_SAA";
  2090.                 break;
  2091.             /* HELP beim Menü-Punkt Speichern als... Diskl.    */
  2092.             case 2112:
  2093.                 sync.nag_Node    = "Menu_SAB";
  2094.                 break;
  2095.             /* HELP beim Menü-Punkt Drucken                        */
  2096.             case 63584:
  2097.                 sync.nag_Node    = "Menu_Dru";
  2098.                 break;
  2099.             /* HELP beim Menü-Punkt Über T_Bestellen ...        */
  2100.             case 63648:
  2101.                 sync.nag_Node    = "Menu_Inf";
  2102.                 break;
  2103.             /* HELP beim Menü-Punkt Speichern Adressen        */
  2104.             case 63712:
  2105.                 sync.nag_Node    = "Menu_HID";
  2106.                 break;
  2107.             /* HELP beim Menü-Punkt Beenden                        */
  2108.             case 63744:
  2109.                 sync.nag_Node    = "Menu_End";
  2110.                 break;
  2111.             /* HELP außerhalb des Menüs, oder über Trennb.    */
  2112.             default:
  2113.                 sync.nag_Node    = "Window";
  2114.                 break;
  2115.         }
  2116.  
  2117.         /* Gut, öffnen wir die Guide Datei                        */
  2118.         MyHandle = OpenAmigaGuide( &sync, NULL );
  2119.  
  2120.         /* und schließen sie, wenn's öffnen klappte            */
  2121.         if(MyHandle)
  2122.             CloseAmigaGuide( MyHandle);
  2123.  
  2124.     }
  2125.     /* Ist die AmigaGuide Library nicht zu öffnen,            */
  2126.     else
  2127.     {
  2128.         /* gibts ne Message, daß ohne AmigaGuide nix            */
  2129.         /* los ist mit der OnlineHilfe                            */
  2130.         es.es_StructSize    = sizeof(struct EasyStruct);
  2131.         es.es_Flags            = 0;
  2132.         es.es_Title            = AppStrings[MSG_ErrorReqTitel];
  2133.         es.es_TextFormat    = AppStrings[MSG_ErrorReqText3];
  2134.         es.es_GadgetFormat= AppStrings[MSG_ErrorReqWahl];
  2135.  
  2136.         EasyRequest(BestellenWnd, &es, NULL);
  2137.     }
  2138. }
  2139.  
  2140. /* Verarbeiten der Commodity-Botschaften                        */
  2141. BOOL Cx_Message( CxMsg *msg )
  2142. {
  2143.     ULONG msgid, msgtype;
  2144.     BOOL terminated = FALSE;
  2145.     /* Message ID ermitteln                                            */
  2146.     msgid = CxMsgID(msg);
  2147.     /* Ebenso den Typ                                                    */
  2148.     msgtype = CxMsgType(msg);
  2149.     /* Eine Botschaft sollte auch beantwortet werden        */
  2150.     ReplyMsg((struct Message *)msg);
  2151.     /* Messagetyp auswerten                                            */
  2152.     switch(msgtype)
  2153.     {
  2154.         /* Benutzerdefinierte Ereignisse                            */
  2155.         case CXM_IEVENT:
  2156.             switch( msgid )
  2157.             {
  2158.                 /* HotKey wurde betätigt                            */
  2159.                 case EVT_HOTKEY:
  2160.                     if( CX_Popup )
  2161.                         WindowToFront( BestellenWnd );
  2162.                     else
  2163.                     {
  2164.                         OpenBestellenWindow();
  2165.                         Winfuell();
  2166.                         if( currentvdb )
  2167.                         {
  2168.                             gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, ListPos);
  2169.                             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2170.                         }
  2171.                     }
  2172.                     break;
  2173.                 /* eigentlich wird sonst niemand erwartet        */
  2174.                 default:
  2175.                     break;
  2176.             }
  2177.             break;
  2178.         /* Kommando, bekannt aus Exchange                        */
  2179.         case CXM_COMMAND:
  2180.             switch( msgid )
  2181.             {
  2182.                 /* Commodity schlafen schicken                    */
  2183.                 case CXCMD_DISABLE:
  2184.                     ActivateCxObj(broker, 0L);
  2185.                     break;
  2186.                 /* und wieder aufwecken                                */
  2187.                 case CXCMD_ENABLE:
  2188.                     ActivateCxObj(broker, 1L);
  2189.                     break;
  2190.                 /* Keine Lust mehr? Beendet das Programm        */
  2191.                 case CXCMD_KILL:
  2192.                     terminated = TRUE;
  2193.                     break;
  2194.                 /* Programm wurde nochmal gestartet                */
  2195.                 /* Fenster öffnen                                        */
  2196.                 case CXCMD_UNIQUE:
  2197.                 case CXCMD_APPEAR:
  2198.                     if( CX_Popup )
  2199.                         WindowToFront( BestellenWnd );
  2200.                     else
  2201.                     {
  2202.                         OpenBestellenWindow();
  2203.                         Winfuell();
  2204.                         if( currentvdb )
  2205.                         {
  2206.                             gt_SetLV(BestellenGadgets[GD_Diskliste], BestellenWnd, ListPos);
  2207.                             gt_SetString( BestellenGadgets[GD_DiskAender], BestellenWnd, currentvdb->d.Name );
  2208.                         }
  2209.                     }
  2210.                     break;
  2211.                 /* Fenster verbergen                                    */
  2212.                 case CXCMD_DISAPPEAR:
  2213.                     if( CX_Popup )
  2214.                         CloseBestellenWindow();
  2215.                     break;
  2216.                 default:
  2217.                     break;
  2218.             }
  2219.             break;
  2220.         default:
  2221.             break;
  2222.     }
  2223.     return terminated;
  2224. }
  2225.  
  2226.  
  2227. /* Lokalisierte Texte einlesen (wenn vorhanden)                */
  2228. void LocaleLesen()
  2229. {
  2230.     if (LocaleBase) {
  2231.         struct    Catalog    *catalog = OpenCatalog (NULL,"T_Bestellen.catalog",OC_BuiltInLanguage,MSG_Language,TAG_DONE) ;
  2232.         if (catalog) {
  2233.             UBYTE    n ;
  2234.             for (n=0 ; n<=MSG_Max ; n++)
  2235.                 AppStrings[n] = GetCatalogStr (catalog,n,AppStrings[n]) ;
  2236.             CloseCatalog (catalog) ;
  2237.         }
  2238.     }
  2239.     /* Hotkey-Vermerk an den Fenstertitel anhängen            */
  2240.     strcpy(WinTitel, AppStrings[MSG_WindowName]);
  2241.     strcat(WinTitel, CX_Popkey);
  2242.     strcat(WinTitel, ">");
  2243.  
  2244.     /* MenuTexte übernehmen                                            */
  2245.     BestellenNewMenu[0].nm_Label = AppStrings[MSG_MenuText1];
  2246.     BestellenNewMenu[1].nm_Label = AppStrings[MSG_MenuText2];
  2247.     BestellenNewMenu[2].nm_Label = AppStrings[MSG_MenuText2a];
  2248.     BestellenNewMenu[3].nm_Label = AppStrings[MSG_MenuText2b];
  2249.     BestellenNewMenu[4].nm_Label = AppStrings[MSG_MenuText3];
  2250.     BestellenNewMenu[5].nm_Label = AppStrings[MSG_MenuText2a];
  2251.     BestellenNewMenu[6].nm_Label = AppStrings[MSG_MenuText2b];
  2252.     BestellenNewMenu[7].nm_Label = AppStrings[MSG_MenuText4];
  2253.     BestellenNewMenu[8].nm_Label = AppStrings[MSG_MenuText2a];
  2254.     BestellenNewMenu[9].nm_Label = AppStrings[MSG_MenuText2b];
  2255.     BestellenNewMenu[10].nm_Label = AppStrings[MSG_MenuText5];
  2256.     BestellenNewMenu[12].nm_Label = AppStrings[MSG_MenuText6];
  2257.     BestellenNewMenu[14].nm_Label = AppStrings[MSG_MenuText7];
  2258.     BestellenNewMenu[15].nm_Label = AppStrings[MSG_MenuText8];
  2259.  
  2260.     /* Menu-ShortCuts übernehmen                                    */
  2261.     BestellenNewMenu[2].nm_CommKey = AppStrings[MSG_MenuKey2];
  2262.     BestellenNewMenu[3].nm_CommKey = AppStrings[MSG_MenuKey2b];
  2263.     BestellenNewMenu[5].nm_CommKey = AppStrings[MSG_MenuKey3];
  2264.     BestellenNewMenu[6].nm_CommKey = AppStrings[MSG_MenuKey3b];
  2265.     BestellenNewMenu[8].nm_CommKey = AppStrings[MSG_MenuKey4];
  2266.     BestellenNewMenu[9].nm_CommKey = AppStrings[MSG_MenuKey4b];
  2267.     BestellenNewMenu[10].nm_CommKey = AppStrings[MSG_MenuKey5];
  2268.     BestellenNewMenu[12].nm_CommKey = AppStrings[MSG_MenuKey6];
  2269.     BestellenNewMenu[14].nm_CommKey = AppStrings[MSG_MenuKey7];
  2270.     BestellenNewMenu[15].nm_CommKey = AppStrings[MSG_MenuKey8];
  2271.  
  2272.     /* Gadget-Texte übernehmen                                        */
  2273.     BestellenNGad[0].ng_GadgetText = AppStrings[MSG_GadgetText1];
  2274.     BestellenNGad[1].ng_GadgetText = AppStrings[MSG_GadgetText2];
  2275.     BestellenNGad[2].ng_GadgetText = AppStrings[MSG_GadgetText3];
  2276.     BestellenNGad[4].ng_GadgetText = AppStrings[MSG_GadgetText5];
  2277.     BestellenNGad[5].ng_GadgetText = AppStrings[MSG_GadgetText6];
  2278.     BestellenNGad[6].ng_GadgetText = AppStrings[MSG_GadgetText7];
  2279.     BestellenNGad[7].ng_GadgetText = AppStrings[MSG_GadgetText8];
  2280.     BestellenNGad[8].ng_GadgetText = AppStrings[MSG_GadgetText9];
  2281.     BestellenNGad[9].ng_GadgetText = AppStrings[MSG_GadgetText10];
  2282.     BestellenNGad[10].ng_GadgetText = AppStrings[MSG_GadgetText11];
  2283.     BestellenNGad[11].ng_GadgetText = AppStrings[MSG_GadgetText12];
  2284.     BestellenNGad[12].ng_GadgetText = AppStrings[MSG_GadgetText13];
  2285.     BestellenNGad[14].ng_GadgetText = AppStrings[MSG_GadgetText15];
  2286.  
  2287.     /* IText (Infotexte auf dem Screen)                            */
  2288.     BestellenIText[0].IText = AppStrings[MSG_IText1];
  2289.     BestellenIText[1].IText = AppStrings[MSG_IText2];
  2290.  
  2291.     /* MX-Gadget (Versandarten-Gadget)                            */
  2292.     Gadget300Labels[0] = AppStrings[MSG_Versandart1];
  2293.     Gadget300Labels[1] = AppStrings[MSG_Versandart2];
  2294.     Gadget300Labels[2] = AppStrings[MSG_Versandart3];
  2295. }
  2296.  
  2297. /* IconToolTypes einlesen                                            */
  2298. void ToolTypesLesen(char *name)
  2299. {
  2300.     struct DiskObject        *diskobj;
  2301.     char *s;
  2302.  
  2303.     /* Icon.library geöffnet?                                        */
  2304.     if ( IconBase )
  2305.     {
  2306.         diskobj = GetDiskObject( name );
  2307.         if (diskobj)
  2308.         {
  2309.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"POSX"))
  2310.                 WinX = atoi(s);
  2311.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"POSY"))
  2312.                 WinY = atoi(s);
  2313.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"DISKFILE"))
  2314.                 strcpy(T_Remember, s);
  2315.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"ADDRFILE"))
  2316.                 strcpy(Einst_File, s);
  2317.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_PRIORITY"))
  2318.                 CX_Priority = atoi(s);
  2319.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_POPUP"))
  2320.                 if(MatchToolValue(s,"NO"))
  2321.                     CX_Popup = FALSE;
  2322.             if (s = FindToolType((STRPTR *)diskobj->do_ToolTypes,"CX_POPKEY"))
  2323.                 strcpy(CX_Popkey, s);
  2324.             FreeDiskObject (diskobj);
  2325.         }        
  2326.     }
  2327. }
  2328.  
  2329. /* Einrichten des Programms als Commodity                        */
  2330. void StartCom()
  2331. {
  2332.     translate = NULL;
  2333.     if ( CxBase )
  2334.     {
  2335.         /* NewBroker Structur füllen:                                */
  2336.         /* Version der NewBroker strukt. (immer NB_Version)*/
  2337.         newbroker.nb_Version = NB_VERSION;
  2338.         /* Programmname, erscheint dann in der Exchange-L.    */
  2339.         newbroker.nb_Name = (char *)AppStrings[MSG_MXName];
  2340.         /* Programmbezeich., erste Zeile Exchange B.            */
  2341.         newbroker.nb_Title = (char *)AppStrings[MSG_MXInfoName];
  2342.         /* Programmbeschreibung, zweite Zeile Exchange B.    */
  2343.         newbroker.nb_Descr = (char *)AppStrings[MSG_MXInfoText];
  2344.         /* Doppelten Start des PGMs verhindern und            */
  2345.         /* Nachricht an das Laufende Programm, beim Versuch*/
  2346.         newbroker.nb_Unique = NBU_UNIQUE | NBU_NOTIFY;
  2347.         /* Fenster ist vorhanden!                                    */
  2348.         newbroker.nb_Flags = COF_SHOW_HIDE;
  2349.         /* Priorität des Commodities (per ToolType wählb.)    */
  2350.         newbroker.nb_Pri = CX_Priority;
  2351.         /* MsgPort, der muß aber erst eingerichtet werden    */
  2352.         newbroker.nb_Port = CreateMsgPort();
  2353.         /* Der Rest ist für künftige Funktionen reserviert    */
  2354.         newbroker.nb_ReservedChannel = NULL;
  2355.  
  2356.         /* Broker an Commodity-Lib zur Anmeldung übergeben    */
  2357.         if( broker = CxBroker(&newbroker,NULL) )
  2358.         {
  2359.             /* Hotkey zu Filterobjekt verarbeiten                */
  2360.             if (filter = CxFilter(CX_Popkey))
  2361.             {
  2362.                 /* HotKey Filter an broker anhängen                */
  2363.                 AttachCxObj(broker, filter);
  2364.                 if (sender = CxSender(newbroker.nb_Port, EVT_HOTKEY))
  2365.                 {
  2366.                     AttachCxObj(filter,sender);
  2367.                     if (translate = CxTranslate(NULL))
  2368.                     {
  2369.                         AttachCxObj(filter,translate);
  2370.                         if(!CxObjError(filter))
  2371.                         {
  2372.                             /* Broker aktivieren                        */
  2373.                             ActivateCxObj(broker, 1L);
  2374.                             /* Signal-Bit merken, für Abfrage    */
  2375.                             cxsigflag = 1L << newbroker.nb_Port->mp_SigBit;
  2376.                         }
  2377.                     }
  2378.                 }
  2379.             }
  2380.         }
  2381.     }
  2382. }
  2383.  
  2384. /* Hauptprogramm                                                        */
  2385. int main( int argc, char *argv[] )
  2386. {
  2387.     /* Hatt das öffnen der Libraries hingehauen?                */
  2388.     if( OpenAll() == TRUE )
  2389.     {
  2390.         struct    VDBnode    *n;
  2391.         struct    IntuiMessage    *imsg;
  2392.         struct    Gadget    *gad;
  2393.         struct    Gadget    *gd = NULL;
  2394.         ULONG        imsgClass;
  2395.         UWORD        imsgCode;
  2396.         BOOL        Done    = FALSE;
  2397.         CxMsg        *msg;
  2398.  
  2399.         /* Einlesen der ToolTypes (für Benutzereinstell.)    */
  2400.         /* In argv[0] steht übrigens der Programmname        */
  2401.         ToolTypesLesen(argv[0]);
  2402.  
  2403.         /* Einlesen der Locale-Daten (für andere Sprachen)    */
  2404.         LocaleLesen();
  2405.  
  2406.         /* Als Commodity einrichten                                */
  2407.         StartCom();
  2408.         if (!translate)
  2409.             exit(0);
  2410.  
  2411.         /* Einstellungen lesen                                        */
  2412.         EinstLesen();
  2413.  
  2414.         /* Daten lesen                                                    */
  2415.         DatenLesen();
  2416.  
  2417.         /* Bildschirm vorbereiten                                    */
  2418.         SetupScreen();
  2419.         /* Fenster öffnen, wenn per ToolTypes so gewählt    */
  2420.         if ( CX_Popup )
  2421.         {
  2422.             OpenBestellenWindow();
  2423.             /* Window mit Voreinstellungen füllen                */
  2424.             Winfuell();
  2425.         }
  2426.  
  2427.         /* Hauptschleife                                                */
  2428.         while( !Done )
  2429.         {
  2430.             /* Auf IntuiMassage warten                                */
  2431.             Wait( cxsigflag | wndsigflag );
  2432.  
  2433.             /* und Auswerten (Commodity)                            */
  2434.             if (cxsigflag)
  2435.             {
  2436.                 while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  2437.                 {
  2438.                     Done = Cx_Message(msg);
  2439.                 }
  2440.             }
  2441.  
  2442.             /* Nachricht vom Fenster                                */ 
  2443.             while((CX_Popup) && (imsg = GT_GetIMsg(BestellenWnd->UserPort)))
  2444.             {
  2445.                 imsgClass        = imsg->Class;
  2446.                 imsgCode            = imsg->Code;
  2447.                 gad = (struct Gadget *)imsg->IAddress;
  2448.  
  2449.                 /* Jede empfangen Nachricht bestätigen            */
  2450.                 GT_ReplyIMsg(imsg);
  2451.  
  2452.                 switch( imsgClass )
  2453.                 {
  2454.                     /* Windowschließsymbol gedrückt                */
  2455.                     case IDCMP_CLOSEWINDOW:
  2456.                         Done = TRUE;
  2457.                         break;
  2458.  
  2459.                     /* Gadget gedrückt                                */
  2460.                     case IDCMP_GADGETUP:
  2461.                     case IDCMP_GADGETDOWN:
  2462.                         Done = Abfrage_Gadgetup(gad, imsgCode);
  2463.                         break;
  2464.  
  2465.                     /* Menupunkt ausgewählt                            */
  2466.                     case IDCMP_MENUPICK:
  2467.                         Done = Abfrage_Menuepick(imsgCode);
  2468.                         break;
  2469.  
  2470.                     /* gewähnliche Taste gedrückt                    */
  2471.                     case IDCMP_VANILLAKEY:
  2472.                         Done = Abfrage_Vanillakey( gad, imsgCode);
  2473.                         break;
  2474.  
  2475.                     /* Mauszeiger ruht kurze Zeit über            */
  2476.                     /* einem Gadget => Gadget merken                */
  2477.                     case IDCMP_GADGETHELP:
  2478.                         if( imsg->IAddress == (APTR) BestellenWnd ) 
  2479.                             gd = NULL;
  2480.                         else
  2481.                             gd = gad;
  2482.                         break;
  2483.  
  2484.                     /* Während der Menüauswahl wurde die        */
  2485.                     /* Help-Taste gedrückt                            */
  2486.                     case IDCMP_MENUHELP:
  2487.                         Abfrage_Menuhelp( imsgCode);
  2488.                         break;
  2489.  
  2490.                     /* Steuertaste gedrückt                            */
  2491.                     case IDCMP_RAWKEY:
  2492.                         Abfrage_Rawkey(gad,imsgCode,gd);
  2493.                         break;
  2494.  
  2495.                     /* Irgend was anderes, ignorieren            */
  2496.                     default:
  2497.                         break;
  2498.                 }
  2499.             }
  2500.         }
  2501.  
  2502.         /* Fenster und Bilschirm schließen                        */
  2503.         CloseBestellenWindow();
  2504.         CloseDownScreen();
  2505.  
  2506.         /* Einstellungen speichern                                    */
  2507.         EinstSchreiben();
  2508.  
  2509.         /* Daten speichern und freigeben                            */
  2510.         DatenSchreiben(&vdblist);
  2511.         while( ( n = (struct VDBnode *) RemHead( &vdblist ) ) )
  2512.         {
  2513.             FreeVec(n);
  2514.         }
  2515.         /* Als Commodity abmelden                                    */
  2516.         if ( broker )
  2517.             DeleteCxObj( broker );
  2518.         /* Noch übrige Meldungen abarbeiten                        */
  2519.         while(msg = (CxMsg *)GetMsg(newbroker.nb_Port))
  2520.             ReplyMsg((struct Message *)msg);
  2521.         /* Commodity-Port freigeben                                */
  2522.         if (newbroker.nb_Port)
  2523.             DeletePort(newbroker.nb_Port);
  2524.     }
  2525.     /* Die Librareis konnten nicht (alle) geöffnet werden    */
  2526.     else
  2527.     {
  2528.         /* Nachricht an den User, daß da was nicht stimmt    */
  2529.         printf(AppStrings[MSG_OSError]);
  2530.     }
  2531.     /* geöffnete Libraries wieder schließen                    */
  2532.     CloseAll();
  2533.  
  2534.     /* 0 zurückgeben = alles glattgelaufen                        */
  2535.     return(0);
  2536. }
  2537.