home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 092.lha / ColorFull / getfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-21  |  27.0 KB  |  1,003 lines
  1. /***************************************************************************
  2. * getfile.c  by: Keith Young                                      12/20/87
  3. *
  4. *   These routines were origionally written by: Charlie Heath of Microsmiths
  5. * (getfile.c on Manx Aztec C examples disk) and were Heavily modified by me
  6. * ( Keith Young ) for use in my ShareWare terminal program: "Access!" and
  7. * then further modified for "portability" and infestation into the public.
  8. * (as FREEWARE).
  9. *  I'll not attemp to list all the modifications made (sounds to much like
  10. * work). Nor will I guarantee that they even work at all (but hey, they work
  11. * for me :-). 
  12. *
  13. *  You may Use these source files, modify 'em, throw 'em away, give 'em away,
  14. * without obligation. JUST DON'T SELL 'EM! (I doubt you'd get much anyway:-)
  15. * 
  16. *   If you do use 'em (in a noncomercial manner), I would appeciate a small
  17. * "mention" in the docs somewhere. (small print, lower left hand corner will
  18. * do )
  19. *  
  20. *  These routines now compile using AZTEC 3.4a using 16 bit ints.(horay!)
  21. * (see included makefile)
  22. *
  23. *   Any bug reports/suggestions/fixes/etc... would be appreciated.
  24. * 
  25. *   I can be reached at:              (703) 297-7639
  26. *
  27. * via    E-MAIL->  GEnie: K.Young
  28. *                 CA-AUG: Keith Young
  29. *           Deep Thought: Keith Young
  30. *             COMPUSERVE: 73170,307
  31. *
  32. * via Snail-Mail-> Keith Young
  33. *                  Rt.2 Box 261
  34. *                  Goodview, Va.   (yes, really :-)
  35. *                           24095
  36. *  
  37. ***************************************************************************/
  38.  
  39. #include <ctype.h>
  40. #include <stdio.h>
  41.  
  42. #include "standard.h"
  43. #include "safeclose.h"
  44. #include "img.h"
  45. #define FAST register
  46. #define NL 0L
  47.  
  48. extern UBYTE               *dmore(), *dinit();
  49. extern APTR                *AllocMem();
  50. extern UBYTE               *rindex(), *index();
  51. extern struct FileLock     *Lock();
  52. extern struct InfoData     *Info();
  53. extern struct Window       *OpenWindow();
  54. extern struct IntuiMessage *GetMsg();
  55.  
  56. static struct FileLock      *pdir = NL;
  57. static struct FileInfoBlock *dir_info;
  58. static struct Window        *eW;      /* Parent Window. Uck   */
  59.  
  60.  
  61.  /* this is initialized in "test.c" currently... */
  62. extern struct TextAttr MyFont;/* = { 
  63.    (UBYTE *)"topaz.font",     
  64.    TOPAZ_EIGHTY,
  65.    FS_NORMAL,
  66.    FPF_ROMFONT
  67.  };*/
  68.  
  69.  
  70. #define FGAD      0L           /* Offset gadget ID's from here */
  71.  
  72. #define FCHARS    32L          /* Number of chars allowed in file name   */
  73. #define DIR_SIZ   50L          /* Number of chars in a dir name...   */
  74. #define MAX_STR   DIR_SIZ+2L
  75.  
  76. #define DENTS     7L           /* Number of entries on screen   */
  77.                                /* It's not as simple as changing 'DENTS'... */
  78. #define DSIZE     FCHARS+1L    /* Size of a directory entry   */
  79. #define DBUFSIZ   4000L        /* Number of bytes to allocate for all ents */
  80.  
  81. #define BCOL      7L           /* Background color   */
  82. #define FCOL      6L           /* Foreground color   */
  83.  
  84. #define RHGHT   128L
  85. #define RWDTH   390L
  86. #define ZWDTH   250L           
  87.  
  88. static UBYTE  def1[DIR_SIZ] = "DF2:\0";  /* user defined directory #1 */
  89. static UBYTE  def2[DIR_SIZ] = "DH0:\0";  /* user defined directory #2 */
  90. static UBYTE  sbuff[20] = "\0";          /* string buffer for "Bytes Free:" */
  91. static UBYTE  ubuf[MAX_STR];             /* Undo buffer   */
  92.  
  93. static struct dirent {
  94.        struct dirent *next;    /* ptr to next dirent */ 
  95.        BOOL isfile;            /* file or directory ? */
  96.        LONG d_size;            /* file size */
  97.        UBYTE dE[DSIZE+2];      /* file name kept here */
  98.  };
  99. static struct dirent *FirstEntry;
  100. static struct dirent *NextEntry;
  101.  
  102. static struct dirhead {
  103.        struct dirent *next;
  104.  };
  105. static struct dirhead ListHead;
  106.  
  107. static ULONG  curent,maxent;
  108. static BOOL   more;
  109. static BOOL   up,dn;            /* toggle flags for quick-scrolling */
  110. static struct Window     *wRq = NL;      /* Requester window   */
  111. static struct RastPort   *wRp;
  112.  
  113. static struct IntuiText saydir = {1,2,JAM2,0,1,&MyFont,(UBYTE *)"(dir) ",NL};
  114.  
  115. /**************************************************************************
  116.  * the following IntuiText is paired together as text + shadowtext...
  117.  * (there are better ways to do this)
  118.  **************************************************************************/
  119.  
  120. static struct IntuiText partext[2] = {
  121.            {0,0,JAM1, 7,2,&MyFont,(UBYTE *)"PARENT",&partext[1]},
  122.            {5,0,JAM1, 5,1,&MyFont,(UBYTE *)"PARENT",NL}
  123.            };
  124.  
  125. static struct IntuiText bytext[2] = {
  126.            {0,0,JAM1,210,RHGHT-16,&MyFont, NL,&bytext[1]},
  127.            {4,0,JAM1,208,RHGHT-17,&MyFont, NL,NL}
  128.            };
  129.  
  130. static struct IntuiText freeTxt[2] = {
  131.            {0,0,JAM1,120,RHGHT-16,&MyFont,(UBYTE *)"Bytes Free:",&freeTxt[1]},
  132.            {5,0,JAM1,118,RHGHT-17,&MyFont,(UBYTE *)"Bytes Free:",NL}
  133.            };
  134.  
  135. static struct IntuiText otxt[2] = {
  136.            {0,0,JAM1,20,RHGHT-32,&MyFont,(UBYTE *)"File",&otxt[1] },
  137.            {5,0,JAM1,18,RHGHT-33,&MyFont,(UBYTE *)"File",&freeTxt[0] }
  138.            };
  139.  
  140. static struct IntuiText dtxt[2] = {
  141.            {0,0,JAM1,20,14,&MyFont,(UBYTE *)"Drawer",&dtxt[1]},
  142.            {5,0,JAM1,18,13,&MyFont,(UBYTE *)"Drawer",&otxt[0]}
  143.            };
  144.  
  145. static struct IntuiText rsize[DENTS] = {      /* File size list */
  146.    {5,2,JAM2,213,1,&MyFont,NL, NL},
  147.    {5,2,JAM2,213,1,&MyFont,NL, NL},
  148.    {5,2,JAM2,213,1,&MyFont,NL, NL}, 
  149.    {5,2,JAM2,213,1,&MyFont,NL, NL},
  150.    {5,2,JAM2,213,1,&MyFont,NL, NL},
  151.    {5,2,JAM2,213,1,&MyFont,NL, NL},
  152.    {5,2,JAM2,213,1,&MyFont,NL, NL}
  153. };
  154. static struct IntuiText rname[DENTS+6] = {    /* File name list */
  155.    {0,2,JAM2,48,1,&MyFont,NL, NL},
  156.    {0,2,JAM2,48,1,&MyFont,NL, NL},
  157.    {0,2,JAM2,48,1,&MyFont,NL, NL}, 
  158.    {0,2,JAM2,48,1,&MyFont,NL, NL},
  159.    {0,2,JAM2,48,1,&MyFont,NL, NL},
  160.    {0,2,JAM2,48,1,&MyFont,NL, NL},
  161.    {0,2,JAM2,48,1,&MyFont,NL, NL},
  162.    {0,0,JAM1,5,16,&MyFont,(UBYTE *)"DH0:",NL}, /* device/dir name list */
  163.    {0,0,JAM1,5,16,&MyFont,(UBYTE *)"DF2:",NL},
  164.    {0,0,JAM1,5,16,&MyFont,(UBYTE *)"DF1:",NL},
  165.    {0,0,JAM1,5,16,&MyFont,(UBYTE *)"DF0:",NL},
  166.    {0,0,JAM1,5,16,&MyFont,(UBYTE *)"VD0:",NL},
  167.    {0,0,JAM1,5,16,&MyFont,(UBYTE *)"RAM:",NL}
  168.  };
  169.  
  170. /* Border for Drawer ... */
  171.  
  172. static SHORT oXY1[] = {
  173.    -1,-1,
  174.    193,-1,
  175.    193,8,
  176.    -1,8,
  177.    -1,-1
  178.  };
  179. static struct Border thebd1 = {
  180.    0,0,
  181.    6,0,JAM1,
  182.    5,oXY1,
  183.    NL
  184.  };
  185.  
  186. /* Border for file name ... */
  187.  
  188. static SHORT oXY2[] = {
  189.    -1,-1,
  190.    209,-1,
  191.    209,8,
  192.    -1,8,
  193.    -1,-1
  194.  };
  195. static struct Border thebd2 = {
  196.    0,0,
  197.    6,0,JAM1,
  198.    5,oXY2,
  199.    NL
  200.  };
  201.  
  202. static struct Image myknob;
  203. static struct PropInfo   cc_prop = {
  204.      AUTOKNOB | FREEVERT,         /* flags */
  205.      0,0,                         /* HPot, VPot */
  206.      0,0x10000,                   /* HBody,VBody */
  207.      0,0,0,0,0,0
  208.  };
  209. static struct Gadget gprop = {
  210.      NULL,                           /* Next gadget   */
  211.      RWDTH-120,23,                   /* Left, Top     */
  212.      20,70,                          /* Scroll Bar    */
  213.      GADGHIMAGE | GADGIMAGE ,        /* Flags         */
  214.      GADGIMMEDIATE | FOLLOWMOUSE,    /* Activation    */
  215.      PROPGADGET,                     /* Type          */
  216.      (APTR)&myknob,                  /* Render        */
  217.      NL,                             /* Select Render */
  218.      NL,NL,                          /* Text, Exclude */
  219.      (APTR)&cc_prop,                 /* Special Info  */
  220.      FGAD+13,                        /* GadgetID      */
  221.      NL                              /* UserData      */
  222.  };
  223.  
  224. static struct Gadget scr_dn = {
  225.    &gprop,
  226.    RWDTH-119,RHGHT-35,
  227.    20,10,                    /* scroll dn   */
  228.    GADGHNONE,      
  229.    GADGIMMEDIATE,      
  230.    BOOLGADGET,
  231.    NL,NL,  
  232.    NL,
  233.    NL,NL,           
  234.    FGAD+22,
  235.    NL
  236.  };                
  237. static struct Gadget scr_up = {
  238.    &scr_dn,
  239.    RWDTH-119,13,
  240.    20,10,                    /* scroll up   */
  241.    GADGHNONE,      
  242.    GADGIMMEDIATE,      
  243.    BOOLGADGET,
  244.    NL,NL,  
  245.    NL,
  246.    NL,NL,           
  247.    FGAD+21,
  248.    NL
  249.  };                
  250.  
  251. static struct Gadget par = {
  252.    &scr_up,
  253.    306,13,
  254.    58,10,                    /* PARENT   */
  255.    GADGHCOMP,      
  256.    RELVERIFY,      
  257.    BOOLGADGET,
  258.    NL,NL,  
  259.    &partext[0],
  260.    NL,NL,           
  261.    FGAD+20,
  262.    NL
  263.  };                
  264. static struct StringInfo gsdef2 = {
  265.     NL,
  266.     NL,
  267.     NL,
  268.     DIR_SIZ,
  269.     NL,NL,NL,NL,NL,NL,NL,NL,NL
  270.  };
  271. static struct Gadget gdef2 = { /* string gadget for user defined directory */
  272.    &par,
  273.    RWDTH-47,95,
  274.    32,10,                             /* string #2 */
  275.    GADGHCOMP, RELVERIFY, STRGADGET,
  276.    NL,NL, NL, /*txt*/
  277.    NL, (APTR)&gsdef2,
  278.    FGAD+19,
  279.    NL
  280.  };
  281.  
  282. static struct StringInfo gsdef1 = {
  283.     NL,
  284.     NL,
  285.     NL,
  286.     DIR_SIZ,
  287.     NL,NL,NL,NL,NL,NL,NL,NL,NL
  288.  };
  289. static struct Gadget gdef1 = { /* string gadget for user defined directory */
  290.    &gdef2,
  291.    RWDTH-87,95,
  292.    32,10,                               /* string #1 */
  293.    GADGHCOMP, RELVERIFY, STRGADGET,
  294.    NL,NL, NL, 
  295.    NL, (APTR)&gsdef1,
  296.    FGAD+18,
  297.    NL
  298.  };
  299.  
  300. static struct StringInfo gsfil = {
  301.    NL,
  302.    ubuf,
  303.    NL,
  304.    DSIZE,
  305.    NL,NL,NL,NL,NL,NL,NL,NL,NL
  306. };
  307. static struct Gadget gfil = {
  308.    &gdef1,
  309.    60,RHGHT-33,
  310.    RWDTH-178,10,                      /* File name gadget */
  311.    GADGHCOMP, RELVERIFY, STRGADGET,
  312.    (APTR)&thebd2,
  313.    NL, NL,/*txt*/
  314.    NL, (APTR)&gsfil,
  315.    FGAD+17,
  316.    NL
  317.  };
  318.  
  319. static struct StringInfo gsdir = {
  320.     NL,
  321.     ubuf,
  322.     NL,
  323.     DIR_SIZ,
  324.     NL,NL,NL,NL,NL,NL,NL,NL,NL
  325.  };
  326. static struct Gadget gdir = {
  327.    &gfil,
  328.    76,13,
  329.    RWDTH-193,10,                     /* Directory gadget */
  330.    GADGHCOMP, RELVERIFY, STRGADGET,
  331.    (APTR)&thebd1,
  332.    NL, NL,/*txt*/
  333.    NL, (APTR)&gsdir,
  334.    FGAD+16,
  335.    NL
  336.  };
  337.  
  338. static struct Gadget gok = {
  339.    &gdir,
  340.    15,RHGHT-19,
  341.    58,12,                    /* OTAY   */
  342.    GADGIMAGE | GADGHIMAGE,      
  343.    RELVERIFY, BOOLGADGET,
  344.    (APTR)&okupImage,
  345.    (APTR)&okdnImage,  
  346.    NL, NL,NL,           
  347.    FGAD+15,
  348.    NL
  349.  };                
  350. static struct Gadget gcan = {
  351.      &gok,
  352.      RWDTH-81,RHGHT-19,
  353.      58,12,                 /* CANCEL */
  354.      GADGIMAGE | GADGHIMAGE,
  355.      RELVERIFY, BOOLGADGET,
  356.      (APTR)&canupImage,
  357.      (APTR)&candnImage,
  358.      NL, NL,NL,
  359.      FGAD+14,
  360.      NL
  361.  };
  362.  
  363. static struct Gadget gram = {
  364.    &gcan,
  365.    RWDTH-90 ,26,
  366.    30,13,                     /* RAM */
  367.    GADGIMAGE | GADGHIMAGE,
  368.    RELVERIFY, BOOLGADGET,
  369.    (APTR)&disk1Image,
  370.    (APTR)&disk2Image,
  371.    &rname[12], NL,NL,
  372.    FGAD+12,
  373.    NL
  374.  };
  375. static struct Gadget gvd0 = {
  376.    &gram,
  377.    RWDTH-50,26,
  378.    30,13,                      /* VD0 */
  379.    GADGIMAGE | GADGHIMAGE,
  380.    RELVERIFY, BOOLGADGET,
  381.    (APTR)&disk1Image,
  382.    (APTR)&disk2Image,
  383.    &rname[11], NL,NL,
  384.    FGAD+11,
  385.    NL
  386.  };
  387. static struct Gadget gdf0 = {
  388.    &gvd0,
  389.    RWDTH-90 ,52,
  390.    30,13,                         /* DF0 */
  391.    GADGIMAGE | GADGHIMAGE,
  392.    RELVERIFY, BOOLGADGET,
  393.    (APTR)&disk1Image,
  394.    (APTR)&disk2Image,
  395.    &rname[10], NL,NL,
  396.    FGAD+10,
  397.    NL
  398.  };
  399. static struct Gadget gdf1 = {
  400.    &gdf0,
  401.    RWDTH-50 ,52,
  402.    30,13,                        /* DF1 */
  403.    GADGIMAGE | GADGHIMAGE,
  404.    RELVERIFY, BOOLGADGET,
  405.    (APTR)&disk1Image,
  406.    (APTR)&disk2Image,
  407.    &rname[9], NL,NL,
  408.    FGAD+9,
  409.    NL
  410.  };
  411. static struct Gadget gdf2 = {
  412.    &gdf1,
  413.    RWDTH-90 ,78,
  414.    30,13,                     /* DF2 */ /* (user #1) */
  415.    GADGIMAGE | GADGHIMAGE,
  416.    RELVERIFY, BOOLGADGET,
  417.    (APTR)&disk1Image,
  418.    (APTR)&disk2Image,
  419.    NL, NL,NL,
  420.    FGAD+8,
  421.    NL
  422.  };
  423. static struct Gadget gdh0 = {
  424.    &gdf2,
  425.    RWDTH-50 ,78,
  426.    30,13,                    /* DH0 */ /* (user #2) */
  427.    GADGIMAGE | GADGHIMAGE,
  428.    RELVERIFY, BOOLGADGET,
  429.    (APTR)&disk1Image,
  430.    (APTR)&disk2Image,
  431.    NL, NL,NL,
  432.    FGAD+7,
  433.    NL
  434.  };
  435.  
  436. static struct Gadget og7 = {
  437.    &gdh0,
  438.    20,83, ZWDTH,10,                      /* Gadgets For   */
  439.    GADGHCOMP, RELVERIFY, BOOLGADGET,     /* Directory entries   */
  440.    NL,NL, &rname[6],
  441.    NL,NL,
  442.    FGAD+6,
  443.    NL
  444.  };
  445. static struct Gadget og6 = {
  446.    &og7,
  447.    20,73, ZWDTH,10,  
  448.    GADGHCOMP, RELVERIFY, BOOLGADGET,
  449.    NL,NL, &rname[5],
  450.    NL,NL,
  451.    FGAD+5,
  452.    NL
  453.  };
  454. static struct Gadget og5 = {
  455.    &og6,
  456.    20,63, ZWDTH,10,
  457.    GADGHCOMP, RELVERIFY, BOOLGADGET,
  458.    NL,NL, &rname[4],
  459.    NL,NL,
  460.    FGAD+4,
  461.    NL
  462.  };
  463. static struct Gadget og4 = {
  464.    &og5,
  465.    20,53, ZWDTH,10,
  466.    GADGHCOMP, RELVERIFY, BOOLGADGET,
  467.    NL,NL, &rname[3],
  468.    NL,NL,
  469.    FGAD+3,
  470.    NL
  471.  };
  472. static struct Gadget og3 = {
  473.    &og4,
  474.    20,43, ZWDTH,10,
  475.    GADGHCOMP, RELVERIFY, BOOLGADGET,
  476.    NL,NL, &rname[2],
  477.    NL,NL,
  478.    FGAD+2,
  479.    NL
  480.  };
  481. static struct Gadget og2 = {
  482.    &og3,
  483.    20,33, ZWDTH,10,
  484.    GADGHCOMP, RELVERIFY, BOOLGADGET,
  485.    NL,NL, &rname[1],
  486.    NL,NL,
  487.    FGAD+1,
  488.    NL
  489.  };
  490. static struct Gadget og1 = {
  491.    &og2,
  492.    20,23, ZWDTH,10,   
  493.    GADGHCOMP, RELVERIFY, BOOLGADGET, 
  494.    NL,NL, &rname[0],
  495.    NL,NL,
  496.    FGAD,
  497.    NL
  498.  };
  499.  
  500. /* Open a requester "Window" */
  501.  
  502. static struct NewWindow NewFiles = {
  503.    120, 40,
  504.    RWDTH,RHGHT,
  505.    BCOL,FCOL,
  506.    NL, /* Fill in AFTER opening ... */
  507.    SMART_REFRESH | ACTIVATE | WINDOWDRAG,
  508.    &og1,
  509.    NL,(UBYTE *)"File Requester",NL,NL,
  510.    RWDTH,RHGHT,RWDTH,RHGHT,
  511.    WBENCHSCREEN  /* change this after call */
  512.  };
  513.  
  514. extern struct IntuitionBase  *IntuitionBase;
  515.  
  516. /*******************************************************************
  517. *  get_fname(window,screen,hail,ddef,ddir);
  518. *
  519. *   Displays a window/requester that
  520. * gets a file name for device,directory,default file, extension
  521. *
  522. *   Calling args:
  523. * window:   Window making the request
  524. * screen:   Screen, if NULL assummed workbench
  525. * hail:   Text prompt at top of requester
  526. * ddef:   Input default file-name. Has NO DIRECTORY OR EXTENSION.
  527. * ddir:   Directory of file, may be null
  528. */
  529.  
  530. /* Set a file-requester (actually a window) with title 'hail' */
  531.  
  532. UBYTE *get_fname(cW,screen,hail,ddef,ddir)
  533.    struct Window *cW;       /* Calling Window   */
  534.    struct Screen *screen;   /* screen .... if null assumed workbench */
  535.    UBYTE      *hail;        /* Hailing prompt   */
  536.    UBYTE      *ddef;        /* Probable file-name   */
  537.    UBYTE      *ddir;        /* Directory in which to search   */
  538. {
  539.    FAST struct IntuiMessage *imes;   /* Wait for message in HERE   */
  540.    FAST struct Gadget       *igad;   /* Get Gadget Mumbo Jumbo   */
  541.    FAST ULONG  i,class;
  542.    FAST TEXT   *pnam,*stomp;
  543.    FAST UBYTE  *retval;              /* return value */
  544.    FAST BOOL   dir_flag;
  545.    FAST BOOL   keepon;
  546.    USHORT      code;
  547.    TEXT        ch;
  548.  
  549.    if ( ! (eW = cW) )   return(NL);
  550.  
  551.     gsfil.Buffer = ddef;   /* Set default file name   */
  552.     gsdir.Buffer = ddir;   /* Set default device name   */
  553.    gsdef1.Buffer = def1;   /* Set #1 default drive */
  554.    gsdef2.Buffer = def2;   /* Set #2 default drive */
  555.  
  556.    up = FALSE;
  557.  
  558.    for ( i=0; i<DENTS; i++)
  559.    {
  560.       rname[i].IText    = NL;
  561.       rsize[i].IText    = NL;
  562.       rname[i].NextText = NL; 
  563.    };
  564.  
  565.    NewFiles.Title = hail;
  566.    if ((dir_info = (struct FileInfoBlock *)
  567.           AllocMem((ULONG)sizeof(struct FileInfoBlock),MEMF_CHIP)) == NULL)
  568.        return(NL);
  569.  
  570.    if (screen)      /* User supplied a screen */
  571.    {
  572.       NewFiles.Type   = CUSTOMSCREEN;
  573.       NewFiles.Screen = screen;
  574.    }
  575.  
  576.    if ( ! (FirstEntry = (struct dirent *)AllocMem((ULONG)DBUFSIZ,0L)) ||
  577.         ! (wRq = (struct Window *)OpenWindow( &NewFiles )) )
  578.    {
  579. /*      emits_rx("Need more memory to open File-Requester...\n");*/
  580.       if ( FirstEntry )   FreeMem(FirstEntry,(ULONG)DBUFSIZ);
  581.       FreeMem(dir_info,(ULONG)sizeof(struct FileInfoBlock));
  582.       return(NL);
  583.    }
  584.  
  585.    ActivateGadget(&gfil,wRq,0L);
  586.    wRp = wRq->RPort;
  587.  
  588.    wRq->UserPort = eW->UserPort;
  589.    ModifyIDCMP(wRq,(ULONG)(MOUSEBUTTONS | GADGETDOWN | GADGETUP | MOUSEMOVE));
  590.    SetAPen(wRp,2L);
  591.    RectFill(wRp,3L,10L,(ULONG)(RWDTH-5),(ULONG)(RHGHT-2));
  592.  
  593.    PrintIText(wRp,&dtxt,0L,0L);
  594.    DrawImage(wRp,&fmupImage,(long)(RWDTH-118),13L);/* up-dn scroll images */
  595.    DrawImage(wRp,&fmdnImage,(long)(RWDTH-118),(long)(RHGHT-35));
  596.    RefreshGadgets(&og1,wRq,0L); /* re-draw the gadgets after filling in the 
  597.                                     background color */
  598.    /* Set up directory, notify any errors...   */
  599.    if ( pnam = (UBYTE *)dinit(ddir) )   notify(pnam);
  600.  
  601.    for ( retval= NL, keepon=TRUE; keepon ; )
  602.    {
  603.       while ( ! (imes=(struct IntuiMessage *)GetMsg(wRq->UserPort)) )  
  604.       {
  605.        if (up)
  606.          {
  607.           cc_prop.VertPot -= (cc_prop.VPotRes/ DENTS);
  608.           RefreshGadgets(&gprop,wRq,0L); 
  609.          }
  610.        if (dn)
  611.          {
  612.           cc_prop.VertPot += (cc_prop.VPotRes/ DENTS);
  613.           RefreshGadgets(&gprop,wRq,0L); 
  614.          }
  615.        if ( dir_flag || up || dn)
  616.          {
  617.           i = (maxent-DENTS) * cc_prop.VertPot / MAXBODY;
  618.           if ( i > (maxent-DENTS) )
  619.           i = maxent-DENTS;
  620.           if ( i <0 )   i = 0;
  621.           curent = i;
  622.           cxxx();     /* display filenames/sizes  */
  623.           dir_flag = FALSE;
  624.          }
  625.          if ( more )
  626.          {
  627.           if (pnam = (UBYTE *)dmore())   /* Continue to read the directory */
  628.              notify(pnam);      /* Yucko error   */
  629.           if ( maxent <= DENTS ) dir_flag = TRUE;
  630.          }
  631.          else
  632.           if (!up && !dn)
  633.              WaitPort(wRq->UserPort);
  634.       }
  635.       igad = (struct Gadget *)imes->IAddress;
  636.       class = imes->Class;
  637.       code = imes->Code;
  638.       if(class != MOUSEMOVE && class != GADGETUP && class != GADGETDOWN &&
  639.          class != MOUSEBUTTONS)
  640.       {
  641.        /* Process_Your_other_window_messages_here(imes); */
  642.        WindowToFront(wRq);
  643.        continue;
  644.       }
  645.       ReplyMsg(imes);
  646.       switch (class)
  647.       {
  648.          case MOUSEMOVE:     dir_flag = TRUE; break;
  649.          case MOUSEBUTTONS:  if (code == SELECTUP)
  650.                                {
  651.                                 up = FALSE;
  652.                                 dn = FALSE;
  653.                                } 
  654.                              break;
  655.          case GADGETUP:
  656.          case GADGETDOWN:
  657.                             if(igad->GadgetID == FGAD+21)
  658.                                {
  659.                                 up = TRUE;
  660.                                 break;
  661.                                } 
  662.                             if(igad->GadgetID == FGAD+22)
  663.                                {
  664.                                 dn = TRUE;
  665.                                 break;
  666.                                } 
  667.           switch ( i = igad->GadgetID)
  668.            {
  669.             case FGAD+0:
  670.             case FGAD+1:
  671.             case FGAD+2:
  672.             case FGAD+3:
  673.             case FGAD+4:    /* Replace file or directory name   */
  674.             case FGAD+5:
  675.             case FGAD+6:
  676.             case FGAD+7:
  677.             case FGAD+8:
  678.             case FGAD+9:   
  679.             case FGAD+10:
  680.             case FGAD+11:
  681.             case FGAD+12:
  682.                  pnam = rname[i].IText;
  683.                  if   ( rname[i].NextText == NL && i<DENTS )
  684.                    {
  685.                     RemoveGadget(wRq,&gfil);
  686.                     for (i=0; i<DSIZE; i++)      ddef[i] = *pnam++;
  687.                     AddGadget(wRq,&gfil,21L);
  688.                     RefreshGadgets(&gfil,wRq,0L);
  689.                     ActivateGadget(&gfil,wRq,0L);
  690.                     break;
  691.                    }
  692.                  else
  693.                    {
  694.                     switch (i)
  695.                     {
  696.                      case FGAD+7 : *ddir = NL; pnam = def2;break;
  697.                      case FGAD+8 : *ddir = NL; pnam = def1;break;
  698.                      case FGAD+9 : *ddir = NL; break;
  699.                      case FGAD+10: *ddir = NL; break;
  700.                      case FGAD+11: *ddir = NL; break;
  701.                      case FGAD+12: *ddir = NL; break;
  702.                     }
  703.                     RemoveGadget(wRq,&gdir);
  704.                     rfnam(ddir,pnam);
  705.                     AddGadget(wRq,&gdir,21L);
  706.                     RefreshGadgets(&gdir,wRq,0L);
  707.                     }
  708.             case FGAD+16:             /* dir string gadget */
  709.                ch = ddir[ strlen(ddir)-1 ];
  710.                if(ch != ':' && ch != '/') strcat(ddir,"/");
  711.                if ( pnam = (UBYTE *)dinit(ddir) )
  712.                   notify(pnam);
  713.                ActivateGadget(&gfil,wRq,0L);
  714.             case FGAD+13:
  715.                dir_flag = TRUE;       /* prop gadget */
  716.                break;
  717.             case FGAD+15:             /* Name gadget, OTAY gadget   */
  718.             case FGAD+17:
  719.                retval = ddef;         /* only returns filename, a little code
  720.                                          could add ddir+ddef first */
  721.             case FGAD+14:             /* Cancel gadget   */
  722.                keepon = FALSE;
  723.             case FGAD+18:
  724.             case FGAD+19:break;       /* user definable string gadgets... */
  725.             case FGAD+20:             /* PARENT gadget */
  726.                 if (stomp = rindex(ddir,'/'))
  727.                   {
  728.                    *stomp = NULL;
  729.                    if (stomp = rindex(ddir,'/'))
  730.                      { 
  731.                       *stomp = NULL;
  732.                       *(stomp+1) = NULL;
  733.                       strcat(ddir,"/");
  734.                      }
  735.                    else if ( stomp = index(ddir,':')) 
  736.                           *(stomp+1) = NULL;
  737.                    RemoveGadget(wRq,&gdir);
  738.                    AddGadget(wRq,&gdir,-1L);
  739.                    RefreshGadgets(&gdir,wRq,0L);
  740.                    if ( pnam = (UBYTE *)dinit(ddir) )
  741.                      notify(pnam);
  742.                    dir_flag = TRUE;     
  743.                   }
  744.           }
  745.       }
  746.    }
  747.   FreeMem(FirstEntry,(ULONG)DBUFSIZ );
  748.   FreeMem(dir_info,(ULONG)sizeof(struct FileInfoBlock));
  749.   free_pdir();
  750.  
  751.   CloseWindowSafely(wRq);
  752.   return(retval);
  753. }
  754.  
  755. static free_pdir()
  756. {
  757.   if ( pdir )
  758.     {
  759.      UnLock(pdir);
  760.      pdir = NL;
  761.     }
  762. }
  763.  
  764. /*
  765.  *
  766.  * convert 'int.' to right justified 'string' ( for file size display )
  767.  *
  768.  */ 
  769.  
  770. char  *itos(fred)
  771. LONG  fred;
  772.  {
  773.    static char fredstring[6]; /* 6 chars. allows for up to 999999 Bytes...*/
  774.    int          next = 5;
  775.    
  776.    if (!fred) fredstring[next--] = '0';
  777.       
  778.    while ((fred+9)/10)
  779.       {      
  780.       fredstring[next--] = fred % 10 + 0x30;
  781.       fred /= 10;
  782.       }
  783.    while (next+1) fredstring[next--] = 0x20;/* ASCII <space> for left padding*/
  784.    return(fredstring);
  785.  }
  786.  
  787. /*****************************************************************
  788. * dinit()
  789. *   Initialize the fib for directory muck.  Null return
  790. * is good, else return is a pointer to an error string 
  791. */
  792.  
  793. static UBYTE *dinit(subdir)
  794.  UBYTE *subdir;
  795. {
  796.  extern long AvailMem();
  797.  struct InfoData *info;
  798.  ULONG           bytes = 0L; /*  Bytes Free on Drive:  */
  799.  
  800.    more = FALSE;
  801.    curent = maxent = 0;
  802.    cc_prop.VertBody = 0xFFFF;
  803.    cc_prop.VertPot = 0;        /* start at begining of file list*/
  804.    RefreshGadgets(&gprop,wRq,0L); 
  805.  
  806.    NextEntry = FirstEntry;      /* Allocate from here   */
  807.    ListHead.next = NL;          /* Clear the boogie     */
  808.  
  809.    free_pdir();   /* Unlock any old lock... */
  810.  
  811.    if (! (pdir=(struct FileLock *)Lock(subdir,(ULONG)ACCESS_READ)) )
  812.      return((UBYTE *)"Wrong Diskette?");
  813.  
  814.    if ( ! Examine(pdir, dir_info) )
  815.      return((UBYTE *)"Wierd Disk Error");
  816.  
  817.    if ( dir_info->fib_DirEntryType < 0L )
  818.      return((UBYTE *)"Bizzare Alert!!");
  819.  
  820.    if ( !strcmp(subdir,"RAM:") || !strcmp(subdir,"ram:"))
  821.      {
  822.       Forbid();
  823.       bytes = ( AvailMem(MEMF_CHIP) + AvailMem(MEMF_FAST));
  824.       Permit();
  825.       sprintf(sbuff,"%ld",bytes);
  826.      }
  827.    else
  828.      {
  829.       info = (struct InfoData *)
  830.                     AllocMem((ULONG)sizeof(struct InfoData),0L);
  831.       if (Info(pdir,info))
  832.       bytes = (info->id_NumBlocks - info->id_NumBlocksUsed) * info->id_BytesPerBlock;
  833.       FreeMem(info,(long)sizeof(*info));
  834.       sprintf(sbuff,"%ld",bytes);
  835.      }
  836.    bytext[0].IText = sbuff; /* my shadow and... */
  837.    bytext[1].IText = sbuff; /* I... */
  838.    SetAPen(wRp,2L);
  839.    RectFill(wRp,209L,(ULONG)(RHGHT-17),270L,(ULONG)(RHGHT-9));
  840.    PrintIText(wRp,&bytext[0],0L,0L);
  841.  
  842.    more = TRUE;
  843.    return(dmore());
  844. }
  845.  
  846.  
  847. static UBYTE *dmore()
  848. {
  849.   FAST struct dirent   *p_D = NextEntry;
  850.   FAST struct dirent   *ptr = (struct dirent *)&ListHead;
  851.   FAST struct dirent   *plink;
  852.   FAST TEXT            *p_mung;  
  853.   FAST ULONG    i;
  854.  
  855.    if ( ! more )   return(NL);
  856.  
  857.    if ( ExNext( pdir, dir_info ) )
  858.    {
  859.       if ( (ULONG)p_D >=
  860.          ((ULONG)FirstEntry + (ULONG)DBUFSIZ - (ULONG)sizeof(struct dirent)) )
  861.         {
  862.          more = FALSE;
  863.          return((UBYTE *)"Directory Truncated!");
  864.         }
  865.          /* Here you can add a file/directory filter   */
  866.          /* filename text string is at &p_D->dE[0]   */
  867.  
  868.       if ( p_D->isfile = ( dir_info->fib_DirEntryType < 0L ) )
  869.          p_D->d_size = (LONG)(dir_info->fib_Size);
  870.  
  871.       p_mung = &p_D->dE[0];
  872.       for ( i=0; i<FCHARS; i++)
  873.          if ( ! (*p_mung++ = dir_info->fib_FileName[i]) )   break;
  874.  
  875.       i = (ULONG)p_mung;
  876.       NextEntry = (struct dirent *)( (i+5L) & ~3L );
  877.  
  878.       for ( i=maxent++; i>=0; i--)
  879.       {
  880.        if ( ! (plink = ptr->next)  )   break;
  881.        if ( alpha_lower(p_D,plink) )   break;
  882.        ptr = plink;
  883.       }
  884.       p_D->next = plink;
  885.       ptr->next = p_D;
  886.  
  887.       if(maxent > DENTS)
  888.        {
  889.         cc_prop.VertBody = ((DENTS * 0x10000) / maxent);
  890.         RefreshGadgets(&gprop,wRq,0L); 
  891.        }
  892.       return(NL);
  893.    }
  894.    else return ( IoErr() == ERROR_NO_MORE_ENTRIES) ?
  895.        (UBYTE *)(more = 0L) : (UBYTE *)"Error Reading Directory!!!";
  896. }
  897.  
  898. /* dedicated alphabetizing function for dmore()   */
  899.  
  900. static alpha_lower(snew,sold)
  901.    struct dirent *snew,*sold;
  902. {
  903.    FAST struct dirent *pnew = snew;
  904.    FAST TEXT *ps1,*ps2, c,d;
  905.  
  906.    if ( pnew->isfile == sold->isfile)
  907.      {
  908.       ps1 = &pnew->dE[0];
  909.       ps2 = &sold->dE[0];
  910.       while ( (c=*ps1++) )
  911.          {
  912.           if ( c > (d=*ps2++) )   return(FALSE);
  913.           else if ( c < d )      break;
  914.          }
  915.       return(TRUE);
  916.      }
  917.    return(pnew->isfile);
  918. }   
  919.  
  920. /* Display directory stuff   */
  921.  
  922. static cxxx()
  923. {
  924.    FAST ULONG   i,new;
  925.    FAST ULONG   x,y;
  926.    FAST struct dirent *ohboy = (struct dirent *)&ListHead;
  927.  
  928.    new = curent;
  929.    for ( i=0; i<new; i++)   ohboy = ohboy->next;
  930.    SetBPen(wRp,2L);
  931.    SetDrMd(wRp,JAM2);
  932.    y = 13L;
  933.    for (i=0; i<DENTS; i++)
  934.      {
  935.       x = 20L;
  936.       y += 10;
  937.       rname[i].NextText = 0;
  938.       rname[i].IText = 0;
  939.       rsize[i].IText = (UBYTE *)"      ";
  940.       rname[i].LeftEdge = 0;
  941.       if ( (new+i) < maxent )
  942.         {
  943.          ohboy = ohboy->next;
  944.          rname[i].IText = &ohboy->dE[0];
  945.         if ( ohboy->isfile )
  946.             {                      
  947.              rsize[i].IText = (UBYTE *)itos(ohboy->d_size);
  948.              PrintIText(wRp,&rname[i],20L,y);
  949.             }
  950.          else
  951.             {
  952.              rname[i].LeftEdge = 48;
  953.              PrintIText(wRp,&saydir,20L,y);
  954.              PrintIText(wRp,&rname[i],20L,y);
  955.              rname[i].NextText = &saydir;
  956.             }
  957.         x = wRp->cp_x;
  958.         }
  959.       if ( x < 214 )
  960.         {
  961.          SetAPen(wRp,2L);  
  962.          RectFill(wRp,x,y,215L,(ULONG)(y+8L));
  963. /*         RectFill(wRp,x,(long)(y-6),215L,(long)(y+1));*/
  964.         }        
  965.       PrintIText(wRp,&rsize[i],0L,y);
  966.    }
  967. }
  968.  
  969.  
  970. /**************************************************
  971. * rfnam()
  972. *   Combines dir, plus name into dir   */
  973.  
  974. static rfnam(dir,fil_nam)
  975.    UBYTE *dir,*fil_nam;
  976.    {
  977.    FAST UBYTE   *pdst = dir;
  978.    FAST UBYTE   *psrc = fil_nam;
  979.    FAST UBYTE   c = ':';
  980.  
  981.    while ( *pdst )
  982.       c = *pdst++;
  983.    if ( c != ':' && c != '/' )   *pdst++ = '/';
  984.  
  985.    while ( *pdst++ = *psrc++ )
  986.       ;
  987.    }
  988.  
  989. static struct IntuiText b_txt = {0,1,JAM2, 5,20,NL,NL,    NL};
  990. static struct IntuiText p_txt = {0,1,JAM2, 5,3,NL,(UBYTE *)"OK", NL};
  991.  
  992. /****************************************************************
  993. * notify(txt)                    
  994. * Prompts for Yes/No response            
  995. */
  996. static notify(txt)
  997.    UBYTE *txt;
  998. {
  999.    b_txt.IText = txt;
  1000.    AutoRequest(wRq,&b_txt,0L,&p_txt,0L,0L,
  1001.       (ULONG)(IntuiTextLength(&b_txt)+50L),70L);
  1002. }
  1003.