#include "demo.h"
#define STRINGARRAY
#include "Daten.h" 
#include <proto/locale.h>
#include <stdarg.h>
 
 
 char Fehler[]="Error while opening >%s< version %ld !";
 char versionstring[]="\0$VER: CARCOSTS "VERSION" "DATE;
 
 
 extern struct WBStartup     *WBenchMsg;
 struct FileRequester        *Rq;
 struct DiskObject           *DiskObj;
 struct Library              *MUIMasterBase;
 struct Library              *LocaleBase;
 struct Library              *IconBase;
 struct IntuitionBase        *IntuitionBase;
 struct Catalog              *mycat;
 struct RDArgs               *RArgsResult;
 struct Daten                 Daten;
 
 char Version[80];
 char WTitel[80];
 char Dir[150];
 char FileName[300];
 char PrtName[300];
 char TitelString1[100];
 char TitelString2[100];
 
 char Start_Kennzeichen[20];
 char Start_Datum[20];
 LONG Start_Day;
 LONG Start_KM;
 LONG Start_Format=FORMAT_DOS;
 
 
 
#ifdef __SASC
 int CXBRK(void) 
  {
   return(0);
  }
 int _CXBRK(void) 
  {
   return(0);
  }
 void chkabort(void) 
  {
  }
#endif
 
 LONG __stack = 8192;
 
 
 
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: main()
 Main function of CarCosts. Opens all libraries, copies the catalog strings,
 copies the menu items, checks if there is an argument (from shell or 
 workbench) and calls the main loop.

Return: VOID

Author: Rüdiger Dreier

History:
 01.10.1993: Initial version

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
VOID __stdargs __main(char *line)
  {
   LONG i;
   LONG array[2]=
    {
     0,0
    };
   char *temp="FILE";
   char *file=0;
   
   if(IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",
                                                           37L))
    {
     if(!(IconBase = OpenLibrary("icon.library",
                                 37L)))
      {
       ShowRequest2(0, "Error", Fehler, "OK","icon.library",37L);
      }
     else
      {
       if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
        {
         ShowRequest2(0, "Error", Fehler, "OK","MUIMaster.library",
                      MUIMASTER_VMIN);
        }
       else
        {
         /* Hier Catalog öffnen und eventuell AppStrings umbiegen */
         if(LocaleBase = OpenLibrary("locale.library",38L))
          {
           if(mycat = OpenCatalog(NULL, "carcost.catalog",
                                  OC_BuiltInLanguage,"deutsch",
                                  TAG_DONE))
            {
             char *string;
             for(i=0;i<=MAXLOCALE;i++)
              {
               string = GetCatalogStr(mycat, i, AppStrings[i].as_Str);
               if(string) AppStrings[i].as_Str = string;
              }
            }
          }
         i=0;
         while(NewMenu[i].nm_Label)
          {
           LONG number;
           if(NewMenu[i].nm_Label != NM_BARLABEL) 
            {
             number = (LONG)NewMenu[i].nm_Label;
             NewMenu[i].nm_Label = &TEXT(number)[2];
             if(TEXT(number)[0] != ' ')
              {
               NewMenu[i].nm_CommKey = TEXT(number);
              }
            }
           i++;
          }
         if(!LocaleBase) Formate[4]=0; /* Kein locale */
         
         sprintf(WTitel,"%s (c) by Rüdiger Dreier",TEXT(MSG_PROGNAME));
         sprintf(Version, "$%s: %s Version "VERSION" "DATE,"VER",TEXT(MSG_PROGNAME));
         
         if(line)
          {
           /* Von der Shell aus gestartet */
           RArgsResult = ReadArgs(temp, array, 0);
           
           file = (char *)array[0];
           if(file)
            {
             char help[6];
             strcpy(FileName,file);
             if(strlen(file) > 4)
              {
               strcpy(help, &file[strlen(file)-4]);
               if(strcmpi(help,TEXT(MSG_EXTENSION)))
                {
                 strcat(FileName,TEXT(MSG_EXTENSION));
                }
              }
             else
              {
               strcat(FileName,TEXT(MSG_EXTENSION));
              }
            }
          }
         
         if(WBenchMsg && WBenchMsg->sm_NumArgs >1)
          {
     /* Funktion: Name des Verzeichnisses besorgen und Namen */
     /* zusammenstellen                                      */
           
           struct WBArg *arg;
           
           arg     = WBenchMsg->sm_ArgList;
           NameFromLock(arg[1].wa_Lock, FileName,300);
           AddPart(FileName, arg[1].wa_Name, 300);
          }
         
         if(WBenchMsg)
          {
           /* Es wurde von Workbench gestartet */
           DiskObj = GetDiskObject(WBenchMsg->sm_ArgList->wa_Name);
          }
         if(MyInit())
          {
           ReCalcTreib();
           Rq = MUI_AllocAslRequest(ASL_FileRequest,TAG_DONE);
           if(Rq)
            {
             
             if(FileName[0]) 
              {
               RemoveAll();
               InsertAll(FileName);
              }
             Loop();
             
             MUI_FreeAslRequest(Rq);
            }
          }
         
         if(RArgsResult)      FreeArgs(RArgsResult);
         
         /* Catalog wieder schließen, falls offen */
         if(mycat) CloseCatalog(mycat);
         if(LocaleBase) CloseLibrary(LocaleBase);
         
         if(DiskObj) FreeDiskObject(DiskObj);
         if (App) MUI_DisposeObject(App);
         
         CloseLibrary(MUIMasterBase);
        }
       CloseLibrary(IconBase);
      }
     CloseLibrary((struct Library *)IntuitionBase);
    }
  }
 
 
 
 
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: SaveAll()
 Saves all data to the file >filename<. The data is saved as ASCII
 
Return: VOID

Author: Rüdiger Dreier

History:
 01.10.1993: Initial version
 07.01.1995: Larger buffers 

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
 VOID SaveAll(char *filename)
  {
   BPTR file;
   LONG max,i,j,k;
   char buffer[3*MAXTEXTSTRING+100]; // DAS sollte jetzt aber reichen...
   
   ReCalcTreib();
   
   if(Start_Kennzeichen[strlen(Start_Kennzeichen)-1]==0x0a)
    {
     Start_Kennzeichen[strlen(Start_Kennzeichen)-1] = 0;
    }
   
   file = Open(filename, MODE_NEWFILE);
   if(file)
    {
     sprintf(buffer,"#\n%s %8ld %8ld %3ld\n%s\n#\n",
             Start_Datum,
             Start_Day,
             Start_KM,
             Start_Format,
             Start_Kennzeichen);
     FPuts(file, buffer);
     
     get(LI_Treib, MUIA_List_Entries, &max);
     
     for(i=0;i<max;i++)
      {
       struct NodeTreib *nw;
       
       DoMethod(LI_Treib, MUIM_List_GetEntry, i, &nw);
       
       sprintf(buffer,
               "%s %8ld "FORMAT_KILOMETER" "FORMAT_LITER" "FORMAT_PREIS"\n",
               nw->Datum,
               nw->Days,
               nw->kmStand,
               nw->Liter,
               nw->Preis);
       FPuts(file,buffer);
      }
     FPuts(file,"#\n");
     
     get(LI_Unter, MUIA_List_Entries, &max);
     
     for(i=0;i<max;i++)
      {
       struct NodeUnter *nw;
       DoMethod(LI_Unter, MUIM_List_GetEntry, i, &nw);
       
       /* Leerzeichen übergehen */
       j=0;
       k=0;
       while(nw->Titelstring[j]==' ') j++;
       while(nw->Bemerkungstring[k]==' ') k++;
       
       sprintf(buffer,"%s %8ld "FORMAT_PREIS"\n%s\n%s\n",
               nw->Datum, nw->Days,
               nw->Preis,
               &nw->Titelstring[j],
               &nw->Bemerkungstring[k]);
       FPuts(file,buffer);
      }
     FPuts(file,"#\n");
     Close(file);
    }
  }
 
 
 
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: InsertAll()
 Inserts the file >filename< in the list

Return: VOID

Author: Rüdiger Dreier

History:
 01.10.1993: Initial version
 07.01.1995: Larger buffers

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
 VOID InsertAll(char *filename)
  {
   BPTR file;
   char *t,*tt;
   char buffer[3*MAXTEXTSTRING+100];
   char buffer2[3*MAXTEXTSTRING+50];
   LONG lastkm;
   
   buffer[0]=0;
   
   file=Open(filename, MODE_OLDFILE);
   if(file)
    {
     t=FGets(file,buffer,99L);
     if(strcmp(buffer,"#\n")==0)
      {
       t=FGets(file,buffer,3*MAXTEXTSTRING);
       if(buffer)
        {
         sscanf(buffer,"%s %ld %ld %ld",
                Start_Datum, 
                &Start_Day, 
                &Start_KM,
                &Start_Format);
        ConvertToString(Start_Day, Start_Datum);
         FGets(file, buffer, 19L);
         if(buffer)
          {
           strcpy(Start_Kennzeichen, buffer);
           //printf("Kennzeichen >%s<\n",Start_Kennzeichen);
           if(Start_Kennzeichen[strlen(Start_Kennzeichen)-1]==0x0a)
            {
             Start_Kennzeichen[strlen(Start_Kennzeichen)-1] = 0;
            }
           //printf("Kennzeichen >%s<\n",Start_Kennzeichen);
           
           //sscanf(buffer,"%s",Start_Kennzeichen);
           lastkm = Start_KM;
           
           t=FGets(file, buffer, 3*MAXTEXTSTRING);
           if(buffer[0]=='#')
            {
             while(t)
              {
               struct NodeTreib nw,*w=&nw;
               
               t = FGets(file,buffer,3*MAXTEXTSTRING);
               if(t)
                {
                 if(strcmp(buffer,"#\n")==0)
                  {
                   t=0;
                  }
                 else
                  {
                   /* String auslesen, neuer Eintrag */  
                   sscanf(buffer,"%s %ld %ld %lf %lf", buffer2,
                          &nw.Days,
                          &nw.kmStand,
                          &nw.Liter,
                          &nw.Preis);
                   nw.deltakm   = nw.kmStand - lastkm;
                   lastkm       = nw.kmStand;
                   /* Division durch NULL abfangen */
                   if(nw.deltakm != 0) 
                   {
                        nw.Verbrauch = 100.*nw.Liter / nw.deltakm;
                   } else {
                        nw.Verbrauch = 0.00;
                   }
                   //ConvertToString(nw.Days, nw.Datum);
                   
                   FillTreib(&nw);
                   
                   DoMethod(LI_Treib, MUIM_List_Insert, 
                            &w, 1L, MUIV_List_Insert_Sorted);
                   
                  }
                }
              }
          
             do
              {
               struct NodeUnter nw,*w=&nw;
               
               t = FGets(file,buffer,3*MAXTEXTSTRING);
               if(t && buffer[0]!='#')
                {
                 /* String auslesen, neuer Eintrag */  
                 sscanf(buffer,"%s %ld %lf", buffer2,
                        &nw.Days,&nw.Preis);
                 
                 nw.Bemerkungstring[0]=0;
                 nw.Titelstring[0]=0;
                 
                 tt=FGets(file, buffer, 3*MAXTEXTSTRING);
                 if(tt)
                  {
                   buffer[strlen(buffer)-1] = 0;
                   sprintf(nw.Titelstring, FORMAT_TITEL, buffer);
                   strcpy(buffer, nw.Titelstring);
                   buffer[MAX_TITEL] = 0;
                   strcpy(nw.DispTitel, buffer);
                   
                   tt=FGets(file, buffer, 3*MAXTEXTSTRING);
                   if(tt)
                    {
                     buffer[strlen(buffer)-1] = 0;
                     sprintf(nw.Bemerkungstring, FORMAT_BEMERKUNG, buffer);
                     strcpy(buffer, nw.Bemerkungstring);
                     buffer[MAX_REM] = 0;
                     strcpy(nw.DispRem, buffer);
                    }
                  }
                  FillUnter(&nw);
                 //ConvertToString(nw.Days, nw.Datum);
                 DoMethod(LI_Unter, MUIM_List_Insert, 
                          &w, 1L, MUIV_List_Insert_Sorted);
                } else {
                  t = 0;
                }
              }
             while(t);
            }
          }
        }
      }
     Close(file);
     ReCalcTreib();
    }
  }
 
 
 
 
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: RemoveAll()
 Clears all lists.

Return: VOID

Author: Rüdiger Dreier

History:
 01.10.1993: Initial version

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
 VOID RemoveAll(VOID)
  {
   LONG max,i;
   
   
   get(LI_Treib, MUIA_List_Entries, &max);
   for(i=0;i<max;i++)
    {
     DoMethod(LI_Treib, MUIM_List_Remove, MUIV_List_Remove_First);
    }
   get(LI_Unter, MUIA_List_Entries, &max);
   for(i=0;i<max;i++)
    {
     DoMethod(LI_Unter, MUIM_List_Remove, MUIV_List_Remove_First);
    }
  }
 
#define P(a) Write(File,a,strlen(a))
 
 char Buffer[3*MAXTEXTSTRING+200];
 
 
 
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: #PrintAll()
 Prints the statistics.

Return: VOID

Author: Rüdiger Dreier

History:
 23.12.1993: Output to a file possible
 01.10.1993: Initial version

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
 VOID PrintAll(char *prtname)
  {
   BPTR File;
   LONG Anzahl;
   LONG i;
   LONG j,k;
   char buffer[MAXTEXTSTRING+1];
   char buffer2[MAXTEXTSTRING+1];
    
   
   ReCalcTreib();
   
   File = Open(prtname, MODE_NEWFILE);
   if(File)
    {
     P(TitelString1);
     P("\n");
     P(TitelString2);
     P("\n\n");
     P(TEXT(MSG_FUEL_PRINT));
     P("\n");
     
     get(LI_Treib, MUIA_List_Entries, &Anzahl);
     
     if(Anzahl > 0)
      {
       struct NodeTreib *node;
       
       P("\n");
       P(TEXT(MSG_FUEL_TITLE));
       P("\n ----------+----------+----------+----------+----------+----------");

       P("\n");
       
       for(i=0;i<Anzahl;i++)
        {
         DoMethod(LI_Treib, MUIM_List_GetEntry, i, &node);
         FillTreib(node);
         
         sprintf(Buffer,"%10s | "FORMAT_KILOMETER" | "
                        "%s | "FORMAT_LITER
                        " | "FORMAT_PREIS
                 " | "FORMAT_VERBRAUCH"\n",
                 node->Datum,
                 node->kmStand,
                 node->deltakmstring,
                 node->Liter,
                 node->Preis,
                 node->Verbrauch);
         
         P(Buffer);
        }
      }
     else
      {
       P(TEXT(MSG_FUEL_NOFUEL));
       P("\n");
      }
     
    get(LI_Unter, MUIA_List_Entries, &Anzahl);
     if(Anzahl > 0)
      {
       struct NodeUnter *node;
       
       P("\n\n");
       P(TEXT(MSG_SUPPORT_PRINT));
       P("\n");
       P(TEXT(MSG_SUPPORT_TITLE));
       P("\n ----------+---------------------------+---------------------------+---------\n");

     
       for(i=0;i<Anzahl;i++)
        {
         DoMethod(LI_Unter, MUIM_List_GetEntry, i, &node);
         j=0;
         k=0;
         
         while((node->Titelstring)[j]    ==' ') j++;
         while((node->Bemerkungstring)[k]==' ') k++;
         
         strcpy(buffer , &((node->Titelstring)[j]));
         buffer[25] = 0;
         strcpy(buffer2, &((node->Bemerkungstring)[k]));
         buffer2[25] = 0;
         
         sprintf(Buffer,"%10s | %25s | %25s | "FORMAT_PREIS"\n",
                 node->Datum,
                 buffer,
                 buffer2,
                 node->Preis);
         
         P(Buffer);
        }
      }
     else
      {
       P(TEXT(MSG_SUPPORT_NOSUPPORT));
       P("\n");
      }
     
     P("\n\n");
     P(TEXT(MSG_PRINT_RESULT));
     P("\n\n");
     sprintf(Buffer,TEXT(MSG_PRINT_R1),
             Start_KM,
             Start_KM+Daten.Kilometer,
             Daten.Kilometer);
     P(Buffer);
     P("\n");
     sprintf(Buffer,TEXT(MSG_PRINT_R2),
             Daten.Liter,
             Daten.Liter*100/(Daten.Kilometer));
     P(Buffer);
     P("\n");
     sprintf(Buffer,TEXT(MSG_PRINT_R3),
             Daten.TreibGes,
             Daten.TreibGes/Daten.Kilometer);
     P(Buffer);
     P("\n");
     sprintf(Buffer,TEXT(MSG_PRINT_R4),
             Daten.UnterGes,
             Daten.UnterGes/Daten.Kilometer);
     P(Buffer);
     P("\n");
     sprintf(Buffer,TEXT(MSG_PRINT_R5),
             Daten.UnterGes+Daten.TreibGes,
             (Daten.UnterGes+Daten.TreibGes)/Daten.Kilometer);
     P(Buffer);
     P("\n");
     Close(File);
    }
   else
    {
     MUI_Request(App, WI_Cost, 0, NULL, 
                 TEXT(MSG_ABOUT_OK_REQ),
                 TEXT(MSG_PRINT_NOPRINTER),
                 TAG_END);
    }
  }
 
 
 
 
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: WriteMyIcon()
 Adds an .info-file to the file >Name<. The icon is only added if:
  - The program was started from workbench (the program's icon is used)
  - If there is no icon for the file.

Return: VOID

Author: Rüdiger Dreier

History:
 15.02.1993: Initial version

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
 VOID WriteMyIcon(char *Name,
                  char *DefaultTool)
  {
   struct DiskObject *old;
   
   if(old = GetDiskObject(Name))
    {
     /* Icon schon vorhanden */
     FreeDiskObject(old);
     return;
    }
   
   if(DiskObj)
    {
     struct DiskObject Obj;
     
     Obj                = *DiskObj;
     Obj.do_Type        = WBPROJECT;
     Obj.do_ToolTypes   = 0;
     Obj.do_DefaultTool = DefaultTool;
     Obj.do_CurrentX    = Obj.do_CurrentY = NO_ICON_POSITION;
     PutDiskObject(Name, &Obj);
    }
  }
 
 
 struct EasyStruct EasyS;
 
 
/*************************************************************************
 *************************************************************************
 *************************************************************************

Function: ShowRequest2()
 Displays a simple requester

Return: LONG, number of the selected button

Author: Rüdiger Dreier

History:
 20.11.1991: Initial version

 *************************************************************************
 *************************************************************************
 *************************************************************************/
 
 LONG ShowRequest2(struct Window *Window,
                   char *Title,
                   char *Text, 
                   char *GadgetText, 
                   ...)
  {
   va_list ap;
   
   va_start(ap,GadgetText);
   
    {
     EasyS.es_StructSize   = sizeof(EasyS);
     EasyS.es_TextFormat   = Text;
     EasyS.es_GadgetFormat = GadgetText;
     EasyS.es_Title        = Title;
     
     return((SHORT)EasyRequestArgs(Window, &EasyS, NULL, (APTR) ap));
     
    }
  }