home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD2.img / d4xx / d475 / gadgeted / source / bin.c next >
Encoding:
C/C++ Source or Header  |  1991-04-17  |  19.2 KB  |  651 lines
  1. /*----------------------------------------------------------------------*
  2.    bin.c Version 2.3 -  © Copyright 1990-91 Jaba Development
  3.  
  4.    Author : Jan van den Baard
  5.    Purpose: The reading and writing of the gadgets in binary form.
  6.    NOTE   : GadgetED 2.0 binary files MUST be patched first!
  7.  *----------------------------------------------------------------------*/
  8.  
  9. /*
  10.  * external global data
  11.  */
  12. extern struct Screen        *MainScreen;
  13. extern struct Window        *MainWindow;
  14. extern struct GadgetList     Gadgets;
  15. extern struct NewWindow      nw_main;
  16. extern struct Gadget         TextGadget;
  17. extern struct ge_prefs       prefs;
  18. extern struct FileRequester *IODir;
  19. extern struct MemoryChain    Misc;
  20. extern struct MemoryChain    Memory;
  21. extern USHORT                GadgetCount, id, BackFill, WDBackFill;
  22. extern USHORT                FrontPen, BackPen, Colors[], WBColors[];
  23. extern USHORT                LightSide, DarkSide;
  24. extern BOOL                  Saved, REQUESTER, WBSCREEN;
  25. extern UBYTE                 name[512], wdt[80], wlb[MAXLABEL];
  26. extern ULONG                 WindowFlags, IDCMPFlags;
  27.  
  28. /*
  29.  * icon image data
  30.  */
  31. USHORT data[] =
  32.  { 0x0000,0x0000,0x0000,0x03fe,0x47ff,0xf800,0x0f01,0xc1e0,
  33.    0x1800,0x1e00,0xc1e0,0x0800,0x1c00,0x41e0,0x0800,0x3c00,
  34.    0x01e0,0x8000,0x3c00,0x01e1,0x8000,0x3c00,0x01ff,0x8000,
  35.    0x3c1f,0xe1e1,0x8000,0x3c07,0xc1e0,0x8000,0x3c03,0xc1e0,
  36.    0x0800,0x1e03,0xc1e0,0x0800,0x0f07,0xc1e0,0x1800,0x03fe,
  37.    0x67ff,0xf800,0x0000,0x0000,0x0000,0xffff,0xffff,0xfe00,
  38.    0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,
  39.    0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,
  40.    0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,
  41.    0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,
  42.    0xfe00,0xffff,0xffff,0xfe00,0xffff,0xffff,0xfe00,0xffff,
  43.    0xffff,0xfe00
  44.  };
  45.  
  46. struct Image icon_image =
  47.  { 0,0,39,15,2,NULL,0x03,0x00,NULL };
  48. struct IconBase *IconBase;
  49.  
  50. /*
  51.  * write a 'GE' icon
  52.  */
  53. BOOL write_icon(nme)
  54.     UBYTE *nme;
  55. {
  56.     struct DiskObject  icon;
  57.     struct Gadget      icon_Gadget;
  58.     BOOL               ret;
  59.  
  60.     if((IconBase = OpenLibrary(ICONNAME,0L)))
  61.     {   icon_image.ImageData     =   &data[0];
  62.  
  63.         icon_Gadget.NextGadget   =   NULL;
  64.         icon_Gadget.LeftEdge     =   0;
  65.         icon_Gadget.TopEdge      =   0;
  66.         icon_Gadget.Width        =   39;
  67.         icon_Gadget.Height       =   15;
  68.         icon_Gadget.Flags        =   GADGIMAGE+GADGBACKFILL;
  69.         icon_Gadget.Activation   =   RELVERIFY+GADGIMMEDIATE;
  70.         icon_Gadget.GadgetType   =   BOOLGADGET;
  71.         icon_Gadget.GadgetRender =   (APTR)&icon_image;
  72.         icon_Gadget.SelectRender =   NULL;
  73.         icon_Gadget.GadgetText   =   NULL;
  74.         icon_Gadget.MutualExclude=   NULL;
  75.         icon_Gadget.SpecialInfo  =   NULL;
  76.         icon_Gadget.GadgetID     =   NULL;
  77.         icon_Gadget.UserData     =   NULL;
  78.  
  79.         icon.do_Magic            =   WB_DISKMAGIC;
  80.         icon.do_Version          =   WB_DISKVERSION;
  81.         icon.do_Gadget           =   icon_Gadget;
  82.         icon.do_Type             =   WBPROJECT;
  83.         icon.do_DefaultTool      =   (char *)":GadgetEd";
  84.         icon.do_ToolTypes        =   NULL;
  85.         icon.do_CurrentX         =   NO_ICON_POSITION;
  86.         icon.do_CurrentY         =   NO_ICON_POSITION;
  87.         icon.do_DrawerData       =   NULL;
  88.         icon.do_ToolWindow       =   NULL;
  89.         icon.do_StackSize        =   NULL;
  90.         ret = PutDiskObject((char *)nme,&icon);
  91.  
  92.         CloseLibrary(IconBase);
  93.         if(NOT ret) return(FALSE);
  94.         return(TRUE);
  95.     }
  96.     return(FALSE);
  97. }
  98.  
  99. /*
  100.  * write a gadget
  101.  */
  102. static BOOL WBG(file,g)
  103.     BPTR               file;
  104.     struct MyGadget   *g;
  105. {
  106.     struct Gadget     *gadget;
  107.     struct IntuiText  *t;
  108.     struct Border     *b;
  109.     struct Image      *i;
  110.     struct StringInfo *s;
  111.     ULONG              data_size;
  112.     char              *str;
  113.  
  114.     gadget = &g->Gadget;
  115.  
  116.     Write(file,(char *)gadget,sizeof(struct Gadget));
  117.     Write(file,(char *)&g->SpecialFlags,2);
  118.     Write(file,(char *)&g->GadgetLabel,MAXLABEL);
  119.  
  120.     if((t = gadget->GadgetText))
  121.     {   while(1)
  122.         {   Write(file,(char *)t,sizeof(struct IntuiText));
  123.             Write(file,(char *)t->IText,80);
  124.             if(NOT(t = t->NextText)) break;
  125.         }
  126.     }
  127.     if((NOT TestBits((ULONG)gadget->GadgetType,PROPGADGET)) AND
  128.        (NOT TestBits((ULONG)gadget->Flags,GADGIMAGE)))
  129.     {   b = (struct Border *)gadget->GadgetRender;
  130.         while(1)
  131.         {   Write(file,(char *)b,sizeof(struct Border));
  132.             Write(file,(char *)b->XY,(b->Count << 2));
  133.             if(NOT(b = b->NextBorder)) break;
  134.         }
  135.     }
  136.     else if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  137.     {   i = (struct Image *)gadget->GadgetRender;
  138.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  139.         Write(file,(char *)i,sizeof(struct Image));
  140.         Write(file,(char *)i->ImageData,data_size);
  141.     }
  142.  
  143.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  144.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  145.     {   i = (struct Image *)gadget->SelectRender;
  146.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  147.         Write(file,(char *)i,sizeof(struct Image));
  148.         Write(file,(char *)i->ImageData,data_size);
  149.     }
  150.  
  151.     if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  152.     {   Write(file,(char *)gadget->SpecialInfo,sizeof(struct PropInfo));
  153.     }
  154.     if(TestBits((ULONG)gadget->GadgetType,STRGADGET))
  155.     {   s = (struct StringInfo *)gadget->SpecialInfo;
  156.         Write(file,(char *)s,sizeof(struct StringInfo));
  157.         Write(file,(char *)s->Buffer,s->MaxChars);
  158.     }
  159.     if(str = IoErrToStr())
  160.     {   enable_window();
  161.         Error(str);
  162.         return(FALSE); }
  163.     return(TRUE);
  164. }
  165.  
  166. /*
  167.  * write the window/requester texts (if there are any)
  168.  */
  169. static BOOL WriteWRTexts(file)
  170.     BPTR file;
  171. {
  172.     register struct IntuiText *t;
  173.     char    *str;
  174.  
  175.     if((t = TextGadget.GadgetText))
  176.     {   while(1)
  177.         {   Write(file,(char *)t,sizeof(struct IntuiText));
  178.             Write(file,(char *)t->IText,80);
  179.             if(NOT(t = t->NextText)) break;
  180.         }
  181.     }
  182.     if(str = IoErrToStr())
  183.     {   enable_window();
  184.         Error(str);
  185.         return(FALSE);
  186.     }
  187.     return(TRUE);
  188. }
  189.  
  190. /*
  191.  * read a gadget
  192.  */
  193. static BOOL RBG(file)
  194.     BPTR file;
  195. {
  196.     struct MyGadget   *g;
  197.     struct Gadget     *gadget;
  198.     struct IntuiText  *t,*t1;
  199.     struct Border     *b,*b1;
  200.     struct Image      *i;
  201.     struct StringInfo *s;
  202.     ULONG  data_size;
  203.     char    *str;
  204.  
  205.  
  206.     if(NOT(g = (struct MyGadget *)Alloc(&Memory,(ULONG)sizeof(struct MyGadget))))
  207.         goto NoMem;
  208.  
  209.     AddTail((void *)&Gadgets,(void *)g);
  210.  
  211.     gadget = (struct Gadget *)&g->Gadget;
  212.  
  213.     Read(file,(char *)gadget,sizeof(struct Gadget));
  214.     Read(file,(char *)&g->SpecialFlags,2);
  215.     Read(file,(char *)&g->GadgetLabel,MAXLABEL);
  216.  
  217.     if(gadget->GadgetText)
  218.     {   if(NOT(t1 = (struct IntuiText *)
  219.          Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  220.             goto NoMem;
  221.         Read(file,(char *)t1,sizeof(struct IntuiText));
  222.  
  223.         if(NOT(t1->IText = (UBYTE *)Alloc(&Memory,80L)))
  224.             goto NoMem;
  225.         Read(file,(char *)t1->IText,80);
  226.         gadget->GadgetText = t1;
  227.         if(t1->NextText)
  228.         {   while(1)
  229.             {   if(NOT(t = (struct IntuiText *)
  230.                  Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  231.                     goto NoMem;
  232.                 Read(file,(char *)t,sizeof(struct IntuiText));
  233.  
  234.                 if(NOT(t->IText = (UBYTE *)Alloc(&Memory,80L)))
  235.                     goto NoMem;
  236.                 Read(file,(char *)t->IText,80);
  237.                 t1->NextText = t;
  238.                 if(NOT t->NextText) break;
  239.                 t1 = t;
  240.             }
  241.         }
  242.     }
  243.  
  244.     if((NOT TestBits((ULONG)gadget->GadgetType,PROPGADGET)) AND
  245.        (NOT TestBits((ULONG)gadget->Flags,GADGIMAGE)))
  246.     {
  247.         if(NOT(b1 = (struct Border *)
  248.          Alloc(&Memory,(ULONG)sizeof(struct Border))))
  249.             goto NoMem;
  250.         Read(file,(char *)b1,sizeof(struct Border));
  251.  
  252.         if(NOT(b1->XY = (SHORT *)Alloc(&Memory,(b1->Count << 2))))
  253.             goto NoMem;
  254.         Read(file,(char *)b1->XY,(b1->Count << 2));
  255.         gadget->GadgetRender = (APTR)b1;
  256.         if(b1->NextBorder)
  257.         {   while(1)
  258.             {   if(NOT(b = (struct Border *)
  259.                  Alloc(&Memory,(ULONG)sizeof(struct Border))))
  260.                     goto NoMem;
  261.                 Read(file,(char *)b,sizeof(struct Border));
  262.  
  263.                 if(NOT(b->XY = (SHORT *)Alloc(&Memory,(b->Count << 2))))
  264.                     goto NoMem;
  265.                 Read(file,(char *)b->XY,(b->Count << 2));
  266.                 b1->NextBorder = b;
  267.                 if(NOT b->NextBorder) break;
  268.                 b1 = b;
  269.             }
  270.         }
  271.     }
  272.     else if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  273.     {   if(NOT(i = (struct Image *)
  274.          Alloc(&Memory,(ULONG)sizeof(struct Image))))
  275.             goto NoMem;
  276.         Read(file,(char *)i,sizeof(struct Image));
  277.  
  278.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  279.         if(NOT(i->ImageData = (USHORT *)
  280.          AllocMem(data_size,MEMF_CHIP+MEMF_CLEAR)))
  281.             goto NoMem;
  282.         Read(file,(char *)i->ImageData,data_size);
  283.         gadget->GadgetRender = (APTR)i;
  284.     }
  285.  
  286.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  287.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  288.     {   if(NOT(i = (struct Image *)
  289.          Alloc(&Memory,(ULONG)sizeof(struct Image))))
  290.             goto NoMem;
  291.         Read(file,(char *)i,sizeof(struct Image));
  292.  
  293.         data_size = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  294.         if(NOT(i->ImageData = (USHORT *)
  295.          AllocMem(data_size,MEMF_CHIP+MEMF_CLEAR)))
  296.             goto NoMem;
  297.         Read(file,(char *)i->ImageData,data_size);
  298.         gadget->SelectRender = (APTR)i;
  299.     }
  300.  
  301.     if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  302.     {   if(NOT TestBits((ULONG)gadget->Flags,GADGIMAGE))
  303.         {   if(NOT(gadget->GadgetRender =
  304.              Alloc(&Memory,(ULONG)sizeof(struct Image))))
  305.                 goto NoMem;
  306.         }
  307.         if(NOT(gadget->SpecialInfo =
  308.           Alloc(&Memory,(ULONG)sizeof(struct PropInfo))))
  309.                 goto NoMem;
  310.         Read(file,(char *)gadget->SpecialInfo,sizeof(struct PropInfo));
  311.     }
  312.     if(TestBits((ULONG)gadget->GadgetType,STRGADGET))
  313.     {   if(NOT(s = (struct StringInfo *)
  314.          Alloc(&Memory,(ULONG)sizeof(struct StringInfo))))
  315.             goto NoMem;
  316.         Read(file,(char *)s,sizeof(struct StringInfo));
  317.         if(NOT(s->Buffer = (UBYTE *)Alloc(&Memory,s->MaxChars)))
  318.             goto NoMem;
  319.         Read(file,(char *)s->Buffer,s->MaxChars);
  320.         if(s->UndoBuffer)
  321.         {   if(NOT(s->UndoBuffer = (UBYTE *)Alloc(&Memory,s->MaxChars)))
  322.                 goto NoMem;
  323.         }
  324.         gadget->SpecialInfo = (APTR)s;
  325.     }
  326.     if(str = IoErrToStr())
  327.     {   enable_window();
  328.         Error(str);
  329.         return(FALSE);
  330.     }
  331.     return(TRUE);
  332.  
  333. NoMem:
  334.     enable_window();
  335.     Error("Out of Memory !");
  336.     return(FALSE);
  337. }
  338.  
  339. /*
  340.  * read the window/requester text (if there are any)
  341.  */
  342. static BOOL ReadWRTexts(file,num)
  343.     BPTR file;
  344.     ULONG num;
  345. {
  346.     register struct IntuiText *t, *t1;
  347.     register UCOUNT i;
  348.     char    *str;
  349.  
  350.     if(NOT num) return(TRUE);
  351.  
  352.     if(NOT(t = (struct IntuiText *)
  353.      Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  354.         goto NoMem;
  355.     Read(file,(char *)t,sizeof(struct IntuiText));
  356.     if(NOT(t->IText = (UBYTE *)Alloc(&Memory,80L)))
  357.         goto NoMem;
  358.     Read(file,(char *)t->IText,80);
  359.     TextGadget.GadgetText = t;
  360.     for(i=0;i<num-1;i++)
  361.     {   if(NOT(t1 = (struct IntuiText *)
  362.          Alloc(&Memory,(ULONG)sizeof(struct IntuiText))))
  363.             goto NoMem;
  364.         Read(file,(char *)t1,sizeof(struct IntuiText));
  365.         if(NOT(t1->IText = (UBYTE *)Alloc(&Memory,80)))
  366.             goto NoMem;
  367.         Read(file,(char *)t1->IText,80);
  368.         t->NextText = t1;
  369.         t = t1;
  370.     }
  371.     if(str = IoErrToStr())
  372.     {   enable_window();
  373.         Error(str);
  374.         return(FALSE);
  375.     }
  376.     return(TRUE);
  377.  
  378. NoMem:
  379.     enable_window();
  380.     Error("Out of Memory !");
  381.     return(FALSE);
  382. }
  383.  
  384. /*
  385.  * get the number of window/requester texts
  386.  */
  387. static LONG get_num_texts()
  388. {
  389.     register struct IntuiText *t;
  390.     LONG num = NULL;
  391.  
  392.     if((t = TextGadget.GadgetText))
  393.     {   num = 1L;
  394.         while(1)
  395.         {   if(NOT(t = t->NextText)) break;
  396.             num++;
  397.         }
  398.     }
  399.     return(num);
  400. }
  401.  
  402. /*
  403.  * write a binary gadgets file
  404.  */
  405. VOID WriteBinGadgets()
  406. {
  407.     struct BinHeader         head;
  408.     BPTR                     file;
  409.     struct ViewPort          *vp;
  410.     ULONG                    rc;
  411.     struct NewWindow         nw;
  412.     register struct MyGadget *g;
  413.     register UCOUNT          i;
  414.     char    *str;
  415.  
  416.     strcpy((char *)IODir->fr_HeadLine,(char *)"Save Binary");
  417.  
  418.     IODir->fr_Screen  = MainScreen;
  419.     IODir->fr_Caller  = MainWindow;
  420.     IODir->fr_Flags  != FR_NoInfo;
  421.     rc = FileRequest(IODir);
  422.     if(rc == FREQ_CANCELED) return;
  423.     else if(rc)
  424.     {   Error("FileRequester won't open !");
  425.         return;
  426.     }
  427.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  428.     strcat((char *)&name,(char *)IODir->fr_FileName);
  429.  
  430.     disable_window();
  431.     SetWindowTitles(MainWindow,(char *)-1L,(char *)"Saving Binary......");
  432.     buisy();
  433.     vp = &MainScreen->ViewPort;
  434.  
  435.     if(NOT(file = Open((char *)&name,MODE_NEWFILE)))
  436.     {   enable_window();
  437.         Error("Can't open Write File !");
  438.         return;
  439.     }
  440.     /* write file header */
  441.     head.FileType   = TYPE;
  442.     head.Version    = GE_VERSION;
  443.     head.Revision   = GE_REVISION;
  444.     head.NumGads    = GadgetCount;
  445.     head.ReqGads    = REQUESTER;
  446.     head.WBScreen   = WBSCREEN;
  447.     head.ScrDepth   = MainScreen->BitMap.Depth;
  448.     for(i=0;i<32;i++) head.Colors[i] = (USHORT)GetRGB4(vp->ColorMap,(LONG)i);
  449.     head.NumTexts   = get_num_texts();
  450.     head.FPen       = FrontPen;
  451.     head.BPen       = BackPen;
  452.     head.BackFill   = BackFill;
  453.     head.WDBackFill = WDBackFill;
  454.     head.LightSide  = LightSide;
  455.     head.DarkSide   = DarkSide;
  456.     for(i=0;i<2;i++) head.Res[i] = 0;
  457.     Write(file,(char *)&head,sizeof(struct BinHeader));
  458.  
  459.     /* write prefs */
  460.     Write(file,(char *)&prefs,sizeof(struct ge_prefs));
  461.  
  462.     /* write window specifics */
  463.     nw.LeftEdge    = MainWindow->LeftEdge;
  464.     nw.TopEdge     = MainWindow->TopEdge;
  465.     nw.Width       = MainWindow->Width;
  466.     nw.Height      = MainWindow->Height;
  467.     nw.DetailPen   = MainWindow->DetailPen;
  468.     nw.BlockPen    = MainWindow->BlockPen;
  469.     nw.Flags       = WindowFlags;
  470.     nw.IDCMPFlags  = IDCMPFlags;
  471.     nw.FirstGadget = NULL;
  472.     nw.CheckMark   = NULL;
  473.     nw.Title       = NULL;
  474.     nw.Screen      = NULL;
  475.     nw.BitMap      = NULL;
  476.     nw.MinWidth    = MainWindow->MinWidth;
  477.     nw.MinHeight   = MainWindow->MinHeight;
  478.     nw.MaxWidth    = MainWindow->MaxWidth;
  479.     nw.MaxHeight   = MainWindow->MaxHeight;
  480.     nw.Type        = CUSTOMSCREEN;
  481.     Write(file,(char *)&nw,sizeof(struct NewWindow));
  482.  
  483.     /* write title + label */
  484.     Write(file,(char *)&wdt,80);
  485.     Write(file,(char *)&wlb,MAXLABEL);
  486.  
  487.     /* write window/requester texts */
  488.     if(WriteWRTexts(file) == FALSE)
  489.     {   Close(file);
  490.         return;
  491.     }
  492.  
  493.     if(GadgetCount)
  494.     {   for(g = Gadgets.Head; g != (struct MyGadget *)&Gadgets.Tail; g = g->Succ)
  495.         {   if(WBG(file,g) == FALSE)
  496.             {   Close(file);
  497.                 return;
  498.             }
  499.         }
  500.     }
  501.     Close(file);
  502.     if(str = IoErrToStr())
  503.     {   enable_window();
  504.         Error(str);
  505.         DeleteFile((char *)&name[0]);
  506.         return;
  507.     }
  508.     Saved = TRUE;
  509.     if(NOT(write_icon((char *)&name[0])))
  510.         Error("Error writing the icon");
  511.     enable_window();
  512.     ok();
  513. }
  514.  
  515. /*
  516.  * read a binary gadgets file
  517.  */
  518. VOID ReadBinGadgets(fsu)
  519.     BOOL fsu;
  520. {
  521.     struct BinHeader         head;
  522.     BPTR                     file;
  523.     struct ViewPort          *vp;
  524.     ULONG                    rc;
  525.     register struct MyGadget *g;
  526.     register UCOUNT          i;
  527.     char   *str;
  528.  
  529.     if(NOT fsu)
  530.     {   if(Saved == FALSE)
  531.         {   if(Ask("Current work isn't saved !",
  532.                    "Load a file anyway ?") == FALSE) return;
  533.         }
  534.         strcpy((char *)IODir->fr_HeadLine,(char *)"Load Binary");
  535.         IODir->fr_Screen  = MainScreen;
  536.         IODir->fr_Caller  = MainWindow;
  537.         IODir->fr_Flags  |= FR_NoInfo;
  538.         rc = FileRequest(IODir);
  539.         if(rc == FREQ_CANCELED) return;
  540.         else if(rc)
  541.         {   Error("FileRequester won't open !");
  542.             return;
  543.         }
  544.         strcpy((char *)&name,(char *)IODir->fr_DirName);
  545.         strcat((char *)&name,(char *)IODir->fr_FileName);
  546.     }
  547.  
  548.     if(NOT(file = Open((char *)&name,MODE_OLDFILE)))
  549.     {   if(fsu)
  550.         {   WBSCREEN = TRUE;
  551.             change_depth(2);
  552.         }
  553.         Error("Can't open Read File !");
  554.         return;
  555.     }
  556.  
  557.     Read(file,(char *)&head,sizeof(struct BinHeader));
  558.  
  559.  
  560.     if(head.FileType == OLDTYPE)
  561.     {   if(fsu)
  562.         {   WBSCREEN = TRUE;
  563.             change_depth(2);
  564.         }
  565.         Close(file);
  566.         Error("File needs patching !"); return;
  567.     }
  568.     if(head.FileType != TYPE)
  569.     {   if(fsu)
  570.         {   WBSCREEN = TRUE;
  571.             change_depth(2);
  572.         }
  573.         Close(file);
  574.         Error("Unknown FileType !"); return;
  575.     }
  576.  
  577.     FreeGList();
  578.     GadgetCount = id = 0;
  579.  
  580.     REQUESTER  = head.ReqGads;
  581.     WBSCREEN   = head.WBScreen;
  582.     FrontPen   = head.FPen;
  583.     BackPen    = head.BPen;
  584.     BackFill   = head.BackFill;
  585.     WDBackFill = head.WDBackFill;
  586.     LightSide  = head.LightSide;
  587.     DarkSide   = head.DarkSide;
  588.  
  589.     Read(file,(char *)&prefs,sizeof(struct ge_prefs));
  590.     Read(file,(char *)&nw_main,sizeof(struct NewWindow));
  591.  
  592.     WindowFlags = nw_main.Flags;
  593.     IDCMPFlags  = nw_main.IDCMPFlags;
  594.  
  595.     if(REQUESTER)
  596.     {   nw_main.Flags     = WINDOWDRAG|WINDOWSIZING;
  597.         nw_main.Flags    |= GIMMEZEROZERO|SIZEBRIGHT|SIZEBBOTTOM|BORDERLESS;
  598.     }
  599.     else
  600.     {   nw_main.Flags     = 0;
  601.         if(TestBits(WindowFlags,WINDOWCLOSE))   nw_main.Flags |= WINDOWCLOSE;
  602.         if(TestBits(WindowFlags,WINDOWDEPTH))   nw_main.Flags |= WINDOWDEPTH;
  603.         if(TestBits(WindowFlags,WINDOWDRAG))    nw_main.Flags |= WINDOWDRAG;
  604.         if(TestBits(WindowFlags,WINDOWSIZING))  nw_main.Flags |= WINDOWSIZING;
  605.         if(TestBits(WindowFlags,SIZEBRIGHT))    nw_main.Flags |= SIZEBRIGHT;
  606.         if(TestBits(WindowFlags,SIZEBBOTTOM))   nw_main.Flags |= SIZEBBOTTOM;
  607.     }
  608.     nw_main.Flags      |=SMART_REFRESH|NOCAREREFRESH|ACTIVATE;
  609.     nw_main.IDCMPFlags  =SIZEVERIFY|NEWSIZE|GADGETUP|GADGETDOWN|INACTIVEWINDOW;
  610.     nw_main.IDCMPFlags |=ACTIVEWINDOW|MENUPICK|RAWKEY|MOUSEBUTTONS|CLOSEWINDOW;
  611.  
  612.     Read(file,(char *)&wdt,80);
  613.     Read(file,(char *)&wlb,MAXLABEL);
  614.  
  615.     change_depth(head.ScrDepth);
  616.     disable_window();
  617.     SetWindowTitles(MainWindow,(char *)-1L,(char *)"Reading Binary......");
  618.     buisy();
  619.     vp = &MainScreen->ViewPort;
  620.     if(NOT WBSCREEN)
  621.         LoadRGB4(vp,(void *)&head.Colors,(1 << MainScreen->BitMap.Depth));
  622.     else
  623.         LoadRGB4(vp,(void *)&WBColors[0],4);
  624.     if(ReadWRTexts(file,head.NumTexts) == FALSE)
  625.     {   Close(file);
  626.         FreeGList();
  627.         return;
  628.     }
  629.     if(head.NumGads)
  630.     {   for(i=0;i<head.NumGads;i++)
  631.         {   if(RBG(file) == FALSE)
  632.             {   Close(file);
  633.                 FreeGList();
  634.                 return;
  635.             }
  636.         }
  637.         for(g = Gadgets.Head; g != (struct MyGadget *)&Gadgets.Tail; g = g->Succ)
  638.         {   AddGList(MainWindow,&g->Gadget,NULL,1,NULL);
  639.             GadgetCount++;
  640.             id++;
  641.         }
  642.     }
  643.     Close(file);
  644.     rem_bo();
  645.     refresh();
  646.     Saved = TRUE;
  647.     enable_window();
  648.     ok();
  649.     if(str = IoErrToStr()) Error(str);
  650. }
  651.