home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSHJ2 / FILE.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  46.3 KB  |  2,222 lines
  1. /**********************************************************************/
  2. /* FILE: FILE.C                                  */
  3. /* DESCRIPTION: FILE I/O Routines                      */
  4. /* CREATED:                                     */
  5. /* LAST MODIFIED:   02/06/89                          */
  6. /*                                      */
  7. /*        loadfile()     - loads a file                  */
  8. /*        instring()    - Searches a string for a character   */
  9. /*        get_fs()    - Handle File Selector dialog box     */
  10. /*         save_doc()    - Save a document to disk          */
  11. /*        write_regions() - Write regions to disk              */
  12. /*        write_attrs()    - Write attributes to disk          */
  13. /*        write_prims()    - Write primitives to disk          */
  14. /*        write_articles()- Write articles to disk          */
  15. /*        write_pages()   - Write pages to disk              */
  16. /*        atbl_setup()    - Article table setup              */
  17. /*        rtble_setup()    - Region table setup              */
  18. /*        dread()        - Read characters from input buffer   */
  19. /*        dwrite()    - Write characters to file          */
  20. /*        ddump()        - Write out file buffer to disk          */
  21. /*        load_doc()    - Load document from disk          */
  22. /*        load_arts()    - Load articles from disk          */
  23. /*        getrptr()    - Get region pointer from rtable      */
  24. /*        fixup_rptrs()    - Fixup region ptrs after loading     */
  25. /*        aindex_to_ptr() - Return article index pointer        */
  26. /*        read_regions()  - Read regions from disk          */
  27. /*        read_prims()    - Read primitives from disk          */
  28. /*        read_pages()    - Read pages from disk              */
  29. /*        read_articles() - Read articles from disk          */
  30. /*        getaindex()    - Get article index              */
  31. /*        getrindex()    - Get region index               */
  32. /*        save_clipb()    - Save clipboard to disk          */
  33. /*        load_clipb()    - Load clipboard from disk          */
  34. /*        extender()    - Handle file name extenders          */
  35. /**********************************************************************/
  36.  
  37. #include "osbind.h"
  38. #include "dbase.h"
  39. #include "gemdefs.h"
  40. #include "alert.h"
  41. #include "deskset2.h"
  42. #include <obdefs.h>
  43.  
  44. /**************************************************************************/
  45. /* DEFINES                                  */
  46. /**************************************************************************/
  47. #define NOMEMORY    1
  48. #define NODATA        2
  49. #define NOFILE        3
  50.  
  51. #define DOCSIZE        5000L
  52.  
  53.  
  54. /**************************************************************************/
  55. /* EXTERNALS                                  */
  56. /**************************************************************************/
  57. extern long lcalloc();
  58. extern long lmalloc();
  59. extern long calloc();
  60. extern PAGE *get_fpage();
  61. extern PAGE *get_npage();
  62. extern REGION *get_fregion();
  63. extern REGION *get_nregion();
  64. extern ARTICLE *getf_article();
  65. extern ARTICLE *getn_article();
  66. extern unsigned char *buf_start;
  67. extern unsigned char *buf_end;
  68. extern unsigned char *free_start;
  69. extern unsigned char *current_char;
  70.  
  71. extern int force_draw_flag;
  72. extern int curr_page;
  73.  
  74. extern PAGE *pagehd;
  75. extern PAGE *clippage;
  76.  
  77. extern ARTICLE *arthd;
  78.  
  79. extern int ptsarray[];
  80.  
  81. extern int clipfull;
  82. extern unsigned char *get_lcmem();
  83. extern char *dpath1;
  84. extern char *dpath2;
  85. extern char *dpath3;
  86. extern char *dpath4;
  87. extern ARTICLE *curart;
  88.  
  89. extern int hpage_size;
  90. extern int vpage_size;
  91. extern int pagemux[];
  92. extern int pagemuy[];
  93. extern int pagetype;
  94. extern int shandle;
  95. extern int view_size;
  96. extern int pxy[];
  97. extern int cur_scale;
  98. extern GRECT pwork;
  99. extern GRECT page_area;
  100. extern int prev_handle;
  101.  
  102.  
  103. extern PAGE *tpagehd;
  104. extern PAGE *tcurpage;
  105. extern int temp_page;
  106. extern PAGE *curpage;
  107. extern PAGE *right_tmplate;
  108. extern PAGE *left_tmplate;
  109. extern int dummy;
  110. extern int tmplate_flag;
  111.  
  112. extern PNUMBER pnum;
  113.  
  114. extern ARTICLE *rtarthd;
  115. extern ARTICLE *ltarthd;
  116.  
  117. extern int pstorage[];
  118. extern char pnumtext[];
  119.  
  120. extern int active_prim;
  121. extern int scan_xres;
  122. extern int scan_yres;
  123. extern OBJECT *ad_menu;
  124.  
  125. extern char *winfo[][4];
  126. extern int unit_type;
  127.  
  128. /**************************************************************************/
  129. /* GLOBAL VARIABLES                                    */
  130. /**************************************************************************/
  131. typedef struct dta
  132.     {
  133.     char    res[21];
  134.     char    attr;
  135.     int    time;
  136.     int    date;
  137.     long    fsize;
  138.     char    str[14];
  139.     }DTA;
  140.  
  141. DTA    thedta;
  142.  
  143. long    chbuff;
  144. int    fhandle;
  145. long    bytes_in;
  146. char    *textptr;
  147. char    *endptr;
  148. char    *tmpptr;
  149. char     fbuffer[100];
  150. char    pathbuf[50];
  151. char    fname[20];
  152. char    *docbuf;
  153. char    *docend;
  154. char    *docptr;
  155.  
  156. long    *atable;
  157. long    *rtable;
  158.  
  159. unsigned int gl_rcount;
  160. long   bufpath;
  161. int    pbufindex;
  162. char *pbuff;
  163.  
  164.  
  165. long   *tatable;
  166. long   *trtable;
  167. ARTICLE *tarthd;
  168. int tcurr_page;
  169.  
  170.  
  171. int rtmplate_flag;    /* Global variables for tmplate storage */
  172. PAGE *rpagehd;        /* during save_doc() and save_tmplate() */
  173. PAGE *rcurpage;        /* If variables used anywhere else, they*/
  174. int rtemp_page;        /* are locals...            */
  175. ARTICLE *rarthd;
  176. char pfname[20];    /* string to hold title for preview window */
  177. char basefname[20];    /* string to hold title for base page       */
  178.  
  179.  
  180. /**********************************************************************/
  181. /* Function: loadfile()                              */
  182. /* Description: Load file 'fname' into buffer                  */
  183. /**********************************************************************/
  184. loadfile(fname)
  185. char *fname;
  186. {
  187.    long bufsize;
  188.  
  189.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  190.    if(Fsfirst(fname,0) <= -1)
  191.    {
  192.     return(0);
  193.    }
  194.    bufsize = (((thedta.fsize * 3L)> 2048L)? (thedta.fsize*3L):(2048L));
  195.    if(chbuff = lcalloc(1L,bufsize))    /* Allocate more than we need */
  196.    {
  197.      fhandle = Fopen(fname,0);
  198.      bytes_in = Fread(fhandle,thedta.fsize,chbuff);
  199.      Fclose(fhandle);
  200.      init_buffer(chbuff,chbuff+bufsize);
  201.      set_buffer(bytes_in);
  202.      return(1);
  203.    }
  204.    return(0);
  205. }
  206.  
  207.  
  208.  
  209. /************************************************************************/
  210. /*  Function: instring()                        */
  211. /*  Description: Searches a string for a particular character         */
  212. /************************************************************************/    
  213. instring(c,s)
  214. char    c;
  215. register char    *s;
  216. {
  217.     while (*s)
  218.         if (c == *s++)
  219.             return(1);
  220.     return(0);
  221. }
  222.  
  223.  
  224. /************************************************************************/
  225. /* Function: get_fs()                            */
  226. /* Description: Handle file selector                    */
  227. /************************************************************************/
  228. get_fs(buff,changed)
  229. register char *buff;
  230. int *changed;
  231. {
  232.     int button;
  233.     register int i;
  234.     register char *tbuff;
  235.         char obuf[40];
  236.         int drv;
  237.  
  238.     tbuff = pathbuf;
  239.     if(pathbuf[0] == '\0')
  240.     {
  241.         *tbuff++ = (drv =Dgetdrv()) + 'A';
  242.         *tbuff++ = ':';
  243.         *tbuff++ = '\\';
  244.         *tbuff++ = 0;
  245.         Dgetpath(obuf,drv+1);
  246.         if(strlen(obuf) == 0);
  247.         else strcat(pathbuf,&obuf[1]);
  248.     }    
  249.     strcpy(buff,pathbuf);
  250.     buff[40] = '\0';        /* filename goes here */
  251.         fname[0] = '\0';
  252.     fsel_input(buff,fname,&button);
  253.     if(!strcmp(buff,pathbuf))
  254.        *changed = 0;
  255.     else
  256.        *changed = 1;
  257.                     /* Backspace until a \ or a :    */
  258.     for (i = strlen(buff); i && !instring(buff[i],"\\:");
  259.                                            buff[i--] = '\0'); 
  260.     strcpy(pathbuf,buff);
  261.     strcat(buff,fname);
  262.     return button;
  263. }
  264.  
  265.  
  266.  
  267. /************************************************************************/
  268. /* Function: save_doc                            */
  269. /* Description:    Save a document to disk.                */
  270. /************************************************************************/
  271. save_doc()
  272. {  
  273.    int pagenum,dummy;
  274.    register unsigned int  pcount,acount,rcount;
  275.    unsigned long rtblsize;
  276.    unsigned long atblsize;
  277.    int status;   
  278.  
  279.    PAGE *pageptr;
  280.    REGION *rptr;
  281.    ARTICLE *aptr;
  282.    long magic;
  283.    
  284.    magic = 0x12445334L;            /* 12DS34 */
  285.    status = FALSE;
  286.  
  287.    strcpy(pathbuf,dpath4);
  288.    strcat(pathbuf,"*.DS2");
  289.    if(!get_fs(fbuffer,&dummy))
  290.     return;
  291.  
  292.    push_sdoc();
  293.    extender(fbuffer,".DS2");   
  294.  
  295.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  296.    if(Fsfirst(fbuffer,0) == 0)            /* File Already Exists  */
  297.    {
  298.     if(alert_cntre(ALERT37) == 2)        /* Cancel Button pressed*/
  299.     {
  300.       pop_sdoc();
  301.       return;
  302.     }
  303.    }
  304.    
  305.  
  306.    
  307.    pageptr = get_fpage(&pagenum);
  308.    if(!pageptr)
  309.    {
  310.     pop_sdoc();
  311.     return;
  312.    }
  313.  
  314.  
  315.    
  316.    docbuf = (char *)lmalloc(DOCSIZE);
  317.    if(!docbuf)
  318.    {
  319.     alert_cntre(ALERT12);    
  320.     pop_sdoc();
  321.     return;
  322.    }
  323.    docptr = docbuf;
  324.    docend = docbuf + DOCSIZE;   /* Points to 1 past max address */
  325.  
  326.    acount = 0;
  327.    rcount = 0;            /* Initialize region count      */
  328.    pcount = 0;            /* Initialize page count    */
  329.  
  330.    while(pageptr)
  331.    {
  332.        pcount++;
  333.        rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  334.        while(rptr)
  335.        {
  336.            rcount++;
  337.            rptr = get_nregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  338.        }
  339.        pageptr = get_npage(&pagenum);
  340.    }
  341.    rtblsize = 4L * ((long)rcount + 1L);
  342.  
  343.    rtable = (long *)lmalloc(rtblsize);
  344.    if(!rtable)
  345.    {
  346.     alert_cntre(ALERT12);
  347.     free(docbuf);
  348.     pop_sdoc();
  349.     return;
  350.    }
  351.    aptr = getf_article();
  352.    while(aptr)
  353.    {
  354.     acount++;
  355.     aptr = getn_article();
  356.    }
  357.    atblsize = 4L * ((long)acount + 1L);
  358.    atable = (long *)lmalloc(atblsize);
  359.    if(!atable)
  360.    {
  361.     free(rtable);
  362.     free(docbuf);
  363.     alert_cntre(ALERT12);
  364.     pop_sdoc();
  365.     return;
  366.    }
  367.   
  368.    rtbl_setup();            /* Set up region table  */
  369.    atbl_setup();            /* Set up article table */
  370.  
  371.    if((fhandle = Fcreate(fbuffer,0)) <= 0)
  372.    {
  373.     alert_cntre(ALERT19);
  374.     pop_sdoc();
  375.      return;
  376.    }
  377.  
  378.    dwrite(&magic,4);            /* Magic value        */
  379.    if(write_pages(pcount)    &&     /* If each is successful then */
  380.       write_articles(acount) &&     /* continue to write the next */
  381.       write_regions(rcount)  &&        /* else short circuit the     */
  382.       write_tags()          &&        /* while statement and stop   */
  383.       write_setp()           &&        /* writing              */
  384.       write_ptype()         &&
  385.       write_pnums()         &&        /* write page number info...  */
  386.       ddump())                /* Dump the buffer    */
  387.  
  388.     ;    /* Everything was written OK */
  389.         /* Let aes handle error messages */
  390.  
  391.    free(atable);
  392.    free(rtable);
  393.    free(docbuf);
  394.  
  395.  
  396.    if(Fclose(fhandle))
  397.     alert_cntre(ALERT18);        /* Close the file     */
  398.  
  399.    pop_sdoc();                /* restore variables  */
  400.    strcpy(pfname," ");
  401.    strcat(pfname,fname);
  402.    extender(pfname,".DS2");
  403.    strcat(pfname," ");
  404.    wind_set(prev_handle,WF_NAME,pfname,0,0);
  405. }
  406.  
  407.  
  408.  
  409. /************************************************************************/
  410. /* Function: write_regions()                        */
  411. /* Description: write regions to disk                    */
  412. /************************************************************************/
  413. write_regions(rcount)
  414. unsigned int rcount;
  415. {
  416.    register int i;
  417.    long rptr;
  418.    
  419.    if(!dwrite(&rcount,2))    /* Write number of regions    */
  420.             return(0);
  421.    for(i = 0;i < rcount;i++)
  422.    {
  423.     rptr = rtable[i];
  424.     if(!write_attrs(rptr))
  425.             return(0);
  426.     if(!write_prims(rptr))
  427.                    return(0);
  428.    }
  429.    return(1);                /* ok */
  430. }
  431.  
  432.  
  433.  
  434.  
  435. /************************************************************************/
  436. /* Function: write_attrs()                        */
  437. /* Description: write attributes to disk                */
  438. /************************************************************************/
  439. write_attrs(rptr)
  440. register REGION *rptr;
  441. {
  442.    unsigned int temp;
  443.  
  444.  
  445.    temp = ((!rptr->artptr) ? (0xffff) : (getaindex(rptr->artptr)));
  446.  
  447.    if(!dwrite(&temp,2))
  448.         return(0);
  449.    temp = ((!rptr->plink) ? (0xffff) : (getrindex(rptr->plink)));
  450.  
  451.    if(!dwrite(&temp,2))
  452.         return(0);
  453.  
  454.    temp = ((!rptr->alink) ? (0xffff) : (getrindex(rptr->alink)));
  455.  
  456.    if(!dwrite(&temp,2))
  457.         return(0);
  458.    if(!dwrite(&rptr->x1,10))              /* write x1,y1,x2,y2,p    */
  459.         return(0);
  460.    if(!dwrite(&rptr->reserved,4))          /* 2 reserved words         */
  461.         return(0);
  462.    if(!dwrite(&rptr->text,sizeof(struct txtattr)))/* Write text attributes  */
  463.         return(0);
  464.    if(!dwrite(&rptr->grattr[0],2*11))            /* Graphic attributes     */
  465.         return(0);
  466.    if(!dwrite(&rptr->type,2))                /* Write type            */
  467.         return(0);
  468.    return(1);                      /* no error */
  469. }
  470.  
  471.  
  472.  
  473.  
  474. /************************************************************************/
  475. /* Function: write_prims()                        */
  476. /* Description: write primitives to disk                */
  477. /************************************************************************/
  478. write_prims(rptr)
  479. REGION *rptr;
  480. {
  481.    int pcount;
  482.    int count,wrmode,op;
  483.  
  484.    pcount = 0;
  485.  
  486.    op = get_fprimitive(rptr,&count,&wrmode);
  487.    while(op != 0xffff)
  488.    {
  489.     pcount++;
  490.     op = get_nprimitive(&count,&wrmode);
  491.    }
  492.    if(!dwrite(&pcount,2))
  493.         return(0);
  494.  
  495.    op = get_fprimitive(rptr,&count,&wrmode);
  496.    while(op != 0xffff)
  497.    {
  498.     if(!dwrite(&op,2))            /* Write opcode         */
  499.            return(0);
  500.     if(!dwrite(&wrmode,2))            /* Write writing mode   */
  501.            return(0);
  502.     if(!dwrite(&count,2))            /* Write ptsarray count */
  503.            return(0);
  504.     if(!dwrite(&ptsarray[0],4*count))    /* Write points     */
  505.            return(0);
  506.     op = get_nprimitive(&count,&wrmode);
  507.    }
  508.    return(1);
  509. }
  510.        
  511. save_article(artptr)
  512. ARTICLE *artptr;
  513. {
  514.       if(artptr->dirty)
  515.       {
  516.          open_article(artptr);
  517.          strcpy(fbuffer,dpath1);
  518.          strcat(fbuffer,&artptr->filename[0]);
  519.          get_abuffvars(artptr);
  520.          write_file(fbuffer);
  521.          artptr->dirty = 0; 
  522.       }
  523. }
  524.  
  525. /************************************************************************/
  526. /* Function: write_articles()                        */
  527. /* Description: write articles to disk                    */
  528. /************************************************************************/
  529. write_articles(acount)
  530. unsigned int acount;
  531. {
  532.    register int i;
  533.    ARTICLE *aptr;
  534.    REGION  *rptr;
  535.    int temp;
  536.  
  537.    if(!dwrite(&acount,2))        /* Write number of articles    */
  538.         return(0);
  539.    for(i = 0;i < acount; i++)
  540.    {
  541.     aptr = (ARTICLE *)atable[i];
  542.     rptr = aptr->regptr;
  543.  
  544.     temp = ((rptr) ? (getrindex(rptr)) : (0xffff));
  545.         if(!dwrite(&temp,2))        /* Write index of first region  */
  546.             return(0);
  547.     if(!dwrite(&aptr->filename[0],40))    /* Write filename    */
  548.             return(0);
  549.     
  550.     save_article(aptr);
  551.    }
  552.    return(1);
  553. }
  554.  
  555.  
  556.  
  557.        
  558. /************************************************************************/
  559. /* Function: write_pages()                        */
  560. /* Description: Write pages to disk                    */
  561. /************************************************************************/
  562. write_pages(pcount)
  563. unsigned int pcount;
  564. {
  565.    PAGE *pageptr;
  566.    REGION *rptr;
  567.    int pagenum,dummy;
  568.    int temp;
  569.  
  570.    if(!dwrite(&pcount,2))        /* Write number of pages      */
  571.         return(0);
  572.    pageptr = get_fpage(&pagenum);
  573.    rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  574.    while(pageptr)
  575.    {
  576.     if(!dwrite(&pagenum,2))        /* Write page number         */
  577.             return(0);
  578.                     /* Write index of first region       */
  579.                     /* else -1 = no region for this page */
  580.     temp = ((rptr) ? (getrindex(rptr)) : (0xffff));
  581.         if(!dwrite(&temp,2))
  582.         return(0);
  583.     pageptr = get_npage(&pagenum);
  584.         rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  585.    }
  586.    return(1);
  587. }
  588.  
  589.  
  590.  
  591.  
  592.  
  593. /************************************************************************/
  594. /* Function: atbl_setup()                        */
  595. /* Description: Article Table setup                    */
  596. /************************************************************************/
  597. atbl_setup()
  598. {
  599.    register int i;
  600.    ARTICLE *aptr;
  601.  
  602.    i = 0;
  603.  
  604.    aptr = getf_article();
  605.    while(aptr)
  606.    {
  607.     atable[i++] = (long)aptr;
  608.     aptr = getn_article();
  609.    }
  610.    atable[i] = 0L;
  611. }
  612.  
  613.  
  614.  
  615.     
  616. /************************************************************************/
  617. /* Function: rtbl_setup()                        */
  618. /* Description: region table setup                    */
  619. /************************************************************************/
  620. rtbl_setup()
  621. {
  622.    PAGE *pageptr;
  623.    REGION *rptr;
  624.    register int i;
  625.    int pagenum;
  626.    int dummy;
  627.  
  628.    i = 0;
  629.    pageptr = get_fpage(&pagenum);
  630.    while(pageptr)
  631.    {
  632.     rptr = get_fregion(pagenum,&dummy,&dummy,&dummy,&dummy,&dummy);
  633.     while(rptr)
  634.     {
  635.         rtable[i++] = (long)rptr;
  636.         rptr = get_nregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  637.     }
  638.     pageptr = get_npage(&pagenum);
  639.    }
  640.    rtable[i] = 0L;
  641. }
  642.  
  643.  
  644.  
  645.  
  646. /************************************************************************/
  647. /* Function: dread()                            */
  648. /* Description: read characters from input buffer            */
  649. /************************************************************************/
  650. dread(cptr,count)
  651. register char *cptr;
  652. register int count;
  653. {
  654.    while(count--)
  655.    {
  656.     *cptr++ = *docptr++;
  657.    }
  658.    if(count != -1)
  659.     return(0);
  660.    else
  661.         return(1);
  662. }
  663.  
  664.  
  665.  
  666.  
  667. /************************************************************************/
  668. /* Function: dwrite()                            */
  669. /* Description: Write characters to file                */
  670. /************************************************************************/
  671. dwrite(cptr,count)
  672. register char *cptr;
  673. register int count;
  674. {
  675.    while(count--)
  676.    {
  677.     if(docptr == docend)
  678.     {
  679.        if(!ddump())
  680.            return(0);            /* error */
  681.     }
  682.     *docptr++ = *cptr++;
  683.    }
  684.    return(1);        /*ok */
  685. }
  686.  
  687.  
  688.  
  689.  
  690.  
  691. /************************************************************************/
  692. /* Function: ddump()                            */
  693. /* Description: Write out file buffer to disk                */
  694. /************************************************************************/
  695. ddump()
  696. {
  697.    long count;
  698.    long num;
  699.  
  700.    count = (long)docptr - (long)docbuf;
  701.    if((num = Fwrite(fhandle,count,docbuf)) >= 0)
  702.    {
  703.      docptr = docbuf;
  704.      return(1);                    /* ok */
  705.    }
  706.    return(0);                    /* error */
  707. }
  708.  
  709.  
  710.  
  711.  
  712.  
  713. /************************************************************************/
  714. /* Function: load_doc()                            */
  715. /* Description:                                */
  716. /*     Load a document from disk and set up region, article, and page  */
  717. /*    structures.                            */
  718. /************************************************************************/
  719. load_doc(docname)
  720. char *docname;
  721. {
  722.    long bufsize;
  723.    int dummy;
  724.    long magic;
  725.    int i;
  726.  
  727.    if(docname)
  728.    {
  729.       strcat(fbuffer,docname);
  730.    }
  731.    else
  732.    {
  733.       strcpy(pathbuf,dpath4);
  734.       strcat(pathbuf,"*.DS2");
  735.       if(!get_fs(fbuffer,&dummy))
  736.       {
  737.       return;
  738.       }
  739.       extender(fbuffer,".DS2");
  740.    }
  741.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  742.    if(Fsfirst(fbuffer,0) <= -1)
  743.    {
  744.       alert_cntre(ALERT8);
  745.       return;
  746.    }
  747.    bufsize = thedta.fsize;
  748.    if(!bufsize)
  749.    {
  750.       alert_cntre(ALERT39);
  751.       return;
  752.    }
  753.  
  754.    docbuf = (char *)lcalloc(1L,bufsize);
  755.    if(!docbuf)
  756.    {
  757.     alert_cntre(ALERT12);
  758.     return;
  759.    }
  760.  
  761.    docptr = docbuf;
  762.    if((fhandle = Fopen(fbuffer,0)) <= 0)
  763.    {
  764.     free(docbuf);
  765.     alert_cntre(ALERT16);
  766.     return;
  767.    }
  768.    bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  769.    if(bytes_in < thedta.fsize)
  770.    {
  771.     free(docbuf);
  772.     alert_cntre(ALERT17);
  773.         Fclose(fhandle);
  774.     return;
  775.    }
  776.    Fclose(fhandle);
  777.  
  778.    erase_all(1);                /* Start fresh         */
  779.    dread(&magic,4);
  780.    if(magic != 0x12445334L)        /* Magic value 12DS34 */
  781.    {
  782.     free(docbuf);
  783.     alert_cntre(ALERT29);
  784.     return;
  785.    }   
  786.    if(read_pages()   && 
  787.    read_articles()   &&
  788.    read_regions())
  789.     ;        /* Everything is OK */
  790.    else
  791.    {
  792.         alert_cntre(ALERT12);        /* Not enough memory    */
  793.     dbase_cleanup();
  794.     free(rtable);
  795.     free(docbuf);
  796.         return;
  797.    }
  798.    
  799.    free(rtable);
  800.    fixup_rptrs();
  801.    load_arts();
  802.    clear_tags();
  803.    read_tags();
  804.    read_setp();
  805.    sysfiles();                /* setup setp files */
  806.    read_ptype();
  807.    read_pnums();            /* read page number info*/
  808.  
  809.    curpage = pagehd;
  810.    curr_page = pagehd->pagenum;
  811.  
  812.    free(docbuf);
  813.  
  814.    strcpy(pfname," ");
  815.    if(docname)
  816.     strcat(pfname,docname);
  817.    else
  818.         strcat(pfname,fname);
  819.    strcat(pfname," ");
  820.    wind_set(prev_handle,WF_NAME,pfname,0,0);
  821.    do_pagenum(curr_page,(curr_page%2)?1:0);
  822.  
  823.    hpage_size = pagemux[pagetype - PA4];
  824.    vpage_size = pagemuy[pagetype - PA4];
  825.    page_area.g_x = page_area.g_y = 0L;
  826.    mutomem(hpage_size,vpage_size,&scan_xres,&scan_yres);
  827.    if(pagetype == PLEGAL + 4)    /* Legal Landscape   ? */
  828.    {                /* view_size == P200 or PADJCNT? */
  829.        if((view_size == P200) || (view_size == PADJCNT))
  830.        {
  831.                                   view_size = PACTUAL;
  832.           for(i=PSIZE;i<= PADJCNT;i++)
  833.               menu_icheck(ad_menu,i,FALSE);
  834.           menu_icheck(ad_menu,view_size,TRUE);
  835.           wind_set(prev_handle,WF_INFO,winfo[view_size - PSIZE][unit_type]);
  836.        }
  837.        menu_ienable(ad_menu,P200,FALSE);
  838.        menu_ienable(ad_menu,PADJCNT,FALSE);
  839.    }
  840.    else
  841.    {
  842.        menu_ienable(ad_menu,P200,TRUE);
  843.        menu_ienable(ad_menu,PADJCNT,TRUE);
  844.    }
  845.    gsx_moff();
  846.    vsf_interior(shandle,0);
  847.  
  848.    if((view_size == PSIZE) ||
  849.       (view_size == PADJCNT))
  850.           pdraw_fit(view_size);
  851.    else
  852.       pdraw_scale();
  853.  
  854.    vr_recfl(shandle,pxy);
  855.    gsx_mon();
  856.    zoom_setup();
  857.    cur_scale = get_scale_num(view_size);
  858.    get_work(prev_handle);
  859.    update_preview_blit();
  860.    clear_window(prev_handle,2,1);
  861.    set_clip(TRUE,&pwork);
  862.  
  863.    graf_mouse(2,&dummy);
  864.  
  865.    init_rulers();
  866.    recalc_txtptrs();
  867.    force_preview();
  868.    slider_chk();
  869.    graf_mouse(ARROW,&dummy);
  870. }
  871.  
  872.  
  873. /************************************************************************/
  874. /*    Clean up data structures of pages,articles, and regions        */
  875. /************************************************************************/
  876. dbase_cleanup()
  877. {
  878. register PAGE *tpage;
  879. PAGE *npage;
  880. register ARTICLE *tart;
  881. ARTICLE *nart;
  882.  
  883.    tpage = npage = pagehd;        /* Clean up pages     */
  884.    while(tpage)
  885.    {
  886.     npage = tpage->nextpage;
  887.     free(tpage);
  888.      tpage = npage;
  889.    }
  890.    tart = nart = arthd;            /* Clean up articles    */
  891.    while(tart)
  892.    {
  893.     nart = tart->nextart;
  894.     free(tart);
  895.      tart = nart;
  896.    }
  897.    clean_regions();
  898.    pagehd = (PAGE *)0L;
  899.    arthd  = (ARTICLE *)0L;
  900. }
  901.  
  902.  
  903. /************************************************************************/
  904. /*    Clean up regions in rtable along with their prims and ptsblks   */
  905. /************************************************************************/
  906. clean_regions()
  907. {
  908. REGION *rptr;
  909. PRIMITIVE *nprim;
  910. register PRIMITIVE *tprim;
  911. PTSBLK *nblk;
  912. PTSBLK *tblk;
  913. register int i;
  914.  
  915.    for(i = 0; i < gl_rcount;i++)        /* Clean up regions       */
  916.    {
  917.     rptr = (REGION *)rtable[i];
  918.        tprim = nprim = rptr->primlist;        /* Clean up primitives    */
  919.     while(tprim)
  920.         {
  921.        nprim = tprim->nextprim;
  922.           tblk = nblk = tprim->blkptr;      /* Clean up blocks      */
  923.        while(tblk)
  924.            {
  925.           nblk = tblk->nextblk;
  926.           free(tblk);
  927.            tblk = nblk;
  928.            }    
  929.        free(tprim);
  930.         tprim = nprim;
  931.         }    
  932.         free(rptr);
  933.     }
  934. }
  935.  
  936. /************************************************************************/
  937. /* Function: load_arts()                        */
  938. /* Description: load articles from disk                    */
  939. /************************************************************************/
  940. load_arts()
  941. {
  942. register ARTICLE *aptr;
  943. ARTICLE *naptr;
  944. ARTICLE *pptr;
  945.  
  946. register REGION  *rptr;
  947. REGION  *rnext;
  948.  
  949.    aptr = arthd;
  950.    while(aptr)
  951.    {
  952.     strcpy(fbuffer,dpath1);
  953.     strcat(fbuffer,&aptr->filename[0]);
  954.     if(!loadfile(fbuffer))
  955.         {
  956.        rptr = aptr->regptr;
  957.  
  958.        while(rptr)
  959.            {
  960.         rptr->artptr = 0L;        /* clear ptr to article    */
  961.         rnext = rptr->alink;           
  962.         rptr->alink = 0L;        /* clear ptr to next region*/
  963.                 rptr = rnext;            /* go on to next article   */
  964.            }
  965.            aptr->filename[0] = '\0';        /* clear filename of articl*/
  966.            aptr->regptr = 0L;                /* zero it out */
  967.        aptr->dirty  = 0;
  968.        
  969.         }
  970.         else
  971.         {
  972.         aptr->buf_start = buf_start;
  973.         aptr->buf_end = buf_end;
  974.         aptr->free_start = free_start;
  975.         aptr->current_char = current_char;
  976.         aptr->dirty  = 0;
  977.         }
  978.     aptr = aptr->nextart;
  979.    }
  980.  
  981.    pptr = aptr = arthd;
  982.    while(aptr)
  983.    {
  984.  
  985.       if(aptr->regptr == 0L)
  986.       {
  987.  
  988.       if(aptr == arthd)
  989.           {
  990.               naptr = aptr->nextart;
  991.           arthd = pptr = naptr;
  992.           free(aptr);
  993.            aptr = naptr;
  994.           }
  995.           else
  996.           {
  997.         naptr = aptr->nextart;
  998.         pptr->nextart = naptr;
  999.         free(aptr);
  1000.         aptr = naptr;
  1001.           }
  1002.  
  1003.       }
  1004.       else
  1005.       {
  1006.  
  1007.      pptr = aptr;
  1008.          aptr = aptr->nextart;
  1009.       }
  1010.    }
  1011.  
  1012.    return(1);
  1013. }
  1014.  
  1015.  
  1016.  
  1017.  
  1018. /**********************************************************************/
  1019. /* Function: getrptr()                              */
  1020. /* Description: get region pointer from region table              */
  1021. /**********************************************************************/
  1022. REGION *getrptr(index)
  1023. int index;
  1024. {
  1025.    if(index == 0xffff)
  1026.     return (REGION *)0L;
  1027.    else
  1028.         return (REGION *)rtable[index];   
  1029. }
  1030.  
  1031.  
  1032.  
  1033.  
  1034. /**********************************************************************/
  1035. /* Function: fixup_rptrs()                          */
  1036. /* Description: Fixup region pointers after loading...              */
  1037. /**********************************************************************/
  1038. fixup_rptrs()
  1039. {
  1040.    register REGION *rptr;
  1041.    register ARTICLE *aptr;
  1042.    register PAGE *pptr;
  1043.    register int i;
  1044.  
  1045.    for(i = 0;i < gl_rcount;i++)
  1046.    {
  1047.     rptr = (REGION *)rtable[i];
  1048.     rptr->alink = getrptr((int)rptr->alink);
  1049.     rptr->plink = getrptr((int)rptr->plink);
  1050.    }
  1051.    pptr = pagehd;
  1052.    while(pptr)
  1053.    {
  1054.     pptr->regptr = getrptr((int)pptr->regptr);
  1055.       pptr = pptr->nextpage;
  1056.    }
  1057.    aptr = arthd;
  1058.    while(aptr)
  1059.    {
  1060.     aptr->regptr = getrptr((int)aptr->regptr);
  1061.     aptr = aptr->nextart;
  1062.    }
  1063. }
  1064.  
  1065.  
  1066.  
  1067. /**********************************************************************/
  1068. /* Function: aindex_to_ptr()                          */
  1069. /* Description: Return article index pointer                  */
  1070. /**********************************************************************/
  1071. ARTICLE *aindex_to_ptr(index)
  1072. unsigned int index;
  1073. {
  1074.    register int i;
  1075.    register ARTICLE *aptr;
  1076.  
  1077.    if(index == 0xffff)
  1078.     return (ARTICLE *)0L;
  1079.    aptr = arthd;
  1080.    for(i = 0; i < index;i++)
  1081.     aptr = aptr->nextart;
  1082.    return aptr;
  1083. }
  1084.  
  1085.  
  1086.  
  1087.  
  1088. /**********************************************************************/
  1089. /* Function: read_regions()                          */
  1090. /* Description: Read regions from disk                      */
  1091. /**********************************************************************/
  1092. read_regions()
  1093. {
  1094.    long rtblsize;
  1095.    register REGION  *rptr;
  1096.    unsigned int rindex;
  1097.    unsigned int aindex;
  1098.    long temp;
  1099.    register int i;
  1100.  
  1101.    dread(&gl_rcount,2);
  1102.    rtblsize = 4L * (long)gl_rcount;
  1103.    if(!(rtable = (long *)lmalloc(rtblsize)))
  1104.                        return(0);
  1105.    for(i = 0;i < gl_rcount;i++)
  1106.    {
  1107.       if(!(rptr = (REGION *)calloc(1,sizeof(REGION))))
  1108.                         return(0);
  1109.       rtable[i] = (long)rptr;
  1110.       dread(&aindex,2);
  1111.       rptr->artptr = aindex_to_ptr(aindex);
  1112.       dread(&rindex,2);
  1113.       temp = ((long)rindex & 0xffff);
  1114.       rptr->plink = (REGION *)temp;
  1115.       dread(&rindex,2);
  1116.       temp = ((long)rindex & 0xffff);
  1117.       rptr->alink = (REGION *)temp;
  1118.       dread(&rptr->x1,10);            /* Read x1,y1,x2,y2,p     */
  1119.       dread(&rptr->reserved,4);            /* 2 reserved words      */
  1120.       dread(&rptr->text,sizeof(struct txtattr));/* Read text attributes   */
  1121.       dread(&rptr->grattr[0],2*11);        /* Graphic attributes     */
  1122.       dread(&rptr->type,2);            /* Read type          */    
  1123.       if(!read_prims(rptr))            /* Read in primitives     */
  1124.               return(0);
  1125.    }
  1126.    return(1);
  1127. }
  1128.  
  1129.  
  1130.  
  1131.  
  1132. /**********************************************************************/
  1133. /* Function: read_prims()                          */
  1134. /* Description: read primitives from disk                  */
  1135. /**********************************************************************/
  1136. read_prims(rptr)
  1137. REGION *rptr;
  1138. {
  1139.    register int i,j,k;
  1140.    int pcount;
  1141.    PRIMITIVE *prevprim;
  1142.    PRIMITIVE  *newprim;
  1143.    register PTSBLK *curblk;
  1144.    register int count;
  1145.  
  1146.    dread(&pcount,2);
  1147.    if(!(prevprim = (PRIMITIVE *)calloc(1,sizeof(PRIMITIVE))))
  1148.                             return(0);
  1149.    rptr->primlist = prevprim;
  1150.  
  1151.    for(i = 0;i < pcount;i++)
  1152.    {
  1153.       dread(&prevprim->op,6);            /* Read op,wrmode,#pts */
  1154.       if(!(curblk = (PTSBLK *)calloc(1,sizeof(PTSBLK))))
  1155.                                return(0);
  1156.       curblk->nextblk = 0L;
  1157.       prevprim->blkptr = curblk;
  1158.       count = prevprim->numpts;
  1159.       count *= 2;            /* count = # vertices */
  1160.       dread(ptsarray,count*2);        /* times 2 for # of chars */
  1161.       j = k = 0;
  1162.       while(count--)
  1163.       {
  1164.     curblk->points[j++] = ptsarray[k++];
  1165.       if(j >= MAXBLK)
  1166.      {
  1167.        if(!(curblk->nextblk = (PTSBLK *)calloc(1,sizeof(PTSBLK))))
  1168.                                         return(0);
  1169.        curblk = curblk->nextblk;
  1170.        curblk->nextblk = 0L;
  1171.        j = 0;
  1172.     }
  1173.       }
  1174.       if(i == pcount - 1)
  1175.     newprim = 0L;
  1176.       else
  1177.       {
  1178.         if(!(newprim = (PRIMITIVE *)calloc(1,sizeof(PRIMITIVE))))
  1179.                             return(0);
  1180.       }
  1181.       prevprim->nextprim = newprim;
  1182.       prevprim = newprim;
  1183.    }
  1184.    return(1);
  1185. }
  1186.  
  1187.  
  1188.  
  1189.  
  1190. /**********************************************************************/
  1191. /* Function: read_pages()                          */
  1192. /* Description: read pages from disk                      */
  1193. /**********************************************************************/
  1194. read_pages()
  1195. {
  1196.    int pcount;
  1197.    PAGE *newpage;
  1198.    register PAGE *prevpage;
  1199.    unsigned int rindex;
  1200.    long temp;
  1201.    register int i;
  1202.    int pagenum;
  1203.  
  1204.    dread(&pcount,2);
  1205.    if(!(prevpage = (PAGE *)calloc(1,sizeof(PAGE))))
  1206.                         return(0);
  1207.    pagehd = prevpage;
  1208.  
  1209.    for(i = 0;i < pcount;i++)
  1210.    {
  1211.       dread(&pagenum,2);
  1212.       prevpage->pagenum = pagenum;
  1213.       dread(&rindex,2);
  1214.       temp = ((long)rindex & 0xffff);
  1215.       prevpage->regptr = (REGION *)temp;
  1216.       if(i == pcount - 1)
  1217.     newpage = 0L;
  1218.       else
  1219.       {
  1220.         if(!(newpage = (PAGE *)calloc(1,sizeof(PAGE))))
  1221.                         return(0);
  1222.       }
  1223.       prevpage->nextpage = newpage;
  1224.       prevpage = newpage;
  1225.    }
  1226.    return(1);
  1227. }
  1228.  
  1229.  
  1230.  
  1231.  
  1232. /**********************************************************************/
  1233. /* Function: read_articles()                          */
  1234. /* Description: read articles from disk                      */
  1235. /**********************************************************************/
  1236. read_articles()
  1237. {
  1238.    int acount;
  1239.    ARTICLE *newart;
  1240.    register ARTICLE *prevart;
  1241.    unsigned int rindex;
  1242.    long temp;
  1243.    register int i;
  1244.  
  1245.    dread(&acount,2);
  1246.    if(acount == 0)
  1247.     return(1);
  1248.    if(!(prevart = (ARTICLE *)calloc(1,sizeof(ARTICLE))))
  1249.                         return(0);
  1250.    arthd = prevart;
  1251.  
  1252.    for(i = 0;i < acount;i++)
  1253.    {
  1254.       dread(&rindex,2);
  1255.       temp = ((long)rindex & 0xffff);
  1256.       prevart->regptr = (REGION *)temp;        /* Fill in the first region */
  1257.       dread(&prevart->filename[0],40);        /* Fill in the file name */
  1258.       if(i == acount - 1)
  1259.     newart = 0L;
  1260.       else
  1261.       {
  1262.         if(!(newart = (ARTICLE *)calloc(1,sizeof(ARTICLE))))
  1263.                             return(0);
  1264.       }
  1265.       prevart->nextart = newart;
  1266.       prevart = newart;
  1267.    }
  1268.    return(1);
  1269. }
  1270.  
  1271.  
  1272.  
  1273.  
  1274. /**********************************************************************/
  1275. /* Function: getaindex()                          */
  1276. /* Description: get article index                      */
  1277. /**********************************************************************/
  1278. getaindex(aptr)
  1279. ARTICLE *aptr;
  1280. {
  1281.    register int i;
  1282.  
  1283.    i = 0;
  1284.    while(atable[i])
  1285.    {
  1286.     if(atable[i] == (long)aptr)
  1287.     {
  1288.        return i;
  1289.     }
  1290.     i++;
  1291.    }
  1292. }
  1293.  
  1294.  
  1295.  
  1296.  
  1297. /**********************************************************************/
  1298. /* Function: getrindex()                          */
  1299. /* Description: get region index()                      */
  1300. /**********************************************************************/
  1301. getrindex(rptr)
  1302. REGION *rptr;
  1303. {
  1304.    register int i;
  1305.    i = 0;
  1306.    while(rtable[i])
  1307.    {
  1308.     if(rtable[i] == (long)rptr)
  1309.     {
  1310.        return i;
  1311.     }
  1312.         i++;
  1313.    }
  1314. }
  1315.  
  1316.  
  1317.  
  1318.  
  1319.  
  1320. /************************************************************************/
  1321. /* Function: save_clipb()                        */
  1322. /* Description:    Save clipboard to disk                    */
  1323. /************************************************************************/
  1324. save_clipb()
  1325. {
  1326.    unsigned long rtblsize;
  1327.    register unsigned int rcount;      
  1328.    register REGION *rptr;
  1329.    int i;
  1330.    int status;
  1331.  
  1332.    status = FALSE;
  1333.    if(!clipfull)    /* does this check the same thing as...*/
  1334.     return;
  1335.  
  1336.    if(!clippage->regptr)   /* this? Oh, well...just in case... */
  1337.         return;
  1338.  
  1339.    active_prim = FALSE;
  1340.    strcpy(pathbuf,dpath2);
  1341.    strcat(pathbuf,"*.CLP");
  1342.    if(!get_fs(fbuffer,&i))
  1343.    {
  1344.     return;
  1345.    }
  1346.    extender(fbuffer,".CLP");   
  1347.  
  1348.  
  1349.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1350.    if(Fsfirst(fbuffer,0) == 0)            /* File Already Exists  */
  1351.    {
  1352.     if(alert_cntre(ALERT37) == 2)        /* Cancel Button pressed*/
  1353.             return;
  1354.    }
  1355.  
  1356.  
  1357.    if((fhandle = Fcreate(fbuffer,0)) <=0)
  1358.    {
  1359.     alert_cntre(ALERT19);
  1360.     return;
  1361.    }
  1362.    docbuf = (char *)lmalloc(DOCSIZE);
  1363.    if(!docbuf)
  1364.    {
  1365.     alert_cntre(ALERT12);
  1366.     Fclose(fhandle);
  1367.     return;
  1368.    }
  1369.    docptr = docbuf;
  1370.    docend = docbuf + DOCSIZE - 1;
  1371.    rcount = 0;            /* Initialize region count      */
  1372.  
  1373.    rptr = clippage->regptr;
  1374.    while(rptr)
  1375.    {
  1376.        rcount++;
  1377.        rptr = rptr->plink;
  1378.    }  
  1379.  
  1380.    rtblsize = 4L * ((long)rcount + 1L);
  1381.    rtable = (long *)lmalloc(rtblsize);
  1382.    if(!rtable)
  1383.    {
  1384.     free(docbuf);
  1385.     alert_cntre(ALERT12);
  1386.     Fclose(fhandle);
  1387.     return;
  1388.    }
  1389.    rptr = clippage->regptr;
  1390.    i = 0;
  1391.    while(rptr)
  1392.    {
  1393.          rtable[i++] = (long)rptr;
  1394.          rptr = rptr->plink;
  1395.    }  
  1396.    if(write_regions(rcount))
  1397.    {
  1398.          if(!ddump())    /* Dump the buffer        */
  1399.          alert_cntre(ALERT20);
  1400.    }
  1401.    else
  1402.      alert_cntre(ALERT20);            
  1403.    free(rtable);
  1404.    free(docbuf);
  1405.    Fclose(fhandle);            /* Close the file        */
  1406. }
  1407.  
  1408.  
  1409.  
  1410. /************************************************************************/
  1411. /* Function: load_clipb()                        */
  1412. /* Description:    Load clipboard                        */
  1413. /************************************************************************/
  1414. load_clipb()
  1415. {
  1416.    long bufsize;
  1417.    int i;
  1418.    REGION *rptr;
  1419.    int status;
  1420.  
  1421.    status = FALSE;
  1422.  
  1423.    strcpy(pathbuf,dpath2);
  1424.    strcat(pathbuf,"*.CLP");
  1425.    if(!get_fs(fbuffer,&i))
  1426.    {
  1427.     return NOFILE;
  1428.    }
  1429.    extender(fbuffer,".CLP");
  1430.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1431.    if(Fsfirst(fbuffer,0) <= -1)
  1432.    {
  1433.     alert_cntre(ALERT8);
  1434.     return NOFILE;
  1435.    }
  1436.  
  1437.    if(!thedta.fsize)
  1438.    {
  1439.     alert_cntre(ALERT39);
  1440.         return(1);
  1441.    }
  1442.    delete_clip();
  1443.    clippage = (PAGE *)get_lcmem((long)sizeof(PAGE));
  1444.    if(!clippage)
  1445.    {
  1446.     alert_cntre(ALERT12);
  1447.     return(1);
  1448.    }
  1449.    bufsize = thedta.fsize;
  1450.    docbuf = (char *)lcalloc(1L,bufsize);
  1451.    if(!docbuf)
  1452.    {
  1453.     free(clippage);
  1454.     alert_cntre(ALERT12);
  1455.     return(1);
  1456.    }
  1457.    docptr = docbuf;
  1458.    fhandle = Fopen(fbuffer,0);
  1459.    if(fhandle <= 0)
  1460.    {
  1461.     free(clippage);
  1462.     free(docbuf);
  1463.     alert_cntre(ALERT16);
  1464.     return(1);
  1465.    }
  1466.    bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  1467.    if(bytes_in < thedta.fsize)
  1468.    {
  1469.     free(clippage);
  1470.     free(docbuf);
  1471.     alert_cntre(ALERT17);
  1472.         Fclose(fhandle);
  1473.     return(1);
  1474.    }
  1475.    Fclose(fhandle);
  1476.    if(!read_regions())
  1477.    {
  1478.     clean_regions();
  1479.     alert_cntre();
  1480.     free(rtable);
  1481.     free(docbuf);
  1482.     free(clippage);
  1483.     return(1);
  1484.    }
  1485.    for(i = 0;i < gl_rcount;i++)
  1486.    {
  1487.         rptr = (REGION *)rtable[i];
  1488.         rptr->plink = getrptr((int)rptr->plink);
  1489.    }
  1490.    clippage->regptr = (REGION *)rtable[0];
  1491.  
  1492.    free(rtable);
  1493.    free(docbuf);
  1494.    return(0);            /* normal return   */
  1495. }
  1496.  
  1497.  
  1498.  
  1499.  
  1500.  
  1501.  
  1502. /**********************************************************************/
  1503. /* Function: extender()                              */
  1504. /* Description: handle file name extenders                  */
  1505. /**********************************************************************/
  1506. extender(fname,ext)
  1507. char *fname;
  1508. register char *ext;
  1509. {
  1510.      register char *s;
  1511.      
  1512.      s = fname;
  1513.      while((*s != '.') && (*s != '\0'))
  1514.                 *s++;
  1515.  
  1516.      if(*s == '\0')
  1517.       strcat(fname,ext);
  1518.      else
  1519.      {    
  1520.        *s++;
  1521.        *ext++;
  1522.        if(*s == '\0')
  1523.       strcat(fname,ext);
  1524.      }
  1525. }
  1526.  
  1527.  
  1528.  
  1529.  
  1530. load_path()
  1531. {
  1532.    long bufsize;
  1533.    
  1534.    Fsetdta(&thedta.res[0]);
  1535.    if(Fsfirst("DESK2.PTH",0) <= -1)
  1536.    {
  1537.     return(0);            /* path file not found */
  1538.    }                    /* so use the defaults */
  1539.    bufsize = thedta.fsize;
  1540.    if(bufpath = lcalloc(1L,bufsize))
  1541.    {
  1542.       fhandle = Fopen("DESK2.PTH",0);
  1543.       bytes_in = Fread(fhandle,thedta.fsize,bufpath);
  1544.       Fclose(fhandle);
  1545.       return(1);
  1546.    }
  1547. }
  1548.  
  1549.  
  1550.  
  1551. write_paths(dpath1,dpath2,dpath3,dpath4)
  1552. char *dpath1;
  1553. char *dpath2;
  1554. char *dpath3;
  1555. char *dpath4;
  1556. {
  1557.         pbufindex = 0;
  1558.     add_slash(dpath1);
  1559.     bputstr(dpath1);
  1560.     bputcr();
  1561.     add_slash(dpath2);
  1562.     bputstr(dpath2);
  1563.     bputcr();
  1564.     add_slash(dpath3);
  1565.     bputstr(dpath3);
  1566.     bputcr();
  1567.     add_slash(dpath4);
  1568.     bputstr(dpath4);
  1569.     bputcr();
  1570.    
  1571.     if( (fhandle = Fcreate("DESK2.PTH",0)) > 0)
  1572.         {
  1573.        Fwrite(fhandle,200L,pbuff);
  1574.        Fclose(fhandle);
  1575.         }
  1576. }
  1577.  
  1578.  
  1579.  
  1580. store_paths(dpath1,dpath2,dpath3,dpath4)
  1581. char *dpath1;
  1582. char *dpath2;
  1583. char *dpath3;
  1584. char *dpath4;
  1585. {
  1586.         pbufindex = 0;
  1587.     bputstr(dpath1);
  1588.     bputcr();
  1589.     bputstr(dpath2);
  1590.     bputcr();
  1591.     bputstr(dpath3);
  1592.     bputcr();
  1593.     bputstr(dpath4);
  1594.     bputcr();
  1595. }
  1596.  
  1597.  
  1598. bputstr(str)
  1599. register char *str;
  1600. {
  1601.    while(*str)
  1602.       pbuff[pbufindex++] = *str++;
  1603. }
  1604.  
  1605.  
  1606. bputcr()
  1607. {
  1608.    pbuff[pbufindex++] = 0x0D;
  1609.    pbuff[pbufindex++] = 0x0A;
  1610. }
  1611.  
  1612.  
  1613.  
  1614. read_path(dpath1,dpath2,dpath3,dpath4)
  1615. char *dpath1;
  1616. char *dpath2;
  1617. char *dpath3;
  1618. char *dpath4;
  1619. {
  1620.    pbufindex = 0;
  1621.  
  1622.    Fsetdta(&thedta.res[0]);
  1623.    if(Fsfirst("DESK2.PTH",0) <= -1)
  1624.    {
  1625.     return(0);
  1626.    }
  1627.    fhandle = Fopen("DESK2.PTH",0);
  1628.    bytes_in = Fread(fhandle,thedta.fsize,pbuff);
  1629.    Fclose(fhandle);
  1630.  
  1631.    bgetstr(dpath1);
  1632.    bgetstr(dpath2);
  1633.    bgetstr(dpath3);
  1634.    bgetstr(dpath4);
  1635.    return(1);
  1636. }
  1637.  
  1638.  
  1639.  
  1640. bgetstr(dpath)
  1641. register char *dpath;
  1642. {
  1643.      while(pbuff[pbufindex] != 0x0D)
  1644.         *dpath++ = pbuff[pbufindex++];
  1645.      pbufindex++;            /* get rid of 0x0D */   
  1646.      pbufindex++;            /* get rid of 0x0A */   
  1647.      *dpath++ = 0x0;
  1648. }
  1649.  
  1650.  
  1651.  
  1652. restore_paths(dpath1,dpath2,dpath3,dpath4)
  1653. char *dpath1;
  1654. char *dpath2;
  1655. char *dpath3;
  1656. char *dpath4;
  1657. {
  1658.    pbufindex = 0;
  1659.    bgetstr(dpath1);
  1660.    bgetstr(dpath2);
  1661.    bgetstr(dpath3);
  1662.    bgetstr(dpath4);
  1663. }
  1664.  
  1665.  
  1666.  
  1667. remove_path(str)
  1668. char *str;
  1669. {
  1670.    char s[100];
  1671.    register int  i; 
  1672.  
  1673.    i = 0;
  1674.    strcpy(&s[0],str);
  1675.  
  1676.    while(s[i++]);
  1677.  
  1678.    while(s[i-1] != '\\' && i)
  1679.        i--;
  1680.    strcpy(str,&s[i]);
  1681. }
  1682.  
  1683.  
  1684.  
  1685. write_ptype()
  1686. {
  1687.     if(!dwrite(&pagetype,2))
  1688.             return(0);
  1689.     else return(1);
  1690. }
  1691.  
  1692.  
  1693.  
  1694. read_ptype()
  1695. {
  1696.    dread(&pagetype,2);            /* Don't forget landscape */
  1697.    if( (pagetype >= PA4) && (pagetype <= (PLEGAL + 4))) /* <- + 4 */
  1698.                 return;
  1699.    else
  1700.       pagetype = PLETTER;
  1701. }
  1702.  
  1703.  
  1704.  
  1705. write_tmplates()
  1706. {
  1707.   register unsigned int pcount,acount,rcount;
  1708.   unsigned long rtblsize;
  1709.   unsigned long atblsize;
  1710.   int lap;
  1711.   ARTICLE *aptr;
  1712.   REGION *rptr;
  1713.  
  1714.   for(lap = 0;lap <= 1;lap++)
  1715.   {
  1716.     if(lap)
  1717.     {
  1718.       pagehd = curpage = right_tmplate;
  1719.       curr_page = right_tmplate->pagenum;
  1720.       arthd = rtarthd;
  1721.     }
  1722.     else
  1723.     {
  1724.       pagehd = curpage = left_tmplate;
  1725.       curr_page = left_tmplate->pagenum;
  1726.       arthd = ltarthd;
  1727.     }
  1728.     
  1729.     pcount = 1;
  1730.     acount = rcount = 0;
  1731.     rptr = get_fregion(curr_page,&dummy,&dummy,&dummy,&dummy,&dummy);
  1732.     while(rptr)
  1733.     {
  1734.       rcount++;
  1735.       rptr = get_nregion(&dummy,&dummy,&dummy,&dummy,&dummy);
  1736.     }
  1737.  
  1738.     rtblsize = 4L * ((long)rcount + 1L);
  1739.  
  1740.     rtable = (long *)lmalloc(rtblsize);
  1741.     if(!rtable)
  1742.     {
  1743.     alert_cntre(ALERT12);
  1744.     return;
  1745.     }
  1746.     rtbl_setup();
  1747.     aptr = getf_article();
  1748.     while(aptr)
  1749.     {
  1750.     acount++;
  1751.     aptr = getn_article();
  1752.     }
  1753.     atblsize = 4L * ((long)acount + 1L);
  1754.     atable = (long *)lmalloc(atblsize);
  1755.     if(!atable)
  1756.     {
  1757.     free(rtable);
  1758.     alert_cntre(ALERT12);
  1759.     return;
  1760.     }
  1761.     atbl_setup();
  1762.     if(write_pages(pcount)     &&
  1763.        write_articles(acount)  &&
  1764.        write_regions(rcount))
  1765.     ;
  1766.     else
  1767.     {    
  1768.     alert_cntre(ALERT20);
  1769.         free(atable);
  1770.         free(rtable);
  1771.     return;
  1772.     }
  1773.     free(atable);
  1774.     free(rtable);
  1775.   }
  1776.   if(!ddump())
  1777.     alert_cntre(ALERT20);
  1778.   return;
  1779. }
  1780.  
  1781.  
  1782. read_tmplates()
  1783. {
  1784.   int i;
  1785.  
  1786.   for(i=0;i<=1;i++)
  1787.   {
  1788.     pagehd = curpage = ((i)?(right_tmplate):(left_tmplate)); 
  1789.     arthd = ((i)?(rtarthd):(ltarthd));
  1790.     tread_pages();
  1791.     read_articles();
  1792.     read_regions();
  1793.     fixup_rptrs();
  1794.     load_arts();
  1795.     recalc_txtptrs();  
  1796.     if(rtable)
  1797.          free(rtable);
  1798.     if(i)
  1799.       rtarthd = arthd;
  1800.     else
  1801.     ltarthd = arthd;
  1802.   }
  1803.   return(1);
  1804. }
  1805.  
  1806.  
  1807.  
  1808. tread_pages()
  1809. {
  1810.   int pcount;
  1811.   int pagenum;
  1812.   unsigned int rindex;
  1813.   long temp;
  1814.   register PAGE *prevpage;
  1815.  
  1816.   prevpage = pagehd;  
  1817.   dread(&pcount,2);
  1818.   dread(&pagenum,2);
  1819.   prevpage->pagenum = pagenum;
  1820.   dread(&rindex,2);
  1821.   temp = ((long)rindex & 0xffff);
  1822.   prevpage->regptr = (REGION *)temp;
  1823.   prevpage->nextpage = 0L;
  1824. }
  1825.  
  1826.  
  1827.  
  1828.  
  1829. load_tmplate()
  1830. {
  1831.  
  1832.    long bufsize;
  1833.    int dummy;
  1834.  
  1835.    strcpy(pathbuf,dpath2);
  1836.    strcat(pathbuf,"*.BPL");
  1837.    if(!get_fs(fbuffer,&dummy))
  1838.    {
  1839.     return;
  1840.    }
  1841.    extender(fbuffer,".BPL");
  1842.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1843.    if(Fsfirst(fbuffer,0) <= -1)
  1844.    {
  1845.     alert_cntre(ALERT8);
  1846.     return;
  1847.    }
  1848.    rtmplate_flag = tmplate_flag;
  1849.    rtemp_page = curr_page;
  1850.    rpagehd    = pagehd;
  1851.    rcurpage   = curpage;
  1852.    rarthd     = arthd;
  1853.  
  1854.    bufsize = thedta.fsize;
  1855.  
  1856.    if(!bufsize)
  1857.    {
  1858.     alert_cntre(ALERT39);
  1859.     return;
  1860.    }
  1861.  
  1862.    docbuf = (char *)lcalloc(1L,bufsize);
  1863.    if(!docbuf)
  1864.    {
  1865.     alert_cntre(ALERT12);
  1866.     return;
  1867.    }
  1868.    docptr = docbuf;
  1869.    if((fhandle = Fopen(fbuffer,0)) <= 0)
  1870.    {
  1871.     alert_cntre(ALERT16);
  1872.     free(docbuf);
  1873.     return;
  1874.    }
  1875.    bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  1876.    if(bytes_in < thedta.fsize)
  1877.    {
  1878.     alert_cntre(ALERT17);
  1879.     free(docbuf);
  1880.         Fclose(fhandle);
  1881.     return;
  1882.    }
  1883.    Fclose(fhandle);
  1884.    delete_tmplates();
  1885.    if(!read_tmplates())
  1886.    {
  1887.     free(docbuf);
  1888.         tmplate_flag = rtmplate_flag;
  1889.         curr_page    = rtemp_page;
  1890.         pagehd       = rpagehd;
  1891.         curpage      = rcurpage;
  1892.          arthd         = rarthd;
  1893.     return;
  1894.    }
  1895.    free(docbuf);
  1896.    strcpy(basefname," ");
  1897.    strcat(basefname,fname);
  1898.    strcat(basefname," ");
  1899.  
  1900.    tmplate_flag = rtmplate_flag;
  1901.  
  1902.    if(tmplate_flag)
  1903.    {
  1904.      pagehd = curpage = ((curr_page % 2) ? (right_tmplate):(left_tmplate));
  1905.      curr_page = pagehd->pagenum;
  1906.      arthd = ((curr_page % 2)?(rtarthd):(ltarthd));
  1907.      wind_set(prev_handle,WF_NAME,basefname,0,0);
  1908.    }
  1909.    else
  1910.    {
  1911.      curr_page    = rtemp_page;
  1912.      pagehd       = rpagehd;
  1913.      curpage      = rcurpage;
  1914.      arthd      = rarthd;
  1915.    }
  1916.    force_preview();
  1917. }
  1918.  
  1919.  
  1920.  
  1921.  
  1922.  
  1923.  
  1924. save_tmplate()
  1925. {
  1926.    int dummy;
  1927.  
  1928.    if(!right_tmplate->regptr && !left_tmplate->regptr)
  1929.                 return;
  1930.  
  1931.    strcpy(pathbuf,dpath2);
  1932.    strcat(pathbuf,"*.BPL");
  1933.    if(!get_fs(fbuffer,&dummy))
  1934.    {
  1935.        return;
  1936.    }
  1937.  
  1938.    push_tmplate();        /* Save global variables*/
  1939.  
  1940.  
  1941.    extender(fbuffer,".BPL");   
  1942.  
  1943.    Fsetdta(&thedta.res[0]);            /* Init a dta area    */
  1944.    if(Fsfirst(fbuffer,0) == 0)            /* File Already Exists  */
  1945.    {
  1946.     if(alert_cntre(ALERT37) == 2)        /* Cancel Button pressed*/
  1947.     {
  1948.        pop_tmplate();    
  1949.        return;
  1950.     }
  1951.    }
  1952.  
  1953.    if((fhandle = Fcreate(fbuffer,0)) <=0)
  1954.    {
  1955.     alert_cntre(ALERT19);
  1956.     pop_tmplate();
  1957.     return;
  1958.    }
  1959.    docbuf = (char *)lmalloc(DOCSIZE);
  1960.    if(!docbuf)
  1961.    {
  1962.     alert_cntre(ALERT12);
  1963.     pop_tmplate();
  1964.     return;
  1965.    }
  1966.    docptr = docbuf;
  1967.    docend = docbuf + DOCSIZE - 1;
  1968.    write_tmplates();
  1969.    free(docbuf);
  1970.    Fclose(fhandle);
  1971.  
  1972.    pop_tmplate();        /* Restore global variables */
  1973.    strcpy(basefname," ");
  1974.    strcat(basefname,fname);
  1975.    extender(basefname,".BPL");
  1976.    strcat(basefname," ");
  1977.    if(tmplate_flag)
  1978.         wind_set(prev_handle,WF_NAME,basefname,0,0);
  1979. }
  1980.  
  1981.  
  1982.  
  1983.  
  1984. write_pnums()
  1985. {
  1986.     if(!dwrite(&pnum,sizeof(struct pnumber)))
  1987.                 return(0);
  1988.     else return(1);
  1989. }
  1990.  
  1991.  
  1992.  
  1993. read_pnums()
  1994. {
  1995.     dread(&pnum,sizeof(struct pnumber));   
  1996. }
  1997.  
  1998.  
  1999.  
  2000.  
  2001.  
  2002. write_defaults()
  2003. {
  2004.    int fd;
  2005.  
  2006.    if((fd = Fcreate("DESK2.DFT",0)) > 0)
  2007.    {
  2008.     Fwrite(fd,102L,pstorage);
  2009.     Fwrite(fd,(long)pstorage[50],pnumtext);
  2010.     Fclose(fd);
  2011.    }
  2012.  
  2013. }
  2014.  
  2015.  
  2016.  
  2017.  
  2018. read_defaults()
  2019. {
  2020.      int fd;
  2021.      int nbytes;
  2022.  
  2023.      Fsetdta(&thedta.res[0]);
  2024.      if(Fsfirst("DESK2.DFT",0) <= -1)
  2025.                  return(0);
  2026.      fd = Fopen("DESK2.DFT",0);
  2027.      nbytes = Fread(fd,102L,pstorage);
  2028.      nbytes = Fread(fd,(long)pstorage[50],pnumtext);
  2029.      Fclose(fd);
  2030.      return(1);
  2031. }
  2032.  
  2033.  
  2034.  
  2035.  
  2036.  
  2037.  
  2038. /* Save these variables for save_doc()    */
  2039. /* this was necessary if in tmplate mode*/
  2040. push_sdoc()
  2041. {
  2042.    rtmplate_flag = tmplate_flag;
  2043.    rtemp_page = curr_page;
  2044.    if(tmplate_flag)
  2045.    {
  2046.       rpagehd = pagehd;
  2047.       rcurpage = curpage;
  2048.       rarthd   = arthd;
  2049.  
  2050.       pagehd = tpagehd;
  2051.       curpage = tcurpage;
  2052.       arthd   = tarthd;
  2053.  
  2054.       tmplate_flag = FALSE;
  2055.    }
  2056.  
  2057. }
  2058.  
  2059.  
  2060.  
  2061.  
  2062.  
  2063. /* Restore original variables for save_doc()*/
  2064. pop_sdoc()
  2065. {
  2066.    tmplate_flag = rtmplate_flag;
  2067.    curr_page = rtemp_page;
  2068.    if(tmplate_flag)
  2069.    {
  2070.      pagehd = rpagehd;
  2071.      curpage = rcurpage;
  2072.      arthd   = rarthd;
  2073.    }
  2074.  
  2075. }
  2076.  
  2077.  
  2078.  
  2079. /* Save global variables for save tmplate */
  2080. /* related to if in tmplate mode       */
  2081. push_tmplate()
  2082. {
  2083.    rtmplate_flag = tmplate_flag;
  2084.    rtemp_page = curr_page;
  2085.    rpagehd    = pagehd;
  2086.    rcurpage   = curpage;
  2087.    rarthd     = arthd;
  2088. }
  2089.  
  2090.  
  2091.  
  2092. /* Restore global variables in save_tmplate*/
  2093. pop_tmplate()
  2094. {
  2095.    arthd        = rarthd;
  2096.    tmplate_flag = rtmplate_flag;
  2097.    curr_page    = rtemp_page;
  2098.    pagehd       = rpagehd;
  2099.    curpage      = rcurpage;
  2100. }
  2101.  
  2102.  
  2103.  
  2104.  
  2105. add_slash(path)
  2106. char *path;
  2107. {
  2108.    int i;
  2109.  
  2110.    i = strlen(path);   
  2111.    if(path[i-1] != '\\')
  2112.     strcat(path,"\\");
  2113. }
  2114.  
  2115.  
  2116.  
  2117. load_tags()
  2118. {
  2119.   int dummy;
  2120.   long bufsize;
  2121.  
  2122.   strcpy(pathbuf,dpath2);
  2123.   strcat(pathbuf,"*.TAG");
  2124.   if(!get_fs(fbuffer,&dummy))
  2125.   {
  2126.     return;
  2127.   }
  2128.  
  2129.   extender(fbuffer,".TAG");
  2130.   Fsetdta(&thedta.res[0]);
  2131.   if(Fsfirst(fbuffer,0) <= -1)
  2132.   {
  2133.      alert_cntre(ALERT8);
  2134.      return;
  2135.   }
  2136.  
  2137.   
  2138.   bufsize = thedta.fsize;
  2139.   if(!bufsize)
  2140.   {
  2141.     alert_cntre(ALERT39);
  2142.     return;
  2143.   }
  2144.  
  2145.   docbuf  = (char *)lcalloc(1L,bufsize);
  2146.   if(!docbuf)
  2147.   {
  2148.     alert_cntre(ALERT12);
  2149.     return;
  2150.   }
  2151.  
  2152.   docptr = docbuf;
  2153.   if((fhandle = Fopen(fbuffer,0)) <= 0)
  2154.   {
  2155.      alert_cntre(ALERT16);
  2156.      free(docbuf);
  2157.      return;
  2158.   }
  2159.  
  2160.   bytes_in = Fread(fhandle,thedta.fsize,docbuf);
  2161.   if(bytes_in < thedta.fsize)
  2162.   {
  2163.      alert_cntre(ALERT17);
  2164.      free(docbuf);
  2165.      Fclose(fbuffer);     
  2166.      return;
  2167.   }
  2168.   Fclose(fbuffer);
  2169.  
  2170.   clear_tags();
  2171.   read_tags();
  2172.   free(docbuf);
  2173. }
  2174.  
  2175.  
  2176.  
  2177.  
  2178. save_tags()
  2179. {
  2180.    int dummy;
  2181.  
  2182.    strcpy(pathbuf,dpath2);
  2183.    strcat(pathbuf,"*.TAG");
  2184.    if(!get_fs(fbuffer,&dummy))
  2185.    {
  2186.     return;
  2187.    }
  2188.  
  2189.    extender(fbuffer,".TAG");
  2190.  
  2191.    Fsetdta(&thedta.res[0]);
  2192.    if(Fsfirst(fbuffer,0) == 0)
  2193.    {
  2194.     if(alert_cntre(ALERT37) == 2)    /* Cancel Button */
  2195.     {
  2196.          return;
  2197.     }
  2198.    }
  2199.  
  2200.    if((fhandle = Fcreate(fbuffer,0)) <= 0)
  2201.    {
  2202.     alert_cntre(ALERT19);
  2203.     return;
  2204.    }
  2205.  
  2206.    docbuf = (char *)lmalloc(DOCSIZE);
  2207.    if(!docbuf)
  2208.    {
  2209.     alert_cntre(ALERT12);
  2210.     return;
  2211.    }
  2212.    docptr = docbuf;
  2213.    docend = docbuf + DOCSIZE - 1;
  2214.    
  2215.    if(write_tags())
  2216.        ddump();    /* let AES handle error message */
  2217.    free(docbuf);
  2218.    if(Fclose(fhandle))
  2219.      alert_cntre(ALERT18);
  2220. }
  2221.  
  2222.