home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / dev / gui / GenCodeC2_2d.lha / GenCodeC2.2d / source / GenCodeCMain.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-22  |  11.4 KB  |  483 lines
  1. /* Main-Header File inserted by GenCodeC */
  2. /* Libraries */
  3. #include <libraries/mui.h>
  4. #include <libraries/gadtools.h> /* for BARLABEL in MenuItem */
  5.  
  6. /* Prototypes */
  7. #ifdef __SASC
  8. #include <clib/muimaster_protos.h>
  9. #include <clib/exec_protos.h>
  10. #include <clib/alib_protos.h>
  11. #include <clib/dos_protos.h>
  12. #else
  13. #include <proto/muimaster.h>
  14. #include <proto/exec.h>
  15. #include <proto/alib.h>
  16. #include <proto/dos.h>
  17. #endif
  18.  
  19. /*  Pragmas  */
  20. #include <pragmas/muimaster_pragmas.h>
  21. #include <pragmas/textfield_pragmas.h>
  22. #include "MB_pragmas.h"
  23.  
  24. /*  Ansi  */
  25. #include <stdlib.h>
  26. #include <stdio.h>
  27. /* GenCodeC header end */
  28.  
  29. /* Include generated by GenCodeC */
  30.  
  31. #include "GenCodeCGUI.h"
  32.  
  33. #include <exec/memory.h>
  34. #include <string.h>
  35.  
  36. #include "TextField.h"
  37. #include "Tools.h"
  38. #include "GenCodeC.h"
  39. #include "MB.h"
  40.  
  41. /* defines for header file */
  42. #define  HHEADER     1
  43. #define  CHEADER     2
  44. #define  MAINHEADER  3
  45.  
  46. #define  LOCALSAVE   1
  47. #define  GLOBALSAVE  2
  48.  
  49. /* Global variables */
  50. BOOL    TextFieldLocked = FALSE;
  51. BOOL    NormalEnd = FALSE;
  52.  
  53. struct ObjTextField    *TF_H_Header = NULL;
  54. struct ObjTextField    *TF_C_Header =  NULL;
  55. struct ObjTextField    *TF_Main_Header = NULL;
  56.  
  57. char     *H_Header_Text;
  58. char     *C_Header_Text;
  59. char     *Main_Header_Text;
  60.  
  61. /* Declarations for libraries (inserted by GenCodeC) */
  62. struct Library * MUIMasterBase;
  63.  
  64. struct Library * IntuitionBase = NULL;
  65. struct Library * MUIBBase      = NULL;
  66. struct Library * TextFieldBase = NULL;
  67.  
  68. /* Init() function */
  69. void init( void )
  70. {
  71.     if (!(IntuitionBase = OpenLibrary("intuition.library",36)))
  72.     {
  73.         exit(20);
  74.     }
  75.  
  76.     if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
  77.     {
  78.         DisplayMsg("Can't Open MUIMaster Library\n");
  79.         CloseLibrary(IntuitionBase);
  80.         exit(20);
  81.     }
  82.  
  83.     if (!(MUIBBase = OpenLibrary("muibuilder.library", 0)))
  84.     {
  85.         DisplayMsg("Can't Open MUIBuilder Library\n");
  86.         CloseLibrary(MUIMasterBase);
  87.         CloseLibrary(IntuitionBase);
  88.         exit(20);
  89.     }
  90.  
  91.     /* exit if we cant init the Library */
  92.     if (!MB_Open())
  93.     {
  94.         DisplayMsg("Unable to Get Temporary files !\n");
  95.         CloseLibrary(MUIBBase);
  96.         CloseLibrary(MUIMasterBase);
  97.         CloseLibrary(IntuitionBase);
  98.         exit(20);
  99.     }
  100.  
  101.     if (!(TextFieldBase = OpenLibrary("gadgets/textfield.gadget", 0)))
  102.     {
  103.         DisplayMsg("Can't Open Textfield gadget\n");
  104.         MB_Close();
  105.         CloseLibrary(MUIBBase);
  106.         CloseLibrary(MUIMasterBase);
  107.         CloseLibrary(IntuitionBase);
  108.         exit(20);
  109.     }
  110. }
  111. /* GenCodeC init() end */
  112.  
  113. void UnlockTextFieldTexts(struct ObjTextField *,char *,struct ObjTextField *,char *,struct ObjTextField *,char *);
  114.  
  115. /* End() function */
  116. void end(void *ptr_void)
  117. {
  118.     struct ObjApp *app=(struct ObjApp *)ptr_void;
  119.  
  120.     MB_Close();    /* Free Memory and Close Temporary Files */
  121.  
  122.     if (app)
  123.     {
  124.         set(app->WI_C_Generation,
  125.             MUIA_Window_Open, FALSE);
  126.  
  127.         if (TextFieldLocked)
  128.             UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  129.                              TF_C_Header,C_Header_Text,
  130.                              TF_Main_Header,Main_Header_Text);
  131.  
  132.         if (TF_H_Header && TF_H_Header->textfield)
  133.             DoMethod(app->GR_H_Header, OM_REMOVE, TF_H_Header->textfield);
  134.  
  135.         if (TF_C_Header && TF_C_Header->textfield)
  136.             DoMethod(app->GR_C_Header, OM_REMOVE, TF_C_Header->textfield);
  137.  
  138.         if (TF_Main_Header && TF_Main_Header->textfield)
  139.             DoMethod(app->GR_Main_Header, OM_REMOVE, TF_Main_Header->textfield);
  140.  
  141.         DisposeTextField(TF_H_Header);
  142.         DisposeTextField(TF_C_Header);
  143.         DisposeTextField(TF_Main_Header);
  144.  
  145.         DisposeApp(app);
  146.     }
  147.  
  148.     CloseAllFiles(!NormalEnd);
  149.     ClearMemory(!NormalEnd);
  150.  
  151.     CloseLibrary(TextFieldBase);
  152.     CloseLibrary(MUIBBase);
  153.     CloseLibrary(MUIMasterBase);
  154.     CloseLibrary(IntuitionBase);
  155.     exit(20);
  156. }
  157. /* GenCodeC end() end */
  158.  
  159. /* Read a header file and load it in memory */
  160. char *LoadHeaderFile(int HeaderFile)
  161. {
  162.     char  *TMPFile;
  163.     char  *HF;
  164.     int   size;
  165.     char  *MBDir=NULL;
  166.     char  *FileName;
  167.     
  168.     MB_Get(MUIB_FileName,&FileName,TAG_END);
  169.     
  170.     /* Get Current Directory Name */
  171.     MBDir = GetCurrentDirectory();
  172.       
  173.     size = strlen(MBDir)+1+9+1+strlen(FilePart(FileName))+12+1;
  174.     TMPFile = AllocMemory(size,TRUE);
  175.  
  176.     /* Try to read local header and if there is no local header, try to read global header */
  177.     strcpy(TMPFile,MBDir);
  178.     AddPart(TMPFile,"C_Headers",size);
  179.     AddPart(TMPFile,FilePart(FileName),size);
  180.     remove_extend(TMPFile);
  181.     switch(HeaderFile)
  182.     {
  183.         case HHEADER:
  184.             add_extend(TMPFile,".H-Header");
  185.             break;
  186.             
  187.         case CHEADER:
  188.             add_extend(TMPFile,".C-Header");
  189.             break;
  190.             
  191.         case MAINHEADER:
  192.             add_extend(TMPFile,".Main-Header");
  193.             break;
  194.     }
  195.     if (!(HF = LoadFileInRAM(TMPFile,FALSE)))
  196.     {
  197.         FreeMemory(TMPFile);
  198.         size = strlen(MBDir)+1+9+1+12+1;
  199.         TMPFile = AllocMemory(size,FALSE);
  200.  
  201.         strcpy(TMPFile,MBDir);
  202.         AddPart(TMPFile,"C_Headers",size);
  203.         switch(HeaderFile)
  204.         {
  205.             case HHEADER:
  206.                 AddPart(TMPFile,"H-Header",size);
  207.                 break;
  208.                     
  209.             case CHEADER:
  210.                 AddPart(TMPFile,"C-Header",size);
  211.                 break;
  212.                     
  213.             case MAINHEADER:
  214.                 AddPart(TMPFile,"Main-Header",size);
  215.                 break;
  216.         }
  217.         if (!(HF = LoadFileInRAM(TMPFile,FALSE)))
  218.         {
  219.             DisplayMsg("Can't open Header file !!!");
  220.         }
  221.         FreeMemory(MBDir);
  222.         FreeMemory(TMPFile);
  223.         return HF;
  224.     }
  225.     else
  226.     {
  227.         FreeMemory(MBDir);
  228.         FreeMemory(TMPFile);
  229.         return HF;
  230.     }
  231. }
  232.  
  233. /* Save a header file */
  234. void SaveHeaderFile(int HeaderFile,char *HeaderText,int PrefsSave)
  235. {
  236.     char  *TMPFile;
  237.     int   size;
  238.     char  *MBDir = NULL;
  239.     char  *FileName;
  240.     BOOL  Prefs = (PrefsSave==LOCALSAVE);
  241.     BPTR  file;
  242.     
  243.     MB_Get(MUIB_FileName,&FileName,TAG_END);
  244.     
  245.     /* Get Current Directory Name */
  246.     MBDir = GetCurrentDirectory();
  247.       
  248.     size = strlen(MBDir)+1+9+((Prefs) ? (1+strlen(FilePart(FileName))):1)+12+1;
  249.     if (!(TMPFile = AllocMemory(size,FALSE)))
  250.     {
  251.         FreeMemory(MBDir);
  252.         DisplayMsg("Can't save Header file !!! \n");
  253.         return;
  254.     }
  255.     else
  256.     {
  257.         strcpy(TMPFile,MBDir);
  258.         AddPart(TMPFile,"C_Headers",size);
  259.         if (Prefs)
  260.         {
  261.             AddPart(TMPFile,FilePart(FileName),size);
  262.             remove_extend(TMPFile);
  263.         }
  264.         switch(HeaderFile)
  265.         {
  266.             case HHEADER:
  267.                 (Prefs) ? add_extend(TMPFile,".H-Header") : AddPart(TMPFile,"H-Header",size);
  268.                 break;
  269.             
  270.             case CHEADER:
  271.                 (Prefs) ? add_extend(TMPFile,".C-Header") : AddPart(TMPFile,"C-Header",size);
  272.                 break;
  273.             
  274.             case MAINHEADER:
  275.                 (Prefs) ? add_extend(TMPFile,".Main-Header") : AddPart(TMPFile,"Main-Header",size);
  276.                 break;
  277.         }
  278.         if (file = OpenFile(TMPFile, MODE_NEWFILE, FALSE))
  279.         {
  280.             FreeMemory(MBDir);
  281.             FreeMemory(TMPFile);
  282.             FWrite(file,HeaderText,strlen(HeaderText),1);
  283.             CloseFile(file);
  284.         }
  285.         else
  286.         {
  287.             DisplayMsg("Can't save Header file !!! \n");
  288.         }
  289.     }
  290. }
  291.  
  292. void CreateTextFieldObjects(struct ObjApp *App,
  293.                             struct ObjTextField **TF_H_Header,
  294.                             struct ObjTextField **TF_C_Header,
  295.                             struct ObjTextField **TF_Main_Header)
  296. {
  297.     char  *HeaderText;
  298.     
  299.     if (!(*TF_H_Header = CreateTextField()))
  300.     {
  301.         DisplayMsg("Can't Create Textfield object\n");
  302.         end((void *)App);
  303.     }
  304.     DoMethod(App->GR_H_Header, OM_ADDMEMBER, (*TF_H_Header)->textfield);
  305.     HeaderText = LoadHeaderFile(HHEADER);
  306.     if (HeaderText)
  307.     {
  308.         set((*TF_H_Header)->text,TEXTFIELD_Text,HeaderText);
  309.         FreeMemory(HeaderText);
  310.     }
  311.     
  312.     if (!(*TF_C_Header = CreateTextField()))
  313.     {
  314.         DisplayMsg("Can't Create Textfield object\n");
  315.         end((void *)App);
  316.     }
  317.     DoMethod(App->GR_C_Header, OM_ADDMEMBER, (*TF_C_Header)->textfield);
  318.     HeaderText = LoadHeaderFile(CHEADER);
  319.     if (HeaderText)
  320.     {
  321.         set((*TF_C_Header)->text,TEXTFIELD_Text,HeaderText);
  322.         FreeMemory(HeaderText);
  323.     }
  324.     
  325.     if (!(*TF_Main_Header = CreateTextField()))
  326.     {
  327.         DisplayMsg("Can't Create Textfield object\n");
  328.         end((void *)App);
  329.     }
  330.     DoMethod(App->GR_Main_Header, OM_ADDMEMBER, (*TF_Main_Header)->textfield);
  331.     HeaderText = LoadHeaderFile(MAINHEADER);
  332.     if (HeaderText)
  333.     {
  334.         set((*TF_Main_Header)->text,TEXTFIELD_Text,HeaderText);
  335.         FreeMemory(HeaderText);
  336.     }
  337. }
  338.  
  339. void LockTextFieldTexts(struct ObjApp *App,
  340.                         struct ObjTextField *TF_H_Header,char **H_Header_Text,
  341.                         struct ObjTextField *TF_C_Header,char **C_Header_Text,
  342.                         struct ObjTextField *TF_Main_Header,char **Main_Header_Text)
  343. {
  344.     char    *text;
  345.     ULONG    size;
  346.     
  347.     set(TF_H_Header->text,TEXTFIELD_ReadOnly,TRUE);
  348.     set(TF_C_Header->text,TEXTFIELD_ReadOnly,TRUE);
  349.     set(TF_Main_Header->text,TEXTFIELD_ReadOnly,TRUE);
  350.     
  351.     get(TF_H_Header->text,TEXTFIELD_Size,&size);
  352.     get(TF_H_Header->text,TEXTFIELD_Text,&text);
  353.     *H_Header_Text = AllocMemory(size+1,TRUE);
  354.     strncpy(*H_Header_Text,text,size);
  355.     (*H_Header_Text)[size]='\0';
  356.  
  357.     get(TF_C_Header->text,TEXTFIELD_Size,&size);
  358.     get(TF_C_Header->text,TEXTFIELD_Text,&text);
  359.     *C_Header_Text = AllocMemory(size+1,TRUE);
  360.     strncpy(*C_Header_Text,text,size);
  361.     (*C_Header_Text)[size]='\0';
  362.     
  363.     get(TF_Main_Header->text,TEXTFIELD_Size,&size);
  364.     get(TF_Main_Header->text,TEXTFIELD_Text,&text);
  365.     *Main_Header_Text = AllocMemory(size+1,TRUE);
  366.     strncpy(*Main_Header_Text,text,size);
  367.     (*Main_Header_Text)[size]='\0';
  368.  
  369.     TextFieldLocked = TRUE;
  370. }
  371.  
  372. void UnlockTextFieldTexts(struct ObjTextField *TF_H_Header,char *H_Header_Text,
  373.                             struct ObjTextField *TF_C_Header,char *C_Header_Text,
  374.                             struct ObjTextField *TF_Main_Header,char *Main_Header_Text)
  375. {
  376.     set(TF_H_Header->text,TEXTFIELD_ReadOnly,FALSE);
  377.     set(TF_C_Header->text,TEXTFIELD_ReadOnly,FALSE);
  378.     set(TF_Main_Header->text,TEXTFIELD_ReadOnly,FALSE);
  379.  
  380.     FreeMemory(H_Header_Text);
  381.     FreeMemory(C_Header_Text);
  382.     FreeMemory(Main_Header_Text);
  383.  
  384.     TextFieldLocked = FALSE;
  385. }
  386.  
  387. /* Main Function inserted by GenCodeC */
  388. int main(int argc,char **argv)
  389. {
  390.     struct ObjApp    *App = NULL; /* Object */
  391.     BOOL            running = TRUE;
  392.     ULONG            signal;
  393.     BOOL            Locale;
  394.  
  395.     /* Program initialisation : generated by GenCodeC */
  396.     init();
  397.     
  398.     /* Create Object : generated by GenCodeC */
  399.     if (!(App = CreateApp()))
  400.     {
  401.         DisplayMsg("Can't Create App\n");
  402.         end((void *)App);
  403.     }
  404.  
  405.     SetDataQuit((void *)App);
  406.     SetFunctionQuit(end);    
  407.  
  408.     CreateTextFieldObjects(App,&TF_H_Header,&TF_C_Header,&TF_Main_Header);
  409.     
  410.     MB_Get(MUIB_Locale,&Locale,TAG_DONE);
  411.     if (!Locale)
  412.         set(App->GR_Catalog,MUIA_ShowMe,FALSE);
  413.     
  414.     set(App->WI_C_Generation,
  415.         MUIA_Window_Open, TRUE
  416.         );
  417.     
  418.     while (running)
  419.     {
  420.         switch (DoMethod(App->App,MUIM_Application_Input,&signal))
  421.         {
  422.             case MUIV_Application_ReturnID_Quit:
  423.             running = FALSE;
  424.             break;
  425.             
  426.             /* Insert your code between the "case" statement and comment "end of case ..." */
  427.             case ID_BT_SAVE_LOCAL:
  428.             {
  429.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  430.                                        TF_C_Header,&C_Header_Text,
  431.                                        TF_Main_Header,&Main_Header_Text);
  432.                     
  433.                 SaveHeaderFile(HHEADER,H_Header_Text,LOCALSAVE);
  434.                 SaveHeaderFile(CHEADER,C_Header_Text,LOCALSAVE);
  435.                 SaveHeaderFile(MAINHEADER,Main_Header_Text,LOCALSAVE);
  436.                     
  437.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  438.                                      TF_C_Header,C_Header_Text,
  439.                                      TF_Main_Header,Main_Header_Text);
  440.             }
  441.             break;
  442.             /* end of case ID_BT_SAVE_LOCAL */
  443.  
  444.             case ID_BT_SAVE_GLOBAL:
  445.             {
  446.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  447.                                        TF_C_Header,&C_Header_Text,
  448.                                        TF_Main_Header,&Main_Header_Text);
  449.                     
  450.                 SaveHeaderFile(HHEADER,H_Header_Text,GLOBALSAVE);
  451.                 SaveHeaderFile(CHEADER,C_Header_Text,GLOBALSAVE);
  452.                 SaveHeaderFile(MAINHEADER,Main_Header_Text,GLOBALSAVE);
  453.  
  454.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  455.                                      TF_C_Header,C_Header_Text,
  456.                                      TF_Main_Header,Main_Header_Text);
  457.             }
  458.             break;
  459.             /* end of case ID_BT_SAVE_GLOBAL */
  460.  
  461.             case ID_BT_GENERATE:
  462.             {
  463.                 LockTextFieldTexts(App,TF_H_Header,&H_Header_Text,
  464.                                        TF_C_Header,&C_Header_Text,
  465.                                        TF_Main_Header,&Main_Header_Text);
  466.  
  467.                 GenerateCode(App,H_Header_Text,C_Header_Text,Main_Header_Text);
  468.  
  469.                 UnlockTextFieldTexts(TF_H_Header,H_Header_Text,
  470.                                      TF_C_Header,C_Header_Text,
  471.                                      TF_Main_Header,Main_Header_Text);
  472.             }
  473.             break;
  474.             /* end of case ID_BT_GENERATE */
  475.  
  476.             /* End computing of IDCMP */
  477.         }
  478.         if (running && signal) Wait(signal);
  479.     }
  480.     NormalEnd = TRUE;
  481.     end((void *)App);
  482. }
  483.