home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #3 / amigamamagazinepolishissue1998.iso / bazy / carcosts / source / main.c < prev    next >
C/C++ Source or Header  |  1996-11-02  |  20KB  |  768 lines
  1. #include "demo.h"
  2. #define STRINGARRAY
  3. #include "Daten.h" 
  4. #include <proto/locale.h>
  5. #include <stdarg.h>
  6.  
  7.  
  8.  char Fehler[]="Error while opening >%s< version %ld !";
  9.  char versionstring[]="\0$VER: CARCOSTS "VERSION" "DATE;
  10.  
  11.  
  12.  extern struct WBStartup     *WBenchMsg;
  13.  struct FileRequester        *Rq;
  14.  struct DiskObject           *DiskObj;
  15.  struct Library              *MUIMasterBase;
  16.  struct Library              *LocaleBase;
  17.  struct Library              *IconBase;
  18.  struct IntuitionBase        *IntuitionBase;
  19.  struct Catalog              *mycat;
  20.  struct RDArgs               *RArgsResult;
  21.  struct Daten                 Daten;
  22.  
  23.  char Version[80];
  24.  char WTitel[80];
  25.  char Dir[150];
  26.  char FileName[300];
  27.  char PrtName[300];
  28.  char TitelString1[100];
  29.  char TitelString2[100];
  30.  
  31.  char Start_Kennzeichen[20];
  32.  char Start_Datum[20];
  33.  LONG Start_Day;
  34.  LONG Start_KM;
  35.  LONG Start_Format=FORMAT_DOS;
  36.  
  37.  
  38.  
  39. #ifdef __SASC
  40.  int CXBRK(void) 
  41.   {
  42.    return(0);
  43.   }
  44.  int _CXBRK(void) 
  45.   {
  46.    return(0);
  47.   }
  48.  void chkabort(void) 
  49.   {
  50.   }
  51. #endif
  52.  
  53.  LONG __stack = 8192;
  54.  
  55.  
  56.  
  57.  
  58.  
  59. /*************************************************************************
  60.  *************************************************************************
  61.  *************************************************************************
  62.  
  63. Function: main()
  64.  Main function of CarCosts. Opens all libraries, copies the catalog strings,
  65.  copies the menu items, checks if there is an argument (from shell or 
  66.  workbench) and calls the main loop.
  67.  
  68. Return: VOID
  69.  
  70. Author: Rüdiger Dreier
  71.  
  72. History:
  73.  01.10.1993: Initial version
  74.  
  75.  *************************************************************************
  76.  *************************************************************************
  77.  *************************************************************************/
  78.  
  79. VOID __stdargs __main(char *line)
  80.   {
  81.    LONG i;
  82.    LONG array[2]=
  83.     {
  84.      0,0
  85.     };
  86.    char *temp="FILE";
  87.    char *file=0;
  88.    
  89.    if(IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",
  90.                                                            37L))
  91.     {
  92.      if(!(IconBase = OpenLibrary("icon.library",
  93.                                  37L)))
  94.       {
  95.        ShowRequest2(0, "Error", Fehler, "OK","icon.library",37L);
  96.       }
  97.      else
  98.       {
  99.        if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
  100.         {
  101.          ShowRequest2(0, "Error", Fehler, "OK","MUIMaster.library",
  102.                       MUIMASTER_VMIN);
  103.         }
  104.        else
  105.         {
  106.          /* Hier Catalog öffnen und eventuell AppStrings umbiegen */
  107.          if(LocaleBase = OpenLibrary("locale.library",38L))
  108.           {
  109.            if(mycat = OpenCatalog(NULL, "carcost.catalog",
  110.                                   OC_BuiltInLanguage,"deutsch",
  111.                                   TAG_DONE))
  112.             {
  113.              char *string;
  114.              for(i=0;i<=MAXLOCALE;i++)
  115.               {
  116.                string = GetCatalogStr(mycat, i, AppStrings[i].as_Str);
  117.                if(string) AppStrings[i].as_Str = string;
  118.               }
  119.             }
  120.           }
  121.          i=0;
  122.          while(NewMenu[i].nm_Label)
  123.           {
  124.            LONG number;
  125.            if(NewMenu[i].nm_Label != NM_BARLABEL) 
  126.             {
  127.              number = (LONG)NewMenu[i].nm_Label;
  128.              NewMenu[i].nm_Label = &TEXT(number)[2];
  129.              if(TEXT(number)[0] != ' ')
  130.               {
  131.                NewMenu[i].nm_CommKey = TEXT(number);
  132.               }
  133.             }
  134.            i++;
  135.           }
  136.          if(!LocaleBase) Formate[4]=0; /* Kein locale */
  137.          
  138.          sprintf(WTitel,"%s (c) by Rüdiger Dreier",TEXT(MSG_PROGNAME));
  139.          sprintf(Version, "$%s: %s Version "VERSION" "DATE,"VER",TEXT(MSG_PROGNAME));
  140.          
  141.          if(line)
  142.           {
  143.            /* Von der Shell aus gestartet */
  144.            RArgsResult = ReadArgs(temp, array, 0);
  145.            
  146.            file = (char *)array[0];
  147.            if(file)
  148.             {
  149.              char help[6];
  150.              strcpy(FileName,file);
  151.              if(strlen(file) > 4)
  152.               {
  153.                strcpy(help, &file[strlen(file)-4]);
  154.                if(strcmpi(help,TEXT(MSG_EXTENSION)))
  155.                 {
  156.                  strcat(FileName,TEXT(MSG_EXTENSION));
  157.                 }
  158.               }
  159.              else
  160.               {
  161.                strcat(FileName,TEXT(MSG_EXTENSION));
  162.               }
  163.             }
  164.           }
  165.          
  166.          if(WBenchMsg && WBenchMsg->sm_NumArgs >1)
  167.           {
  168.      /* Funktion: Name des Verzeichnisses besorgen und Namen */
  169.      /* zusammenstellen                                      */
  170.            
  171.            struct WBArg *arg;
  172.            
  173.            arg     = WBenchMsg->sm_ArgList;
  174.            NameFromLock(arg[1].wa_Lock, FileName,300);
  175.            AddPart(FileName, arg[1].wa_Name, 300);
  176.           }
  177.          
  178.          if(WBenchMsg)
  179.           {
  180.            /* Es wurde von Workbench gestartet */
  181.            DiskObj = GetDiskObject(WBenchMsg->sm_ArgList->wa_Name);
  182.           }
  183.          if(MyInit())
  184.           {
  185.            ReCalcTreib();
  186.            Rq = MUI_AllocAslRequest(ASL_FileRequest,TAG_DONE);
  187.            if(Rq)
  188.             {
  189.              
  190.              if(FileName[0]) 
  191.               {
  192.                RemoveAll();
  193.                InsertAll(FileName);
  194.               }
  195.              Loop();
  196.              
  197.              MUI_FreeAslRequest(Rq);
  198.             }
  199.           }
  200.          
  201.          if(RArgsResult)      FreeArgs(RArgsResult);
  202.          
  203.          /* Catalog wieder schließen, falls offen */
  204.          if(mycat) CloseCatalog(mycat);
  205.          if(LocaleBase) CloseLibrary(LocaleBase);
  206.          
  207.          if(DiskObj) FreeDiskObject(DiskObj);
  208.          if (App) MUI_DisposeObject(App);
  209.          
  210.          CloseLibrary(MUIMasterBase);
  211.         }
  212.        CloseLibrary(IconBase);
  213.       }
  214.      CloseLibrary((struct Library *)IntuitionBase);
  215.     }
  216.   }
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223. /*************************************************************************
  224.  *************************************************************************
  225.  *************************************************************************
  226.  
  227. Function: SaveAll()
  228.  Saves all data to the file >filename<. The data is saved as ASCII
  229.  
  230. Return: VOID
  231.  
  232. Author: Rüdiger Dreier
  233.  
  234. History:
  235.  01.10.1993: Initial version
  236.  07.01.1995: Larger buffers 
  237.  
  238.  *************************************************************************
  239.  *************************************************************************
  240.  *************************************************************************/
  241.  
  242.  VOID SaveAll(char *filename)
  243.   {
  244.    BPTR file;
  245.    LONG max,i,j,k;
  246.    char buffer[3*MAXTEXTSTRING+100]; // DAS sollte jetzt aber reichen...
  247.    
  248.    ReCalcTreib();
  249.    
  250.    if(Start_Kennzeichen[strlen(Start_Kennzeichen)-1]==0x0a)
  251.     {
  252.      Start_Kennzeichen[strlen(Start_Kennzeichen)-1] = 0;
  253.     }
  254.    
  255.    file = Open(filename, MODE_NEWFILE);
  256.    if(file)
  257.     {
  258.      sprintf(buffer,"#\n%s %8ld %8ld %3ld\n%s\n#\n",
  259.              Start_Datum,
  260.              Start_Day,
  261.              Start_KM,
  262.              Start_Format,
  263.              Start_Kennzeichen);
  264.      FPuts(file, buffer);
  265.      
  266.      get(LI_Treib, MUIA_List_Entries, &max);
  267.      
  268.      for(i=0;i<max;i++)
  269.       {
  270.        struct NodeTreib *nw;
  271.        
  272.        DoMethod(LI_Treib, MUIM_List_GetEntry, i, &nw);
  273.        
  274.        sprintf(buffer,
  275.                "%s %8ld "FORMAT_KILOMETER" "FORMAT_LITER" "FORMAT_PREIS"\n",
  276.                nw->Datum,
  277.                nw->Days,
  278.                nw->kmStand,
  279.                nw->Liter,
  280.                nw->Preis);
  281.        FPuts(file,buffer);
  282.       }
  283.      FPuts(file,"#\n");
  284.      
  285.      get(LI_Unter, MUIA_List_Entries, &max);
  286.      
  287.      for(i=0;i<max;i++)
  288.       {
  289.        struct NodeUnter *nw;
  290.        DoMethod(LI_Unter, MUIM_List_GetEntry, i, &nw);
  291.        
  292.        /* Leerzeichen übergehen */
  293.        j=0;
  294.        k=0;
  295.        while(nw->Titelstring[j]==' ') j++;
  296.        while(nw->Bemerkungstring[k]==' ') k++;
  297.        
  298.        sprintf(buffer,"%s %8ld "FORMAT_PREIS"\n%s\n%s\n",
  299.                nw->Datum, nw->Days,
  300.                nw->Preis,
  301.                &nw->Titelstring[j],
  302.                &nw->Bemerkungstring[k]);
  303.        FPuts(file,buffer);
  304.       }
  305.      FPuts(file,"#\n");
  306.      Close(file);
  307.     }
  308.   }
  309.  
  310.  
  311.  
  312.  
  313.  
  314. /*************************************************************************
  315.  *************************************************************************
  316.  *************************************************************************
  317.  
  318. Function: InsertAll()
  319.  Inserts the file >filename< in the list
  320.  
  321. Return: VOID
  322.  
  323. Author: Rüdiger Dreier
  324.  
  325. History:
  326.  01.10.1993: Initial version
  327.  07.01.1995: Larger buffers
  328.  
  329.  *************************************************************************
  330.  *************************************************************************
  331.  *************************************************************************/
  332.  
  333.  VOID InsertAll(char *filename)
  334.   {
  335.    BPTR file;
  336.    char *t,*tt;
  337.    char buffer[3*MAXTEXTSTRING+100];
  338.    char buffer2[3*MAXTEXTSTRING+50];
  339.    LONG lastkm;
  340.    
  341.    buffer[0]=0;
  342.    
  343.    file=Open(filename, MODE_OLDFILE);
  344.    if(file)
  345.     {
  346.      t=FGets(file,buffer,99L);
  347.      if(strcmp(buffer,"#\n")==0)
  348.       {
  349.        t=FGets(file,buffer,3*MAXTEXTSTRING);
  350.        if(buffer)
  351.         {
  352.          sscanf(buffer,"%s %ld %ld %ld",
  353.                 Start_Datum, 
  354.                 &Start_Day, 
  355.                 &Start_KM,
  356.                 &Start_Format);
  357.         ConvertToString(Start_Day, Start_Datum);
  358.          FGets(file, buffer, 19L);
  359.          if(buffer)
  360.           {
  361.            strcpy(Start_Kennzeichen, buffer);
  362.            //printf("Kennzeichen >%s<\n",Start_Kennzeichen);
  363.            if(Start_Kennzeichen[strlen(Start_Kennzeichen)-1]==0x0a)
  364.             {
  365.              Start_Kennzeichen[strlen(Start_Kennzeichen)-1] = 0;
  366.             }
  367.            //printf("Kennzeichen >%s<\n",Start_Kennzeichen);
  368.            
  369.            //sscanf(buffer,"%s",Start_Kennzeichen);
  370.            lastkm = Start_KM;
  371.            
  372.            t=FGets(file, buffer, 3*MAXTEXTSTRING);
  373.            if(buffer[0]=='#')
  374.             {
  375.              while(t)
  376.               {
  377.                struct NodeTreib nw,*w=&nw;
  378.                
  379.                t = FGets(file,buffer,3*MAXTEXTSTRING);
  380.                if(t)
  381.                 {
  382.                  if(strcmp(buffer,"#\n")==0)
  383.                   {
  384.                    t=0;
  385.                   }
  386.                  else
  387.                   {
  388.                    /* String auslesen, neuer Eintrag */  
  389.                    sscanf(buffer,"%s %ld %ld %lf %lf", buffer2,
  390.                           &nw.Days,
  391.                           &nw.kmStand,
  392.                           &nw.Liter,
  393.                           &nw.Preis);
  394.                    nw.deltakm   = nw.kmStand - lastkm;
  395.                    lastkm       = nw.kmStand;
  396.                    /* Division durch NULL abfangen */
  397.                    if(nw.deltakm != 0) 
  398.                    {
  399.                         nw.Verbrauch = 100.*nw.Liter / nw.deltakm;
  400.                    } else {
  401.                         nw.Verbrauch = 0.00;
  402.                    }
  403.                    //ConvertToString(nw.Days, nw.Datum);
  404.                    
  405.                    FillTreib(&nw);
  406.                    
  407.                    DoMethod(LI_Treib, MUIM_List_Insert, 
  408.                             &w, 1L, MUIV_List_Insert_Sorted);
  409.                    
  410.                   }
  411.                 }
  412.               }
  413.           
  414.              do
  415.               {
  416.                struct NodeUnter nw,*w=&nw;
  417.                
  418.                t = FGets(file,buffer,3*MAXTEXTSTRING);
  419.                if(t && buffer[0]!='#')
  420.                 {
  421.                  /* String auslesen, neuer Eintrag */  
  422.                  sscanf(buffer,"%s %ld %lf", buffer2,
  423.                         &nw.Days,&nw.Preis);
  424.                  
  425.                  nw.Bemerkungstring[0]=0;
  426.                  nw.Titelstring[0]=0;
  427.                  
  428.                  tt=FGets(file, buffer, 3*MAXTEXTSTRING);
  429.                  if(tt)
  430.                   {
  431.                    buffer[strlen(buffer)-1] = 0;
  432.                    sprintf(nw.Titelstring, FORMAT_TITEL, buffer);
  433.                    strcpy(buffer, nw.Titelstring);
  434.                    buffer[MAX_TITEL] = 0;
  435.                    strcpy(nw.DispTitel, buffer);
  436.                    
  437.                    tt=FGets(file, buffer, 3*MAXTEXTSTRING);
  438.                    if(tt)
  439.                     {
  440.                      buffer[strlen(buffer)-1] = 0;
  441.                      sprintf(nw.Bemerkungstring, FORMAT_BEMERKUNG, buffer);
  442.                      strcpy(buffer, nw.Bemerkungstring);
  443.                      buffer[MAX_REM] = 0;
  444.                      strcpy(nw.DispRem, buffer);
  445.                     }
  446.                   }
  447.                   FillUnter(&nw);
  448.                  //ConvertToString(nw.Days, nw.Datum);
  449.                  DoMethod(LI_Unter, MUIM_List_Insert, 
  450.                           &w, 1L, MUIV_List_Insert_Sorted);
  451.                 } else {
  452.                   t = 0;
  453.                 }
  454.               }
  455.              while(t);
  456.             }
  457.           }
  458.         }
  459.       }
  460.      Close(file);
  461.      ReCalcTreib();
  462.     }
  463.   }
  464.  
  465.  
  466.  
  467.  
  468.  
  469.  
  470. /*************************************************************************
  471.  *************************************************************************
  472.  *************************************************************************
  473.  
  474. Function: RemoveAll()
  475.  Clears all lists.
  476.  
  477. Return: VOID
  478.  
  479. Author: Rüdiger Dreier
  480.  
  481. History:
  482.  01.10.1993: Initial version
  483.  
  484.  *************************************************************************
  485.  *************************************************************************
  486.  *************************************************************************/
  487.  
  488.  VOID RemoveAll(VOID)
  489.   {
  490.    LONG max,i;
  491.    
  492.    
  493.    get(LI_Treib, MUIA_List_Entries, &max);
  494.    for(i=0;i<max;i++)
  495.     {
  496.      DoMethod(LI_Treib, MUIM_List_Remove, MUIV_List_Remove_First);
  497.     }
  498.    get(LI_Unter, MUIA_List_Entries, &max);
  499.    for(i=0;i<max;i++)
  500.     {
  501.      DoMethod(LI_Unter, MUIM_List_Remove, MUIV_List_Remove_First);
  502.     }
  503.   }
  504.  
  505. #define P(a) Write(File,a,strlen(a))
  506.  
  507.  char Buffer[3*MAXTEXTSTRING+200];
  508.  
  509.  
  510.  
  511.  
  512.  
  513. /*************************************************************************
  514.  *************************************************************************
  515.  *************************************************************************
  516.  
  517. Function: #PrintAll()
  518.  Prints the statistics.
  519.  
  520. Return: VOID
  521.  
  522. Author: Rüdiger Dreier
  523.  
  524. History:
  525.  23.12.1993: Output to a file possible
  526.  01.10.1993: Initial version
  527.  
  528.  *************************************************************************
  529.  *************************************************************************
  530.  *************************************************************************/
  531.  
  532.  VOID PrintAll(char *prtname)
  533.   {
  534.    BPTR File;
  535.    LONG Anzahl;
  536.    LONG i;
  537.    LONG j,k;
  538.    char buffer[MAXTEXTSTRING+1];
  539.    char buffer2[MAXTEXTSTRING+1];
  540.     
  541.    
  542.    ReCalcTreib();
  543.    
  544.    File = Open(prtname, MODE_NEWFILE);
  545.    if(File)
  546.     {
  547.      P(TitelString1);
  548.      P("\n");
  549.      P(TitelString2);
  550.      P("\n\n");
  551.      P(TEXT(MSG_FUEL_PRINT));
  552.      P("\n");
  553.      
  554.      get(LI_Treib, MUIA_List_Entries, &Anzahl);
  555.      
  556.      if(Anzahl > 0)
  557.       {
  558.        struct NodeTreib *node;
  559.        
  560.        P("\n");
  561.        P(TEXT(MSG_FUEL_TITLE));
  562.        P("\n ----------+----------+----------+----------+----------+----------");
  563.  
  564.        P("\n");
  565.        
  566.        for(i=0;i<Anzahl;i++)
  567.         {
  568.          DoMethod(LI_Treib, MUIM_List_GetEntry, i, &node);
  569.          FillTreib(node);
  570.          
  571.          sprintf(Buffer,"%10s | "FORMAT_KILOMETER" | "
  572.                         "%s | "FORMAT_LITER
  573.                         " | "FORMAT_PREIS
  574.                  " | "FORMAT_VERBRAUCH"\n",
  575.                  node->Datum,
  576.                  node->kmStand,
  577.                  node->deltakmstring,
  578.                  node->Liter,
  579.                  node->Preis,
  580.                  node->Verbrauch);
  581.          
  582.          P(Buffer);
  583.         }
  584.       }
  585.      else
  586.       {
  587.        P(TEXT(MSG_FUEL_NOFUEL));
  588.        P("\n");
  589.       }
  590.      
  591.     get(LI_Unter, MUIA_List_Entries, &Anzahl);
  592.      if(Anzahl > 0)
  593.       {
  594.        struct NodeUnter *node;
  595.        
  596.        P("\n\n");
  597.        P(TEXT(MSG_SUPPORT_PRINT));
  598.        P("\n");
  599.        P(TEXT(MSG_SUPPORT_TITLE));
  600.        P("\n ----------+---------------------------+---------------------------+---------\n");
  601.  
  602.      
  603.        for(i=0;i<Anzahl;i++)
  604.         {
  605.          DoMethod(LI_Unter, MUIM_List_GetEntry, i, &node);
  606.          j=0;
  607.          k=0;
  608.          
  609.          while((node->Titelstring)[j]    ==' ') j++;
  610.          while((node->Bemerkungstring)[k]==' ') k++;
  611.          
  612.          strcpy(buffer , &((node->Titelstring)[j]));
  613.          buffer[25] = 0;
  614.          strcpy(buffer2, &((node->Bemerkungstring)[k]));
  615.          buffer2[25] = 0;
  616.          
  617.          sprintf(Buffer,"%10s | %25s | %25s | "FORMAT_PREIS"\n",
  618.                  node->Datum,
  619.                  buffer,
  620.                  buffer2,
  621.                  node->Preis);
  622.          
  623.          P(Buffer);
  624.         }
  625.       }
  626.      else
  627.       {
  628.        P(TEXT(MSG_SUPPORT_NOSUPPORT));
  629.        P("\n");
  630.       }
  631.      
  632.      P("\n\n");
  633.      P(TEXT(MSG_PRINT_RESULT));
  634.      P("\n\n");
  635.      sprintf(Buffer,TEXT(MSG_PRINT_R1),
  636.              Start_KM,
  637.              Start_KM+Daten.Kilometer,
  638.              Daten.Kilometer);
  639.      P(Buffer);
  640.      P("\n");
  641.      sprintf(Buffer,TEXT(MSG_PRINT_R2),
  642.              Daten.Liter,
  643.              Daten.Liter*100/(Daten.Kilometer));
  644.      P(Buffer);
  645.      P("\n");
  646.      sprintf(Buffer,TEXT(MSG_PRINT_R3),
  647.              Daten.TreibGes,
  648.              Daten.TreibGes/Daten.Kilometer);
  649.      P(Buffer);
  650.      P("\n");
  651.      sprintf(Buffer,TEXT(MSG_PRINT_R4),
  652.              Daten.UnterGes,
  653.              Daten.UnterGes/Daten.Kilometer);
  654.      P(Buffer);
  655.      P("\n");
  656.      sprintf(Buffer,TEXT(MSG_PRINT_R5),
  657.              Daten.UnterGes+Daten.TreibGes,
  658.              (Daten.UnterGes+Daten.TreibGes)/Daten.Kilometer);
  659.      P(Buffer);
  660.      P("\n");
  661.      Close(File);
  662.     }
  663.    else
  664.     {
  665.      MUI_Request(App, WI_Cost, 0, NULL, 
  666.                  TEXT(MSG_ABOUT_OK_REQ),
  667.                  TEXT(MSG_PRINT_NOPRINTER),
  668.                  TAG_END);
  669.     }
  670.   }
  671.  
  672.  
  673.  
  674.  
  675.  
  676.  
  677. /*************************************************************************
  678.  *************************************************************************
  679.  *************************************************************************
  680.  
  681. Function: WriteMyIcon()
  682.  Adds an .info-file to the file >Name<. The icon is only added if:
  683.   - The program was started from workbench (the program's icon is used)
  684.   - If there is no icon for the file.
  685.  
  686. Return: VOID
  687.  
  688. Author: Rüdiger Dreier
  689.  
  690. History:
  691.  15.02.1993: Initial version
  692.  
  693.  *************************************************************************
  694.  *************************************************************************
  695.  *************************************************************************/
  696.  
  697.  VOID WriteMyIcon(char *Name,
  698.                   char *DefaultTool)
  699.   {
  700.    struct DiskObject *old;
  701.    
  702.    if(old = GetDiskObject(Name))
  703.     {
  704.      /* Icon schon vorhanden */
  705.      FreeDiskObject(old);
  706.      return;
  707.     }
  708.    
  709.    if(DiskObj)
  710.     {
  711.      struct DiskObject Obj;
  712.      
  713.      Obj                = *DiskObj;
  714.      Obj.do_Type        = WBPROJECT;
  715.      Obj.do_ToolTypes   = 0;
  716.      Obj.do_DefaultTool = DefaultTool;
  717.      Obj.do_CurrentX    = Obj.do_CurrentY = NO_ICON_POSITION;
  718.      PutDiskObject(Name, &Obj);
  719.     }
  720.   }
  721.  
  722.  
  723.  struct EasyStruct EasyS;
  724.  
  725.  
  726. /*************************************************************************
  727.  *************************************************************************
  728.  *************************************************************************
  729.  
  730. Function: ShowRequest2()
  731.  Displays a simple requester
  732.  
  733. Return: LONG, number of the selected button
  734.  
  735. Author: Rüdiger Dreier
  736.  
  737. History:
  738.  20.11.1991: Initial version
  739.  
  740.  *************************************************************************
  741.  *************************************************************************
  742.  *************************************************************************/
  743.  
  744.  LONG ShowRequest2(struct Window *Window,
  745.                    char *Title,
  746.                    char *Text, 
  747.                    char *GadgetText, 
  748.                    ...)
  749.   {
  750.    va_list ap;
  751.    
  752.    va_start(ap,GadgetText);
  753.    
  754.     {
  755.      EasyS.es_StructSize   = sizeof(EasyS);
  756.      EasyS.es_TextFormat   = Text;
  757.      EasyS.es_GadgetFormat = GadgetText;
  758.      EasyS.es_Title        = Title;
  759.      
  760.      return((SHORT)EasyRequestArgs(Window, &EasyS, NULL, (APTR) ap));
  761.      
  762.     }
  763.   }
  764.  
  765.  
  766.  
  767.  
  768.