home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / utilities / misc / gadmget1.9.lha / GadMGet1.9 / GadMget1.9.source.lha / gadmget.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-02  |  87.7 KB  |  3,764 lines
  1. /* GadMGet.c  by Jeremy Friesner -- jfriesne@ucsd.edu  
  2.    Version 1.9, released 03 February 1995 */
  3.  
  4. #ifndef MGET_C
  5. #define MGET_C
  6.  
  7. #define INTUI_V36_NAMES_ONLY
  8. #define MAXFILELINELENGTH 300 
  9. #define CHAR_SPACE ' '
  10. #define INVALID 666
  11.  
  12. #define FIND_REQUESTTYPE               0
  13. #define LINELENGTH_REQUESTTYPE          1
  14. #define OUTPUTFILE_REQUESTTYPE          2
  15. #define SELECT_REQUESTTYPE           3
  16. #define DESELECT_REQUESTTYPE         4
  17.  
  18. #define SEARCH_FORWARD 1
  19. #define SEARCH_BACKWARD 2
  20. #define SEARCHTYPE_BOTTOM 1
  21. #define SEARCHTYPE_TOP 2
  22. #define SEARCHTYPE_NEXT 3
  23. #define SEARCHTYPE_PREVIOUS 4
  24. #define SEARCHTYPE_FORWARD 5
  25. #define SEARCHTYPE_BACKWARD 6
  26.  
  27. #define SORTBYDIR  1
  28. #define DIRNAMESIZE 10
  29.  
  30. #define SORTBYNAME 2
  31. #define NAMESIZE 20
  32.  
  33. #define SORTBYDESC 3
  34. #define DESCSIZE 42
  35.  
  36. #define SORTBYSIZE 4
  37. #define SIZESIZE 5
  38.  
  39. #define SORTBYAGE  5
  40. #define AGESIZE  5
  41.  
  42. #define TREESORT   1
  43. #define BUBBLESORT 2
  44.  
  45. #include "GadMget.h"
  46.  
  47. extern UWORD lastcode;
  48. extern ULONG appwinsig;
  49. extern struct NewGadget mgetNGad[];
  50. extern struct NewMenu mgetNewMenu[];
  51. extern struct Window *findwindow;
  52. extern struct AppMessage *amsg;
  53. extern struct MsgPort *awport;
  54. extern struct AppWindow *appwin;
  55. extern struct TextAttr listfont;
  56.  
  57. extern LONG lTreeTicker;
  58. extern LONG lTreeSubTicker;
  59. extern char *sTreeWriteHere;
  60. extern char *szTickerString;
  61.  
  62. FILE *fpOut = stdout;
  63. int IntuitionBase; 
  64. ULONG winopenerror, lockscrnerror;
  65. ULONG handlereturn;
  66. BOOL done=FALSE,BStartedFromWB=FALSE;
  67. char windowtitle[95] = "Loading...";
  68. char sListFontName[36] = "";
  69. int nListFontSize = 0;  /* Default to a bad value */
  70. char version[] = "$VER: GadMget V1.9";
  71. char template[] = "Template:  GadMGet FILE/A,OUTPUT/K,LINELENGTH/K,TOP/K,LEFT/K,\
  72. WIDTH/K,HEIGHT/K,PUBSCREEN/K,WBSCREEN/S,DEFPUBSCREEN/S,NOFILES/S,GETREADMES/S,\
  73. NOPARSE/S,CASESENSITIVE/S,SORTCASESENSITIVE/S,SEARCHCASESENSITIVE/S,NOCOMMAND/S,\
  74. NOSPLIT/S,NOAPPWINDOW/S,COMMAND/K,NOSIMPLEPATHS/S,NOCD/S,HEADER/K,FOOTER/K,\
  75. FONT/K,FONTSIZE/K,KEEPBLANKLINES/S,KEEPGETSORT/S,KEEPFILESORT/S,FILESORT/K,\
  76. GETSORT/K,AMINETPATH/K,EOL/K\n";
  77. char pnamestring[20],searchstring[MAXFILELINELENGTH];
  78. char szPubScreenName[40],*pubscreenname = NULL,defDir[200],defFile[40];
  79. char szCommandString[40] = "mget ";
  80. char inputfile[300]="ram:RECENT";
  81. char sEndOfLineString[10] = "\r\n";
  82. char sAminetPathString[50] = "../../";
  83. char sOutFileName[300]="";
  84. char szHeaderFile[300];
  85. char szFooterFile[300];
  86. char sMultiSelect[150]="";
  87. int nTopListTop, nTopListHeight, nBottomListHeight;
  88. int nSortType[2] = {SORTBYDIR, SORTBYDIR};
  89. int nKeepSorted[2] = {FALSE, FALSE};
  90. int Not[2] = {TRUE, FALSE};        /* NOT lookup array */
  91. int nForTreeSortUseOnly;    /* only global because nested functions ain't happenin!  Don't use elsewhere! */
  92. struct List *lForTreeSortUseOnly;
  93.  
  94. /* Input column info */
  95. static int nNameCol = 0;
  96. static int nKCol    = 35;
  97. static int nDirCol  = 21;
  98. static int nAgeCol  = 35;  /* Not that this should be the RIGHT side of the age string! */
  99. static int nPlusCol = 36;
  100. static int nDescCol = 37;
  101.  
  102. /* default flags */
  103. int screentype              = USE_CUSTOMSCREEN,    
  104.      getreadmes             = FALSE, 
  105.      filesflag           = TRUE,                 /* get .lha files */
  106.      filelist_length      = 0,                      /* no files loaded */
  107.      getlist_length      = 0,                     /* no files selected either */
  108.      search_index         = 0,                     /* buffer at first item */
  109.      mgetfind_findtype   = SEARCHTYPE_FORWARD,   /* global var used between mgetfind* */
  110.      simplepaths          = TRUE,                 /* don't use ncftp style mgets */
  111.      searchcasesensitive = FALSE,
  112.      sortcasesensitive   = FALSE,                    
  113.      maxoutputlinelength = 254,                  /* shell's limit */
  114.      requesttype          = FIND_REQUESTTYPE,     /* subwindow is for string searches */
  115.      nSortAlgorithm      = TREESORT,             /* default sort type */
  116.      appwindow              = TRUE,                 /* = YES */
  117.      added_bytes          = 0,                     /* used for debugging-- tracks */
  118.                                                    /* the # of bytes allocated */
  119.      files_selected      = 0,                        /* no files selected */
  120.      screenisopen          = FALSE,                 /* = NO */
  121.      windowisopen          = FALSE,                  /* = NO */
  122.      noparse              = FALSE,                  /* = yes, parse */
  123.      nocommand             = FALSE,                 /* = yes, generate command */
  124.      nosplit              = FALSE,                 /* = yes, split */
  125.      nocd                 = FALSE,                 /* = generate CD commands */
  126.      mgetNGad_height      = 248,                     /* default first listview height */
  127.      keepblanklines         = FALSE;                /* = don't show blank lines */
  128.  
  129. ULONG kbytes_selected = 0;                                
  130.      
  131. UWORD windowwidth       = MAXINT,                    /* window will be sized to fill */
  132.         windowheight  = MAXINT,                    /* screen unless these are */
  133.         windowtop       = 0,                         /* overridden by parameters */
  134.         windowleft       = 0;
  135.         
  136.  
  137. void *findvi = NULL;
  138.  
  139. struct Library *Intuitionbase            = NULL;
  140. struct GfxBase *GraphicsBase            = NULL;
  141. struct Library *GadToolsBase            = NULL;
  142. struct Library *UtilityBase                = NULL;
  143. struct Library *AslBase                    = NULL;
  144. struct Library *IconBase                = NULL;
  145. struct Library *WorkbenchBase            = NULL;
  146. struct WBArg *argptr = NULL;
  147.  
  148. struct IntuiMessage *message                 = NULL;
  149. struct List *filelist                         = NULL, 
  150.                 *getlist                         = NULL;
  151. struct Node *search_current                 = NULL;
  152. struct Gadget *findgadlist                 = NULL;
  153. struct TextFont *listfontdata = NULL;
  154.  
  155. __chip UWORD waitPointer[] =
  156.     {
  157.     0x0000, 0x0000,
  158.     0x0400, 0x07c0,
  159.     0x0000, 0x07c0,
  160.     0x0100, 0x0380,
  161.     0x0000, 0x07e0,
  162.     0x07c0, 0x1ff8,
  163.     0x1ff0, 0x3fec,
  164.     0x3ff8, 0x7fde,
  165.     0x3ff8, 0x7fbe,
  166.     0x7ffc, 0xff7f,
  167.     0x7efc, 0xffff,
  168.     0x7ffc, 0xffff,
  169.     0x3ff8, 0x7ffe,
  170.     0x3ff8, 0x7ffe,
  171.     0x1ff0, 0x3ffc,
  172.     0x07c0, 0x1ff8,
  173.     0x0000, 0x07e0,
  174.     0x0000, 0x0000};
  175.     
  176.  
  177. void debug(int a)
  178. {
  179.     fprintf(fpOut,"debug  %i\n",a);
  180.     Delay(80);
  181. }
  182.  
  183.  
  184.  
  185.  
  186. void EOLParse(char *sString)
  187. {
  188. char sTempString[50], sTemp2[2] = " "; 
  189. char * sCurrent = sString;
  190. int i=0, nStringLength;
  191.  
  192. if (sString == NULL) return;
  193. nStringLength = strlen(sString); 
  194. memset(sTempString,'\0',sizeof(sTempString));
  195.  
  196. while ((i<(sizeof(sTempString)-1))&&(*sCurrent != '\0'))
  197. {
  198.     if (*sCurrent == '\\')
  199.     {
  200.         sCurrent++; i++;
  201.         switch(*sCurrent)
  202.         {
  203.             case 'r':
  204.                 strncat(sTempString,"\r",sizeof(sTempString));
  205.             break;
  206.             
  207.             case 'n':
  208.                 strncat(sTempString,"\n",sizeof(sTempString));
  209.             break;
  210.         
  211.             case '\0':
  212.                 i = nStringLength + 1;    /* get out of the loop! */
  213.             break;
  214.             
  215.             case '\\':
  216.                 strncat(sTempString,"\\",sizeof(sTempString));
  217.             break;                
  218.             
  219.             default:
  220.                 sTemp2[0] = *sCurrent;
  221.                 strncat(sTempString,"\\",sizeof(sTempString));                
  222.                 strncat(sTempString,sTemp2,sizeof(sTempString));
  223.                 i++;
  224.             break;
  225.         }
  226.     }
  227.     else
  228.     {
  229.         sTemp2[0] = *sCurrent;
  230.         strncat(sTempString, sTemp2, sizeof(sTempString));
  231.         i++;
  232.     }
  233.     sCurrent++;
  234. }
  235. strncpy(sString,sTempString,nStringLength);
  236. return;
  237. }
  238.  
  239.  
  240.  
  241.  
  242.  
  243. /* If *index isn't NULL, that location will be set to the index
  244.    value of the tail of the list */
  245. struct Node * TailOf(struct List *thislist, int *index)
  246. {
  247.     struct Node *CurrentNode = thislist->lh_Head;
  248.     int nTempIndex = 0;
  249.     
  250.     /* traverse to tail of list */
  251.     while ((CurrentNode != NULL)&&(CurrentNode->ln_Succ != NULL))
  252.     {
  253.         nTempIndex++;
  254.         CurrentNode = CurrentNode->ln_Succ;
  255.     }
  256.  
  257.     if (index != NULL) *index = nTempIndex;
  258.  
  259.     return(CurrentNode);
  260. }
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267. /* Return index in list of the current 1st visible node */
  268. LONG ListViewTop (struct Gadget *gad, struct Window *win)
  269. {
  270.    LONG top;
  271.  
  272.     /* use Official attributes function if running under 3.0+, otherwise
  273.        hack into the Gadget struct to find out */
  274.    if (GadToolsBase->lib_Version >= 39)
  275.       GT_GetGadgetAttrs (gad, win, NULL, GTLV_Top, &top, TAG_END);
  276.    else
  277.       top = (LONG)(*(short *)(((char *)gad)+sizeof(struct Gadget)+4));
  278.  
  279.    return (top);
  280. }
  281.  
  282.  
  283.  
  284. /* return pointer to first visible node in thisGad, thislist */
  285. struct Node * ListViewTopNode(struct Gadget *thisGad, struct List *thislist)
  286. {
  287.     int nTemp = 0;
  288.     int nTop = ListViewTop(thisGad,mgetWnd);
  289.     struct Node *CurrentNode = NULL;
  290.  
  291.     CurrentNode = thislist->lh_Head;
  292.     while (nTemp < nTop) {CurrentNode = CurrentNode->ln_Succ; nTemp++;}
  293.     return(CurrentNode);
  294. }
  295.  
  296.  
  297.  
  298. int isAminetParsable(char *dataline)
  299. {
  300.     BOOL BValidLine;
  301.     
  302.     /* check to make sure string is a valid file line */
  303.     if ((dataline == NULL)||(dataline[0] == '\0')||(dataline[Not[keepblanklines]] == '\0')) return(FALSE);    
  304.         
  305.     if (!noparse)
  306.     {
  307.         if (((dataline[nNameCol] < '0')||(dataline[nNameCol] > 'z')) ||
  308.             ((dataline[nKCol] != 'K')&&(dataline[nKCol] != 'M')&&(dataline[nKCol] != '?')) || 
  309.             (dataline[nDirCol] < '0') || (dataline[nDirCol] > 'z') ||
  310.             (dataline[nDescCol] < 'A') || (dataline[nDescCol] > 'z') ||
  311.             ((dataline[nPlusCol] != '+')&&(dataline[nPlusCol] != '*')&&(dataline[nPlusCol] != ' ')) ||
  312.             ((filesflag == 0)&&(dataline[nPlusCol] != '+')))
  313.         {
  314.             /* Problem line--rescan! */
  315.             BValidLine = ReScanAminetLine(dataline);
  316.             if (filesflag == 0) return(BValidLine && (dataline[nPlusCol] == '+'));
  317.             else return(BValidLine);
  318.         }
  319.     }    
  320.     return(TRUE);
  321. }
  322.  
  323.  
  324. /* This function looks at an Aminet line and if successful, will update
  325.    the global n#?Col variables to reflect the columns found in this line
  326.    Returns 0 on failure (and won't update the global vars), or 1 on 
  327.    success (vars were all updated) */
  328. int ReScanAminetLine(char *dataline)
  329. {
  330.     BOOL BDone = FALSE;
  331.     int nCount = 0;
  332.     int nTempNameCol = -1;
  333.     int nTempKCol    = -1;
  334.     int nTempDirCol  = -1;
  335.     int nTempPlusCol = -1;
  336.     int nTempDescCol = -1;
  337.     int nState = 0;                /* State 0 = haven't found filename yet */
  338.                                 /* State 1 = reading thru filename */
  339.                                 /* State 2 = haven't found directory yet */
  340.                                 /* State 3 = haven't found K/M thingy yet */
  341.                                 /* State 4 = haven't found weeks yet */
  342.                                 /* State 5 = Looking for plus symbol */
  343.                                 /* State 6 = Backtracking for age field */
  344.     char *pcThisChar = dataline;
  345.     
  346.     if (pcThisChar == NULL) return(0);
  347.     
  348.     while((*pcThisChar != '\0')&&(BDone == FALSE))
  349.     {
  350.         switch (nState)
  351.         {
  352.             case 0:        /* Looking for start of file name */
  353.                 if ((*pcThisChar >= '0')&&(*pcThisChar <= 'z'))
  354.                 {
  355.                     nTempNameCol = nCount;
  356.                     nState = 1;
  357.                 }
  358.                 pcThisChar++; 
  359.                 nCount++;
  360.                 break;
  361.             
  362.             case 1:        /* Reading thru filename */
  363.                 if (*pcThisChar == ' ')
  364.                 {
  365.                     nState = 2;
  366.                 }
  367.                 else
  368.                 {
  369.                     pcThisChar++; 
  370.                     nCount++;
  371.                 }
  372.                 break;
  373.             
  374.             case 2:    /* Moving over spaces after filename */
  375.                 if (*pcThisChar != ' ')
  376.                 {
  377.                     nTempDirCol = nCount;
  378.                     nState = 3;
  379.                 }
  380.                 pcThisChar++;
  381.                 nCount++;
  382.                 break;
  383.             
  384.             case 3:    /* Moving thru directory */
  385.                 if (*pcThisChar == ' ')
  386.                 {
  387.                     nState = 4;
  388.                 }
  389.                 pcThisChar++;
  390.                 nCount++;
  391.                 break;
  392.             
  393.             case 4: /* Looking for KCol */
  394.                 if ((*pcThisChar == 'K')||(*pcThisChar == 'M')||(*pcThisChar == '?'))
  395.                 {
  396.                     nTempKCol = nCount;
  397.                     nState = 5;
  398.                 }        
  399.                 pcThisChar++;
  400.                 nCount++;
  401.                 break;
  402.             
  403.             case 5: /* Looking for plus symbol */
  404.                 if (*pcThisChar == '+')
  405.                 {
  406.                     nTempPlusCol = nCount;
  407.                     nTempDescCol = nCount + 1;
  408.                     nState = 6;
  409.                     pcThisChar--;    /* move back to the left of + */
  410.                     nCount--;
  411.                 }
  412.                 else if ((*pcThisChar > '9')&&(*pcThisChar < '0')&&(*pcThisChar != ' '))
  413.                 {
  414.                     nTempPlusCol = nCount - 1;
  415.                     if (nTempPlusCol < 0) nTempPlusCol = 0;
  416.                     nTempDescCol = nCount;
  417.                     nState = 6;
  418.                     pcThisChar -= 2;    /* move back to the left of the */
  419.                     nCount     -= 2;    /* first comment char AND the space */
  420.                 }
  421.                 else
  422.                 {
  423.                     pcThisChar++;
  424.                     nCount++;
  425.                 }
  426.                 break;
  427.         
  428.             case 6: /* Backtracking, looking for rightmost digit in age column */
  429.                 if (((*pcThisChar >= '0')||(*pcThisChar <= '9'))||(nCount == 0))
  430.                 {
  431.                     nAgeCol = nCount;
  432.                     BDone = TRUE;
  433.                 }
  434.                 else
  435.                 {
  436.                     pcThisChar--;
  437.                     nCount--;
  438.                 }
  439.                 break;
  440.         }
  441.     }        
  442.     
  443.     /* Now we see if we've got something valid */
  444.     if (nState < 5) return(0);
  445.     
  446.     /* This in case there was no plus on this line! */
  447.     if (nTempPlusCol == -1) nTempPlusCol = nTempKCol + 1;
  448.     if (nTempDescCol == -1) nTempDescCol = (nTempPlusCol + (dataline[nTempPlusCol] != '\0'));
  449.     
  450.     /* Assign global vars */
  451.     nNameCol = nTempNameCol;
  452.     nDirCol  = nTempDirCol;
  453.     nKCol    = nTempKCol;
  454.     nPlusCol = nTempPlusCol;
  455.     nAgeCol  = nTempPlusCol - 1;
  456.     nDescCol = nTempDescCol;
  457.     if (nAgeCol < 0) nAgeCol = 0;
  458.     return(1);
  459. }
  460.     
  461.     
  462.     
  463.             
  464. int listviewgadgetClicked (VOID)
  465. {
  466. int i;
  467. struct Node *current = filelist->lh_Head;
  468. char *dataline = NULL;
  469.  
  470.  
  471.  for (i=0; i<lastcode; i++) current = current->ln_Succ;
  472.  
  473.  if (current != NULL)
  474.  {
  475.     /* Take it out of filelist */
  476.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  477.     GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  478.  
  479.     TransferToSelected(current);
  480.  
  481.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  482.     GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  483.  }
  484.  return(1);    
  485. }
  486.  
  487.  
  488.  
  489.  
  490.  
  491.  
  492.  
  493. int list2Clicked (VOID)
  494. {
  495.  /* This function will move a clicked item from the lower list to the upper one */
  496.  int i;
  497.  struct Node *current = getlist->lh_Head;
  498.  
  499.  for (i=0; i<lastcode; i++) current = current->ln_Succ;
  500.     
  501.  if (current != NULL)
  502.  {
  503.     GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  504.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  505.  
  506.     TransferToFiles(current);
  507.  
  508.     GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  509.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  510.  }
  511. }
  512.  
  513.  
  514.  
  515.  
  516.  
  517.  
  518. void TransferToSelected(struct Node *current)
  519. {
  520.  
  521.     if (isAminetParsable(current->ln_Name) == FALSE) return;  /* don't transfer what you cant understand */
  522.  
  523.     UpdateByteCount(current->ln_Name,1);
  524.     
  525.     /* Watch out for the nasty case where our search buffer just got removed */
  526.     if (search_current == current) 
  527.     {
  528.         if (search_current->ln_Pred != NULL)
  529.         {
  530.             search_current = search_current->ln_Pred;
  531.             search_index--;
  532.         }
  533.         else
  534.         {
  535.             search_current = search_current->ln_Succ;
  536.             search_index++;
  537.         }
  538.         
  539.         /* Check to see if we've walked off the front or back of the list */
  540.         /* If we have, default to the head of the list */
  541.         if (search_current == NULL) 
  542.         {
  543.             
  544.                 search_current = filelist->lh_Head;
  545.                 search_index = 0;
  546.         }
  547.     }
  548.  
  549.     Remove(current);
  550.     /* And insert it in getlist */
  551.     if ((nKeepSorted[1] == 1)&&(!noparse))
  552.     {
  553.         SmartAdd(getlist,current,nSortType[1]);
  554.     }
  555.     else
  556.     {
  557.         AddTail(getlist,current);
  558.     }
  559.     
  560.     
  561.     files_selected++;
  562.     filelist_length--;
  563.     getlist_length++;
  564.     
  565.     ChangeWindowTitle();
  566. }
  567.  
  568.  
  569.  
  570.  
  571. void TransferToFiles(struct Node *current)
  572. {
  573.     UpdateByteCount(current->ln_Name,-1);
  574.  
  575.     /* Take it out of getlist */
  576.     Remove(current);
  577.     current->ln_Succ = NULL;        /* Clear now invalid field */
  578.  
  579.     /* And insert it in filelist */
  580.      if ((nKeepSorted[0] == 1)&&(!noparse))
  581.      {    
  582.          SmartAdd(filelist,current,nSortType[0]);
  583.      }
  584.     else
  585.     {
  586.         AddTail(filelist,current);
  587.     }
  588.     
  589.     /* and that's it! */
  590.     files_selected--;
  591.     filelist_length++;
  592.     getlist_length--;
  593.  
  594.     ChangeWindowTitle();
  595. }
  596.  
  597.  
  598.  
  599.  
  600.  
  601.  
  602.  
  603.  
  604. /* Returns file size, in weeks, of the given Aminet line--only
  605.    works if said file size is available, of course */
  606. int AminetFileAge(char *sString)
  607. {
  608.     int nTemp;
  609.     int nSum = 0;
  610.     
  611.     if (isAminetParsable(sString) == FALSE) return(0);
  612.     nTemp = nAgeCol;
  613.     
  614.     /* If no date available on this line, return error. */
  615.     if ((sString[nTemp] < '0')||(sString[nTemp] > '9')) return(-999);
  616.     
  617.     while ((sString[nTemp] >= '0')&&(sString[nTemp] <= '9')&&(nTemp >= 0))
  618.     {
  619.         nSum *= 10;
  620.         nSum += sString[nTemp] - '0';
  621.         nTemp--;
  622.     }
  623.     
  624.     return(nSum);
  625. }
  626.  
  627.  
  628.  
  629. int AminetFileSize(char *sString)
  630. {
  631. /* Returns file size, in kilobytes, of the given Aminet line */
  632. int multiplier;
  633. int filesize = 0, wholenum;
  634. int outputlength = -1;
  635. int tenthofmultiplier = 0;
  636.  
  637.     if (isAminetParsable(sString) == FALSE) return(0);
  638.     
  639.     switch (sString[nKCol])
  640.     {
  641.         case 'M':
  642.             multiplier = 1024;   /* 1024 k in a M */
  643.             tenthofmultiplier = 102;
  644.             break;
  645.             
  646.         case 'K': 
  647.             multiplier = 1;     /* 1 k in a k */
  648.             break;
  649.         
  650.         case '?':
  651.             multiplier = 0;
  652.             break;
  653.             
  654.         default:
  655.             return(FALSE);
  656.     }
  657.     
  658.     if (sString[nKCol-2] == '.')        /* for when it's like:  3.5M */
  659.     {
  660.         /* figure out kilobytes */
  661.         wholenum = (int) (sString[nKCol-3] - '0');
  662.         
  663.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (multiplier * wholenum);
  664.         
  665.         wholenum = (int) (sString[nKCol-1] - '0');
  666.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (tenthofmultiplier * wholenum);
  667.     }
  668.     else
  669.     {
  670.         wholenum = (int) (sString[nKCol-3] - '0');
  671.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (100 * multiplier * wholenum);
  672.  
  673.         wholenum = (int) (sString[nKCol-2] - '0');
  674.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + ( 10 * multiplier * wholenum);
  675.  
  676.         wholenum = (int) (sString[nKCol-1] - '0');
  677.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (      multiplier * wholenum);
  678.     }
  679.     
  680.     return(filesize);
  681. }
  682.  
  683.  
  684.  
  685. void SmartAdd(struct List *thislist, struct Node *addme, int nThisSortType)
  686. {
  687. /* a simple add into the correct order of the list */
  688. struct Node *current, *past;
  689. char sBuffer1[43], sBuffer2[43];
  690.  
  691. current = thislist->lh_Head;
  692. past = NULL;
  693.  
  694. if ((addme == NULL)||(addme->ln_Name == NULL)) 
  695. {
  696.     printf("Tell Jeremy--bug #5!\n");
  697.     return();
  698. }
  699.  
  700. while (current != NULL)            
  701.         {
  702.             /* Only sort if this is an Aminet file line, or not an Aminet Sort */    
  703.             if ((current->ln_Name != NULL)&&(isAminetParsable(current->ln_Name)&&isAminetParsable(addme->ln_Name)))
  704.             {
  705.                 switch(nThisSortType)
  706.                 {
  707.                     case SORTBYDIR:
  708.                         strncpy(sBuffer1,addme->ln_Name+nDirCol,DIRNAMESIZE);
  709.                         strncpy(sBuffer2,current->ln_Name+nDirCol,DIRNAMESIZE);
  710.                         if ((strchr(sBuffer1,'/') != NULL)&&
  711.                              (strchr(sBuffer2,'/') != NULL)&&
  712.                               (strncmp(sBuffer1,sBuffer2,DIRNAMESIZE) < 0))
  713.                         {
  714.                             Insert(thislist, addme, past);    /* and put it back in after current */
  715.                             return();
  716.                         }
  717.                     break;
  718.                 
  719.                     case SORTBYDESC:
  720.                         if (strncmp(addme->ln_Name+nDescCol,current->ln_Name+nDescCol,DESCSIZE) < 0)
  721.                         {
  722.                             Insert(thislist, addme, past);    /* and put it back in after current */
  723.                             return();
  724.                         }
  725.                     break;
  726.                     
  727.                     case SORTBYNAME:
  728.                         memset(sBuffer1,NUL,NAMESIZE);  /* sort sometimes goes into infinite loops if you don't have this??? */
  729.                         memset(sBuffer2,NUL,NAMESIZE);  /* It shouldn't, though, because strncpy terminates everything right? */
  730.                         strncpy(sBuffer1,addme->ln_Name+nNameCol,NAMESIZE);
  731.                         strncpy(sBuffer2,current->ln_Name+nNameCol,NAMESIZE);    
  732.                         if (strncmp(sBuffer1,sBuffer2,NAMESIZE) < 0)
  733.                         {
  734.                             Insert(thislist, addme, past);    /* and put it back in after current */        
  735.                             return();
  736.                         }
  737.                     break;
  738.                     
  739.                     case SORTBYSIZE:
  740.                         if (AminetFileSize(addme->ln_Name) < AminetFileSize(current->ln_Name))
  741.                         {
  742.                             Insert(thislist, addme, past);    /* and put it back in after current */
  743.                             return();
  744.                         }
  745.                         
  746.                     case SORTBYAGE:
  747.                         if (AminetFileAge(addme->ln_Name) < AminetFileAge(current->ln_Name))
  748.                         {
  749.                             Insert(thislist, addme, past);    /* and put it back in after current */
  750.                             return();
  751.                         }
  752.  
  753.                     break;
  754.                 }
  755.             }    
  756.             past = current;                /* step to next in list */
  757.             current = current->ln_Succ;
  758.         }
  759.         
  760.     AddTail(thislist,addme);        /* If we've got to the end without returning, add it to the end */
  761.     return();
  762. }
  763.  
  764.  
  765.  
  766.  
  767.  
  768. int CompareByDir(struct Node *past, struct Node *current)
  769. {
  770.     static char sBuffer1[43], sBuffer2[43];  /* static to avoid re- and de-allocing */
  771.     
  772.     if (isAminetParsable(current->ln_Name) == FALSE) return(-999);     /* error! */
  773.          
  774.     if (sortcasesensitive == TRUE) 
  775.         return(strncmp(past->ln_Name+nDirCol,current->ln_Name+nDirCol,DIRNAMESIZE));  /* For Lists, > 0 = switch */
  776.  
  777.     /* case insensitive */    
  778.     strncpy(sBuffer1,past->ln_Name+nDirCol,DIRNAMESIZE);
  779.     strncpy(sBuffer2,current->ln_Name+nDirCol,DIRNAMESIZE);
  780.     UpperCase(sBuffer1);        /* not case sensitive */
  781.     UpperCase(sBuffer2);
  782.     
  783.     return(strncmp(sBuffer1,sBuffer2,DIRNAMESIZE));  /* For Lists, > 0 = switch */
  784. }
  785.  
  786.  
  787.  
  788.     
  789. int CompareByDesc(struct Node *past, struct Node *current)
  790. {
  791.     static char sBuffer1[43], sBuffer2[43];  /* static to avoid re- and de-allocing */
  792.  
  793.     /* Make sure the comment is ok! */
  794.     if (isAminetParsable(current->ln_Name) == FALSE) return(-999);     /* error! */
  795.     
  796.     if (sortcasesensitive == TRUE) return(strncmp(past->ln_Name+nDescCol,current->ln_Name+nDescCol,DESCSIZE));
  797.  
  798.     /* For Lists, > 0 = switch */
  799.     strncpy(sBuffer1,past->ln_Name+nDescCol,DESCSIZE);        /* copies to modify */
  800.     strncpy(sBuffer2,current->ln_Name+nDescCol,DESCSIZE);    
  801.     UpperCase(sBuffer1);        /* not case sensitive */
  802.     UpperCase(sBuffer2);
  803.     
  804.    return(strncmp(sBuffer1, sBuffer2,DESCSIZE));
  805. } 
  806.     
  807.  
  808.  
  809.     
  810.  
  811.  
  812. int CompareByName(struct Node *past, struct Node *current)
  813. {
  814.     static char sBuffer1[43], sBuffer2[43];  /* static to avoid re- and de-allocing */
  815.  
  816.     /* Make sure the comment is ok! */
  817.     if (isAminetParsable(current->ln_Name) == FALSE) return(-999);     /* error! */
  818.  
  819.     if (sortcasesensitive == TRUE) return(strncmp(past->ln_Name+nNameCol,current->ln_Name+nNameCol,NAMESIZE));
  820.     
  821.     /* case insensitive test below */    
  822.     strncpy(sBuffer1,past->ln_Name+nNameCol,NAMESIZE);
  823.     strncpy(sBuffer2,current->ln_Name+nNameCol,NAMESIZE);    
  824.     UpperCase(sBuffer1);
  825.     UpperCase(sBuffer2);
  826.     
  827.     return(strncmp(sBuffer1,sBuffer2,NAMESIZE));
  828. }
  829.  
  830.  
  831.  
  832.  
  833.  
  834. int CompareBySize(struct Node *past, struct Node *current) 
  835. {
  836.     return(AminetFileSize(past->ln_Name) - AminetFileSize(current->ln_Name));
  837. }
  838.  
  839.  
  840. int CompareByAge(struct Node *past, struct Node *current) 
  841. {
  842.     return(AminetFileAge(past->ln_Name) - AminetFileAge(current->ln_Name));
  843. }
  844.  
  845.  
  846. void SortList(struct List *thislist, int nThisSortType)
  847. {
  848.     static char sSortTypeString[40];
  849.     char *sSortWinString;
  850.     
  851.     strcpy(sSortTypeString, "Sorting by \0");
  852.     
  853.     if (windowisopen) SetWindowTitles(mgetWnd, "Sorting--please be patient", (char *) ~0); 
  854.  
  855.     /* Generate Window title prompt */
  856.     switch(nThisSortType)
  857.     {
  858.         case SORTBYDIR:
  859.             strcat(sSortTypeString,"Directory: ");
  860.         break;
  861.         
  862.         case SORTBYSIZE:
  863.             strcat(sSortTypeString,"Size: ");
  864.         break;
  865.         
  866.         case SORTBYDESC:
  867.             strcat(sSortTypeString,"Description: ");
  868.         break;
  869.  
  870.         case SORTBYNAME:
  871.             strcat(sSortTypeString,"FileName: ");
  872.         break;
  873.         
  874.         default:
  875.             strcat(sSortTypeString,"Unknown: ");
  876.         break;
  877.     }
  878.  
  879.     sSortWinString = strrchr(sSortTypeString,' ') + 1;        /* Where to write next */
  880.     sTreeWriteHere = sSortWinString;
  881.     szTickerString = sSortTypeString;
  882.             
  883.     if (thislist == NULL) return;
  884.     
  885.     /* Remove list from ListView if necessary  */
  886.      if (windowisopen)
  887.      {
  888.           if (thislist == filelist) GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  889.          if (thislist ==  getlist) GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  890.         SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  891.     }
  892.  
  893.     switch (nSortAlgorithm)
  894.     {
  895.          case BUBBLESORT: BubbleSortList(thislist, nThisSortType, sSortWinString, sSortTypeString); break;
  896.          case TREESORT:   TreeSortList  (thislist, nThisSortType, sSortWinString, sSortTypeString); break;
  897.      }
  898.      
  899.      if (windowisopen)
  900.     {
  901.         /* Replace list into ListView */
  902.         if (thislist == filelist) GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  903.         if (thislist ==  getlist) GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels,  getlist, TAG_END);
  904.         ClearPointer(mgetWnd);
  905.     }
  906.     ChangeWindowTitle();
  907.  
  908. }
  909.  
  910.  
  911.  
  912.  
  913.  
  914. int TreeSortUserCompare(struct Node *thisnode, struct Node *thatnode)
  915. {
  916.     int nResult;
  917.         
  918.     switch(nForTreeSortUseOnly)  /* using a global variable here stinks :( */
  919.     {
  920.         case SORTBYDIR:  nResult = CompareByDir (thisnode, thatnode); break;
  921.         case SORTBYNAME: nResult = CompareByName(thisnode, thatnode); break;
  922.         case SORTBYSIZE: nResult = CompareBySize(thisnode, thatnode); break;
  923.         case SORTBYDESC: nResult = CompareByDesc(thisnode, thatnode); break;
  924.         case SORTBYAGE:  nResult = CompareByAge (thisnode, thatnode); break;
  925.     }
  926.     if (nResult == 0) return(1);  /* default value can't be zero! */
  927.     return(nResult);
  928. }
  929.  
  930.  
  931.  
  932.  
  933. void TreeSortList(struct List *thislist, int nThisSortType, char *sSortWinString, char *sSortTypeString)    
  934. {
  935.     struct Node *CurrentNode = thislist->lh_Head;
  936.     tree *mytree = NULL;                                    
  937.     
  938.     /* make tree out of our list */
  939.     tree_init(&mytree);
  940.  
  941.     /* set global variables for TreeSortUserCompare and TransferNode's use */    
  942.     nForTreeSortUseOnly = nThisSortType;   /* Used by TreeSortUserCompare  */
  943.     lForTreeSortUseOnly = thislist;          /* Used by TransferNode         */
  944.     
  945.     lTreeTicker = 0;
  946.     lTreeSubTicker = 0;
  947.     
  948.     while (CurrentNode != NULL)
  949.     {        
  950.         if (CurrentNode->ln_Succ != NULL)    /* This is necessary to avoid the "killer node" ??? */
  951.             tree_add(&mytree, TreeSortUserCompare, (char *) CurrentNode, DeleteNodeError);
  952.     
  953.         CurrentNode = CurrentNode->ln_Succ;        /* move down the list */
  954.     }
  955.  
  956.     /* traverse tree, inserting into new list */
  957.     /* nAbort now stays true only if both of the below are true */
  958.     if (tree_trav(&mytree,TransferNode) == FALSE)
  959.         MakeReq("Tree Sort Error","Warning:  Tree Sort failed; list may be incomplete", "Uh-Oh");
  960.     
  961.     /* now clean up the tree -- since Nodes are still in a List, we don't want to delete them */
  962.      tree_mung(&mytree, DoNothing);
  963. }    
  964.  
  965.  
  966.  
  967. int DoNothing (struct Node *thisnode)
  968. {
  969.    /* and here is the magic code to .... do nothing! */
  970.    return(0);
  971. }
  972.  
  973.  
  974.  
  975.  
  976.  
  977. int TransferNode(struct Node *thisnode)
  978. {    
  979.     if (isAminetParsable(thisnode->ln_Name))
  980.     {
  981.         Remove(thisnode); 
  982.         AddTail((struct List *) lForTreeSortUseOnly, thisnode); 
  983.     }
  984.     return(TRUE);
  985. }
  986.  
  987.  
  988.  
  989.  
  990.  
  991.  
  992. int PrintNodeData(struct Node *thisnode)
  993. {
  994.  
  995.     if (thisnode == NULL) 
  996.     {
  997.         printf("PND:  called with thisnode == NULL!\n");
  998.         return(FALSE);
  999.     }
  1000.     if (thisnode->ln_Name == NULL) 
  1001.     {
  1002.         printf("PND:  called with thisnode->ln_Name == NULL!\n");
  1003.         return(FALSE);
  1004.     }
  1005.     
  1006.     printf("[%s]\n",thisnode->ln_Name);
  1007.     return(TRUE);
  1008. }
  1009.  
  1010.  
  1011.  
  1012.  
  1013.  
  1014.  
  1015. int DeleteNodeError(struct Node *thisnode)
  1016. {
  1017.     printf("tree_add tried to delete this node:\n");
  1018.     PrintNodeData(thisnode);
  1019. }
  1020.  
  1021.  
  1022.  
  1023.  
  1024.  
  1025.  
  1026. void BubbleSortList(struct List *thislist, int nThisSortType, char *sSortWinString, char *sSortTypeString)
  1027. {
  1028.    /* a simple swap-sort */
  1029.     int nSwappedThisPass = 1, nUpdateTitle = 0, nUpdateCount = 0;
  1030.     struct Node *current, *past;
  1031.  
  1032.     while (nSwappedThisPass > 0)
  1033.     {
  1034.         /* start a pass */
  1035.         past = thislist->lh_Head;
  1036.         if (past == NULL) return;
  1037.         
  1038.         current = past->ln_Succ;
  1039.         nSwappedThisPass = 0;        /* start with none recorded */
  1040.  
  1041.         while (current != NULL)            
  1042.         {
  1043.             /* Only sort if this is an Aminet file line, or not an Aminet Sort */    
  1044.             if ((current->ln_Name != NULL)&&(past->ln_Name != NULL)&&
  1045.                 (isAminetParsable(current->ln_Name)&&isAminetParsable(past->ln_Name)))
  1046.             {
  1047.                 if ((nThisSortType == SORTBYDIR) &&(CompareByDir (past,current) > 0) ||
  1048.                     (nThisSortType == SORTBYSIZE)&&(CompareBySize(past,current) > 0) ||
  1049.                     (nThisSortType == SORTBYDESC)&&(CompareByDesc(past,current) > 0) ||
  1050.                     (nThisSortType == SORTBYNAME)&&(CompareByName(past,current) > 0))
  1051.                 {
  1052.                     /* Swap the two nodes */
  1053.                      Remove(past);
  1054.                      Insert(thislist, past, current);
  1055.                      nSwappedThisPass++;
  1056.                 }
  1057.             }    
  1058.             past = current;
  1059.             current = current->ln_Succ;
  1060.         }
  1061.         
  1062.         if (windowisopen)
  1063.         {
  1064.             sprintf(sSortWinString,"%i",nUpdateCount);
  1065.             SetWindowTitles(mgetWnd, sSortTypeString, (char *) ~0);
  1066.             nUpdateCount++; 
  1067.          }              
  1068.     }        
  1069.     return;
  1070. }
  1071.         
  1072.  
  1073. /* Returns the length of the first "word" in the string, i.e. number
  1074.    of letters before the space */        
  1075. int LengthOfWord(char *szString)
  1076. {
  1077.     char *pcTemp = szString;
  1078.     int nCount = 0;
  1079.     
  1080.     /* skip any leading spaces */
  1081.     while (*pcTemp == ' ') pcTemp++;
  1082.     
  1083.     /* Count chars in word */    
  1084.     while ((*pcTemp != '\0')&&(*pcTemp != ' ')) 
  1085.     {
  1086.         nCount++;
  1087.         pcTemp++;
  1088.     }
  1089.     
  1090.     return(nCount);
  1091. }
  1092.  
  1093.  
  1094.  
  1095.  
  1096. int OutputList(struct List *thislist)
  1097. {
  1098. #define LASTDIRBUFSIZE 30
  1099.  
  1100.  char *p;
  1101.  int k,l,z,next_bytes,putnameOK = 0,putcommandOK = 1; 
  1102.  int printed_bytes = maxoutputlinelength - 1, printreturnfirst = 0;
  1103.  char outname[MAXFILELINELENGTH],szLastDir[LASTDIRBUFSIZE];
  1104.  struct Node *current;
  1105.  
  1106.  memset(szLastDir,NUL,LASTDIRBUFSIZE);
  1107.  
  1108.  /* Get any readme files first, so user can browse them while d/l'ing the rest */
  1109.  if (getreadmes)
  1110.     {
  1111.     current = thislist->lh_Head;
  1112.      while (current != NULL)
  1113.      {
  1114.          /* watch out for empty nodes! */
  1115.         if (isAminetParsable(current->ln_Name))
  1116.         {
  1117.             z = strlen(current->ln_Name);
  1118.             /* Extra filtering code, borrowed from mgetlistviewclicked()... */
  1119.             if ((current->ln_Name[nNameCol] < '0')||(current->ln_Name [nNameCol] > 'z')) z = 0;
  1120.             if (current->ln_Name[nDirCol] < '0') z = 0;
  1121.             if ((filesflag == 0)&&(current->ln_Name[nPlusCol] != '+')) z = 0;
  1122.             /* end code from mgetlistviewclicked() ... */
  1123.         }
  1124.         else z=0;
  1125.         
  1126.         if (z>nDirCol)
  1127.         {
  1128.             k = LengthOfWord(¤t->ln_Name[nNameCol]);    /* length of filename */
  1129.             l = LengthOfWord(¤t->ln_Name[nDirCol]);   /* length of directory */
  1130.     
  1131.             if ((k<(nDirCol+1))&&(k>0)&&(l<12)&&(l>2))
  1132.             {
  1133.                 memset(outname,NUL,MAXFILELINELENGTH);
  1134.                 strncat(outname,¤t->ln_Name[nDirCol],l);
  1135.                 
  1136.                 /* Here we have the directory name--see if it's different, generate cd */
  1137.                 if ((current->ln_Name[nPlusCol] == '+')&&
  1138.                     (nocd == 0)&&
  1139.                     (simplepaths == 1)&&
  1140.                     (strncmp(szLastDir,outname,LASTDIRBUFSIZE) != 0)) 
  1141.                 {
  1142.                     memset(szLastDir,NUL,LASTDIRBUFSIZE);
  1143.                     GenerateCDCommand(&printreturnfirst, &printed_bytes, szLastDir, outname);
  1144.                     putnameOK = 1;
  1145.                     putcommandOK = 0;
  1146.                 }
  1147.                 
  1148.                 if (simplepaths == 1)
  1149.                 {    
  1150.                     /* remove path so it won't be printed again in the mget command */
  1151.                     memset(outname,NUL,sizeof(outname));
  1152.                 }
  1153.                 else
  1154.                 {
  1155.                     strncat(outname,"/",1);
  1156.                 }
  1157.                 
  1158.                 strncat(outname,¤t->ln_Name[nNameCol],k);
  1159.                 outname[79]=0;    /* just in case, we'll reterminate the string */            
  1160.             
  1161.                 if (current->ln_Name[nPlusCol] == '+')
  1162.                     {    
  1163.                     /* find the last '.' in outname, and change whatever's after it to 'readme'! */
  1164.                     p = strrchr(outname,'.');
  1165.                     
  1166.                     /* and if there is no "." ? */
  1167.                     if (p == NULL)
  1168.                     {
  1169.                         strcat(outname,".");
  1170.                         p = strrchr(outname,'.');
  1171.                     }
  1172.                     
  1173.                     strcpy(p+1,"readme");
  1174.                     
  1175.                     next_bytes = strlen(outname) + 1;    /* + 1 for the space */
  1176.                     if ((next_bytes>3)&&(next_bytes<39))
  1177.                         {
  1178.                         if ((putcommandOK == 1)&&(!nosplit)&&((printed_bytes + next_bytes) > maxoutputlinelength))
  1179.                             {
  1180.                             PrintCommandString(&printreturnfirst, &printed_bytes);            
  1181.                             putnameOK = 1;
  1182.                             }            
  1183.                         fprintf(fpOut,"%s ",outname);
  1184.                         printed_bytes = printed_bytes + next_bytes;
  1185.                         putcommandOK = 1;
  1186.                         }
  1187.                     }
  1188.                 }
  1189.             }
  1190.         current = current->ln_Succ;    
  1191.         }
  1192.     }        
  1193.  
  1194.  if (filesflag)
  1195.  {    
  1196.      current = thislist->lh_Head;    
  1197.     while (current != NULL)
  1198.     {
  1199.          /* watch out for empty nodes! */
  1200.         if (isAminetParsable(current->ln_Name))
  1201.         {
  1202.             z = strlen(current->ln_Name);
  1203.             /* Extra filtering code, borrowed from mgetlistviewclicked()... */
  1204.             if ((current->ln_Name[nNameCol] < '0')||(current->ln_Name [nNameCol] > 'z')) z = 0;
  1205.             if ((filesflag == 0)&&(current->ln_Name[nPlusCol] != '+')) z = 0;
  1206.             /* end code from mgetlistviewclicked() ... */
  1207.         }
  1208.         else z=0;
  1209.  
  1210.         if (z>nDirCol)
  1211.         {
  1212.             k = LengthOfWord(¤t->ln_Name[nNameCol]);    /* length of filename */
  1213.             l = LengthOfWord(¤t->ln_Name[nDirCol]);   /* length of directory */
  1214.  
  1215.             if ((k<(nDirCol+1))&&(k>0)&&(l<12)&&(l>2))
  1216.             {
  1217.                 memset(outname,NUL,MAXFILELINELENGTH);
  1218.                 strncat(outname,¤t->ln_Name[nDirCol],l);
  1219.  
  1220.                 /* Here we have the directory name--see if it's different, generate cd */
  1221.                 if ((nocd == 0)&&
  1222.                     (simplepaths == 1)&&
  1223.                     (strncmp(szLastDir,outname,LASTDIRBUFSIZE) != 0)) 
  1224.                 {
  1225.                     memset(szLastDir,NUL,LASTDIRBUFSIZE);
  1226.                     GenerateCDCommand(&printreturnfirst, &printed_bytes, szLastDir, outname);
  1227.                     putcommandOK = 0;
  1228.                     putnameOK = 1;
  1229.                 }
  1230.                 
  1231.                 if (simplepaths == 1)
  1232.                 {    
  1233.                     /* remove path so it won't be printed again in the mget command */
  1234.                     memset(outname,NUL,sizeof(outname));
  1235.                 }
  1236.                 else
  1237.                 {
  1238.                     strncat(outname,"/",1);
  1239.                 }
  1240.                 
  1241.                 
  1242.                 strncat(outname,¤t->ln_Name[nNameCol],k);
  1243.                 outname[79]=0;    /* just in case, we'll reterminate the string */            
  1244.                 if (filesflag)
  1245.                 {    
  1246.                     next_bytes = strlen(outname) + 1;    /* + 1 for the space */
  1247.                     if ((next_bytes>3)&&(next_bytes<33))
  1248.                     {
  1249.                         if ((putcommandOK == 1)&&(!nosplit)&&((printed_bytes + next_bytes) > maxoutputlinelength))
  1250.                         {
  1251.                             PrintCommandString(&printreturnfirst, &printed_bytes);    
  1252.                             putnameOK = 1;
  1253.                         }            
  1254.                         fprintf(fpOut,"%s ",outname);
  1255.                         putcommandOK = 1;
  1256.                         printed_bytes = printed_bytes + next_bytes;
  1257.                     }
  1258.                 }
  1259.             }
  1260.         }    
  1261.     current = current->ln_Succ;    
  1262.     }
  1263.  }
  1264. return(1);
  1265. }
  1266.  
  1267.  
  1268.  
  1269.  
  1270. void PrintCommandString(int *printreturnfirst, int *printed_bytes)
  1271. {
  1272.     if (*printreturnfirst) fprintf(fpOut,sEndOfLineString); 
  1273.     *printreturnfirst = 1;
  1274.         
  1275.     if (nocommand) 
  1276.     {
  1277.         *printed_bytes = 0;
  1278.     }
  1279.     else
  1280.     {
  1281.         fprintf(fpOut,"%s",szCommandString);
  1282.         *printreturnfirst = 1;
  1283.         *printed_bytes = strlen(szCommandString) + 1;    /* reset counter for next batch */
  1284.     }
  1285.     return;
  1286. }
  1287.  
  1288.  
  1289.  
  1290.  
  1291. void GenerateCDCommand(int *printreturnfirst, int *printed_bytes, char *szLastDir, char *outname)
  1292. {
  1293.     if (*printreturnfirst) fprintf(fpOut,sEndOfLineString);
  1294.     fprintf(fpOut,"cd ");
  1295.                 
  1296.     /* On the first item, we will be starting at the aminet root
  1297.        directory, so we won't need to print the ../.. .  After that,
  1298.         though, we will.  printreturnfirst serves nicely to tell
  1299.         whether or not we're in the first iteration. */   
  1300.     
  1301.     if (*printreturnfirst == 1) fprintf(fpOut,sAminetPathString);
  1302.             
  1303.     fprintf(fpOut,"%s",outname);
  1304.     *printreturnfirst = 1;
  1305.     PrintCommandString(printreturnfirst, printed_bytes);
  1306.  
  1307.     /* update buffer */    
  1308.     strncpy(szLastDir,outname,30);    
  1309.  
  1310.     return;
  1311. }            
  1312.  
  1313.  
  1314.  
  1315. int RawOutputList(struct List *thislist)
  1316. {
  1317. struct Node *current = thislist->lh_Head;
  1318. int minlinelength = 1;
  1319.  
  1320.  if (keepblanklines == 1) minlinelength = 0;
  1321.       
  1322.  while (current != NULL)
  1323.     {    
  1324.     if ((current->ln_Name != NULL)&&(current->ln_Name[0] < 128)&&(strlen(current->ln_Name) >= minlinelength))
  1325.         {
  1326.             if (current->ln_Name[0] < 14) 
  1327.             {
  1328.                 fprintf(fpOut,"\n",current->ln_Name);
  1329.             }
  1330.             else
  1331.             {
  1332.                 fprintf(fpOut,"%.300s\n",current->ln_Name);
  1333.             }
  1334.         }
  1335.     current = current->ln_Succ;
  1336.     }
  1337. return(1);
  1338. }
  1339.  
  1340.  
  1341.  
  1342.  
  1343.  
  1344.  
  1345.  
  1346.  
  1347.  
  1348. int MakeReq(char *sText, char *sTitle, char *sGadgets)
  1349. {
  1350.     struct EasyStruct myreq;
  1351.     LONG number = 0L;
  1352.     int nResult;
  1353.     char sDefaultTitle[] = "GadMGet Error";
  1354.     
  1355.     if (sTitle == NULL) sTitle = sDefaultTitle;
  1356.     if (sText == NULL) sText = sDefaultTitle;
  1357.     if (sGadgets == NULL) sGadgets = "OK";
  1358.     
  1359.     myreq.es_TextFormat   = sText;
  1360.     myreq.es_Title        = sTitle;
  1361.     myreq.es_GadgetFormat = sGadgets;
  1362.     
  1363.     if (mgetWnd != NULL) SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  1364.     nResult = EasyRequest(mgetWnd, &myreq, NULL, NULL, number);
  1365.     if (mgetWnd != NULL) ClearPointer(mgetWnd);
  1366.     return(nResult);
  1367. }
  1368.  
  1369.  
  1370. int mgettreesort (VOID)
  1371. {
  1372.     nSortAlgorithm = TREESORT;
  1373.     SetMenuValues();
  1374. }
  1375.  
  1376. int mgetbubblesort (VOID)
  1377. {
  1378.     nSortAlgorithm = BUBBLESORT;
  1379.     SetMenuValues();
  1380. }    
  1381.  
  1382. int mgetsortcase (VOID)
  1383. {
  1384.     sortcasesensitive = Not[sortcasesensitive];
  1385.     if (nKeepSorted[0] == 1) SortList(filelist,nSortType[0]);
  1386.     if (nKeepSorted[1] == 1) SortList(getlist, nSortType[1]);
  1387.     SetMenuValues();
  1388. }
  1389.  
  1390.  
  1391.  
  1392.  
  1393.  
  1394.  
  1395.  
  1396.  
  1397. int mgetabout (VOID)
  1398. {
  1399.     char sAboutText[100];
  1400.  
  1401.     strcpy(sAboutText,pnamestring);
  1402.     strcat(sAboutText,"\n\nby Jeremy Friesner\njfriesne@ucsd.edu\n");
  1403.     MakeReq(sAboutText,"About GadMGet","Hey, Cool!");
  1404.     return(1);
  1405. }
  1406.  
  1407.  
  1408.  
  1409.  
  1410.  
  1411.  
  1412.  
  1413.  
  1414. int mgetquit (VOID)
  1415. {
  1416.     done=TRUE;
  1417. }
  1418.  
  1419.  
  1420.  
  1421.  
  1422. int mgetmultiselect(VOID)
  1423. {
  1424. int lin, nSortAtEnd = FALSE;
  1425. struct Node *select_current = filelist->lh_Head, *select_next = NULL;
  1426. char sUpperBuffer[MAXFILELINELENGTH],sUpperSearchString[MAXFILELINELENGTH];
  1427.  
  1428. requesttype = SELECT_REQUESTTYPE;       /* This is a HORRIBLE way to program, but I don't want  */
  1429. lin = mgetfind();                                /* to try to change the parameters since it might screw */
  1430. requesttype = FIND_REQUESTTYPE;            /* up the mget_listview2 functions...                        */
  1431.  
  1432.  if (lin == TRUE) 
  1433.  {
  1434.     SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  1435.      GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  1436.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  1437.         
  1438.     if (searchcasesensitive)    
  1439.     {            
  1440.         while (select_current != NULL)
  1441.         {
  1442.             if ((nKeepSorted[1] == TRUE)&&(getlist_length > 240))
  1443.             {
  1444.                   nSortAtEnd = TRUE;                        /* remember to sort when done */
  1445.                   nKeepSorted[1] = FALSE;
  1446.             }       
  1447.  
  1448.             if ((select_current->ln_Name != NULL)&&
  1449.                 (strstr(select_current->ln_Name,sMultiSelect) != 0))
  1450.             {
  1451.                 select_next = select_current->ln_Succ;
  1452.                 TransferToSelected(select_current);
  1453.                 select_current = select_next;
  1454.             }
  1455.             else
  1456.             {
  1457.                 select_current = select_current->ln_Succ; 
  1458.             }
  1459.         }
  1460.     }
  1461.     else
  1462.     {
  1463.         strncpy(sUpperSearchString,sMultiSelect,sizeof(sUpperSearchString));
  1464.         UpperCase(sUpperSearchString);
  1465.         while (select_current != NULL)
  1466.         {
  1467.             if ((nKeepSorted[1] == TRUE)&&(getlist_length > 240))
  1468.             {
  1469.                   nSortAtEnd = TRUE;                        /* remember to sort when done */
  1470.                   nKeepSorted[1] = FALSE;
  1471.             }       
  1472.  
  1473.             if (select_current->ln_Name != NULL)
  1474.             {
  1475.                 strncpy(sUpperBuffer,select_current->ln_Name,sizeof(sUpperBuffer)-1);
  1476.                 UpperCase(sUpperBuffer);
  1477.  
  1478.                 if (strstr(sUpperBuffer,sUpperSearchString) != 0)
  1479.                 {
  1480.                     select_next = select_current->ln_Succ;
  1481.                     TransferToSelected(select_current);
  1482.                     select_current = select_next;
  1483.                 }
  1484.                 else
  1485.                 {
  1486.                     select_current = select_current->ln_Succ; 
  1487.                 }
  1488.             }
  1489.             else
  1490.             {
  1491.                     select_current = select_current->ln_Succ; 
  1492.             }
  1493.         }
  1494.     }
  1495.  
  1496.  if (nSortAtEnd == TRUE)
  1497.  {
  1498.      mgetgetkeep();        /* Sort files now, at the end */
  1499.  }
  1500.  
  1501.  GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  1502.  GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  1503.  
  1504.  ChangeWindowTitle();
  1505.  ClearPointer(mgetWnd);
  1506.  }
  1507. }
  1508.  
  1509.  
  1510.  
  1511.  
  1512.  
  1513. int mgetmultideselect(VOID)
  1514. {
  1515. int lin, nSortAtEnd = FALSE;
  1516. struct Node *select_current = getlist->lh_Head, *select_next = NULL;
  1517. char sUpperBuffer[MAXFILELINELENGTH], sUpperSearchString[MAXFILELINELENGTH];
  1518.  
  1519. requesttype = DESELECT_REQUESTTYPE;       /* This is a HORRIBLE way to program, but I don't want  */
  1520. lin = mgetfind();                                /* to try to change the parameters since it might screw */
  1521. requesttype = FIND_REQUESTTYPE;            /* up the mget_listview2 functions...                        */
  1522.  
  1523. if (lin == TRUE) 
  1524.  {
  1525.      SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  1526.      GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  1527.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  1528.  
  1529.     if (searchcasesensitive)    
  1530.     {
  1531.         while (select_current != NULL)
  1532.         {
  1533.            if ((nKeepSorted[0] == TRUE)&&(filelist_length > 240))
  1534.             {
  1535.                  nSortAtEnd = TRUE;                        /* remember to sort when done */
  1536.                   nKeepSorted[0] = FALSE;
  1537.             }
  1538.  
  1539.             if ((select_current->ln_Name != NULL)&&
  1540.                 (strstr(select_current->ln_Name,sMultiSelect) != 0))
  1541.             {
  1542.                 select_next = select_current->ln_Succ;
  1543.                 TransferToFiles(select_current);
  1544.                 select_current = select_next;
  1545.             }
  1546.             else
  1547.             {
  1548.                 select_current = select_current->ln_Succ; 
  1549.             }
  1550.         }
  1551.     }
  1552.     else
  1553.     {
  1554.         strncpy(sUpperSearchString,sMultiSelect,sizeof(sUpperSearchString));
  1555.         UpperCase(sUpperSearchString);
  1556.         while (select_current != NULL)
  1557.         {
  1558.            if ((nKeepSorted[0] == TRUE)&&(filelist_length > 240))
  1559.             {
  1560.                  nSortAtEnd = TRUE;                        /* remember to sort when done */
  1561.                   nKeepSorted[0] = FALSE;
  1562.             }
  1563.  
  1564.             if (select_current->ln_Name != NULL)
  1565.             {
  1566.                 strncpy(sUpperBuffer,select_current->ln_Name,sizeof(sUpperBuffer)-1);
  1567.                 UpperCase(sUpperBuffer);
  1568.  
  1569.                 if (strstr(sUpperBuffer,sUpperSearchString) != 0)
  1570.                 {
  1571.                     select_next = select_current->ln_Succ;
  1572.                     TransferToFiles(select_current);
  1573.                     select_current = select_next;
  1574.                 }
  1575.                 else
  1576.                 {
  1577.                     select_current = select_current->ln_Succ; 
  1578.                 }
  1579.             }
  1580.             else
  1581.             {
  1582.                     select_current = select_current->ln_Succ; 
  1583.             }
  1584.         
  1585.         }
  1586.     }
  1587.  
  1588.  if (nSortAtEnd == TRUE)
  1589.  {
  1590.      mgetfileskeep();        /* Sort files now, at the end */
  1591.  }
  1592.  
  1593.  GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  1594.  GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  1595.  
  1596.  ChangeWindowTitle();
  1597.  ClearPointer(mgetWnd);
  1598.  }
  1599. }
  1600.  
  1601.  
  1602.  
  1603.  
  1604.  
  1605. int mgetcase (VOID)
  1606. {
  1607. searchcasesensitive = Not[searchcasesensitive];
  1608. SetMenuValues();
  1609. }
  1610.  
  1611.  
  1612.  
  1613.  
  1614. int mgetCD (VOID)
  1615. {
  1616. simplepaths = Not[simplepaths];
  1617. SetMenuValues();
  1618. }
  1619.  
  1620.  
  1621.  
  1622.  
  1623.  
  1624.  
  1625. int mgetfindtop (VOID)
  1626. {
  1627.     mgetfind_findtype = SEARCHTYPE_TOP;
  1628.     mgetfind();
  1629.     mgetfind_findtype = SEARCHTYPE_FORWARD;
  1630.     return(TRUE);
  1631. }
  1632.  
  1633.  
  1634.  
  1635. int mgetfindbottom (VOID)
  1636. {
  1637.     mgetfind_findtype = SEARCHTYPE_BOTTOM;
  1638.     mgetfind();
  1639.     mgetfind_findtype = SEARCHTYPE_FORWARD;
  1640.     return(TRUE);
  1641. }
  1642.  
  1643.  
  1644. int mgetfindback (VOID)
  1645. {
  1646.     mgetfind_findtype = SEARCHTYPE_BACKWARD;
  1647.     mgetfind();
  1648.     mgetfind_findtype = SEARCHTYPE_FORWARD;
  1649.     return(TRUE);
  1650. }
  1651.  
  1652.  
  1653. int mgetfind (VOID)
  1654. {
  1655. ULONG winsig, signals;
  1656. int done = 0, found = 0, index = -1;
  1657. int fwindowwidth = 450, fwindowheight = 35 + Scr->RastPort.TxHeight;
  1658. int fwindowleft = (mgetLeft + (windowwidth/2) - (fwindowwidth/2));
  1659. int fwindowtop  = (mgetTop  + (windowheight/2)- (fwindowheight/2));
  1660. int WindowHeightLines = nTopListHeight/(listfont.ta_YSize);
  1661. struct NewGadget stringGad;
  1662. struct IntuiMessage *imsg;
  1663. struct Gadget *newgad = NULL;
  1664. char numstring[100], *ss = searchstring, sTempOutString[300];
  1665. char *wp = NULL,windowtitlestring0[] = "Search Window", 
  1666.                 windowtitlestring1[] = "Line Length Window",
  1667.                 windowtitlestring2[] = "Output File Change Window",
  1668.                 windowtitlestring3[] = "Select Multiple Items Window",
  1669.                 windowtitlestring4[] = "Deselect Multiple Items Window";
  1670. FILE *fpTemp = NULL;
  1671.  
  1672. findvi  = GetVisualInfo(Scr, TAG_END);
  1673. if (findvi == NULL) return(0);
  1674. if (findwindow != NULL) return(0);
  1675.  
  1676.  
  1677. if (fwindowleft < 0) fwindowleft = mgetLeft;
  1678. if (fwindowheight < 0) fwindowtop = mgetTop;
  1679.  
  1680.  newgad = CreateContext(&findgadlist);
  1681.  if (newgad == 0)
  1682.     {
  1683.     MakeReq("Couldn't create findwindow gad context!\n",NULL,"Dammit!");
  1684.     return(0);
  1685.     }
  1686.  
  1687.  if (newgad == NULL) return(0);
  1688.  
  1689. stringGad.ng_TextAttr     = &topaz8;    /* Cant figure out how to get system default into a TextAttr!  No name string available! */
  1690. stringGad.ng_VisualInfo  = findvi;
  1691. stringGad.ng_LeftEdge     = 5;
  1692. stringGad.ng_TopEdge        = 18 + Scr->RastPort.TxHeight;
  1693. stringGad.ng_Width         = (fwindowwidth-10);
  1694. stringGad.ng_Height         = 13;
  1695. stringGad.ng_GadgetText  = "Please enter search string.";
  1696. stringGad.ng_GadgetID     = 35;    
  1697. stringGad.ng_Flags         = PLACETEXT_ABOVE;
  1698.  
  1699.  switch (requesttype)
  1700.  {
  1701.      case FIND_REQUESTTYPE:
  1702.         wp = windowtitlestring0;
  1703.    break;
  1704.  
  1705.    case LINELENGTH_REQUESTTYPE:
  1706.          wp = windowtitlestring1;
  1707.          stringGad.ng_GadgetText = "Please enter new maximum line length.";
  1708.          sprintf(numstring,"%i\0",maxoutputlinelength);    
  1709.          ss = numstring;
  1710.    break;
  1711.    
  1712.    case OUTPUTFILE_REQUESTTYPE:
  1713.          wp = windowtitlestring2;
  1714.          stringGad.ng_GadgetText = "Please enter new output file path/device.";
  1715.          sprintf(numstring,"%s",sOutFileName);
  1716.          strncpy(sTempOutString,sOutFileName,sizeof(sTempOutString));
  1717.          ss = sTempOutString;
  1718.    break;
  1719.    
  1720.    case SELECT_REQUESTTYPE:
  1721.        wp = windowtitlestring3;
  1722.        stringGad.ng_GadgetText = "Please enter key string to select files with.";
  1723.        sprintf(numstring,"%s",sMultiSelect);
  1724.          strncpy(sTempOutString,sMultiSelect,sizeof(sTempOutString));
  1725.          ss = sTempOutString;       
  1726.    break;
  1727.    
  1728.    case DESELECT_REQUESTTYPE:
  1729.        wp = windowtitlestring4;
  1730.        stringGad.ng_GadgetText = "Please enter key string to deselect files with.";
  1731.        sprintf(numstring,"%s",sMultiSelect);
  1732.        strncpy(sTempOutString,sMultiSelect,sizeof(sTempOutString));
  1733.        ss = sTempOutString;
  1734.       break;
  1735.  }
  1736.  
  1737.  
  1738.  newgad = CreateGadget(STRING_KIND, newgad, &stringGad, 
  1739.                   GTST_String, ss, 
  1740.                   STRINGA_Justification, GACT_STRINGCENTER, 
  1741.                   GA_Immediate, TRUE,
  1742.                   TAG_END);  
  1743.  
  1744.  if (newgad == NULL) 
  1745.     {
  1746.     FreeGadgets(findgadlist);
  1747.     FreeVisualInfo(findvi);
  1748.     return(0);
  1749.     }
  1750.  
  1751.  if (GadToolsBase->lib_Version == 37)
  1752.     {
  1753.     /* Only do it the "illegal" way under v37.  GA_Immediate in the CreateGadget
  1754.        line, above, won't work under v37 but will on later releases. */
  1755.     newgad->Activation |= GACT_IMMEDIATE; 
  1756.     }    
  1757.  
  1758.  switch (screentype)
  1759.     {
  1760.     case USE_PUBSCREEN:
  1761.         findwindow = OpenWindowTags(NULL,
  1762.                 WA_Left,        fwindowleft,
  1763.                 WA_Top,        fwindowtop,
  1764.                 WA_Width,         fwindowwidth,
  1765.                 WA_Height,    fwindowheight,
  1766.                 WA_PubScreen,    Scr,
  1767.                 WA_PubScreenFallBack, TRUE,
  1768.                 WA_IDCMP,        STRINGIDCMP|IDCMP_CLOSEWINDOW|
  1769.                             IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW,
  1770.                 WA_Flags,        WFLG_DRAGBAR|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  1771.                 WA_Gadgets,    findgadlist,
  1772.                 WA_Title,         wp,
  1773.                 WA_ScreenTitle,    pnamestring,
  1774.                 TAG_DONE );
  1775.         break;
  1776.     case USE_CUSTOMSCREEN:
  1777.         findwindow = OpenWindowTags(NULL,
  1778.                 WA_Left,        fwindowleft,
  1779.                 WA_Top,        fwindowtop,
  1780.                 WA_Width,         fwindowwidth,
  1781.                 WA_Height,    fwindowheight,
  1782.                 WA_CustomScreen, Scr,
  1783.                 WA_IDCMP,        STRINGIDCMP|IDCMP_CLOSEWINDOW|
  1784.                             IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW,
  1785.                 WA_Flags,        WFLG_DRAGBAR|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  1786.                 WA_Gadgets,    findgadlist,
  1787.                 WA_Title,         wp,
  1788.                 WA_ScreenTitle,    pnamestring,
  1789.                 WA_CustomScreen,    Scr,
  1790.                 TAG_DONE );
  1791.         break;
  1792.     case USE_WBSCREEN:
  1793.         findwindow = OpenWindowTags(NULL,
  1794.                 WA_Left,        fwindowleft,
  1795.                 WA_Top,        fwindowtop,
  1796.                 WA_Width,         fwindowwidth,
  1797.                 WA_Height,    fwindowheight,
  1798.                 WA_IDCMP,        STRINGIDCMP|IDCMP_CLOSEWINDOW|
  1799.                             IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW,
  1800.                 WA_Flags,        WFLG_DRAGBAR|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  1801.                 WA_Gadgets,    findgadlist,
  1802.                 WA_Title,         wp,
  1803.                 WA_ScreenTitle,    pnamestring,
  1804.                 TAG_DONE );
  1805.         break;
  1806.     }
  1807.  
  1808. if (findwindow == NULL) return(0);
  1809. GT_RefreshWindow(findwindow, NULL); 
  1810.  
  1811. SetWindowTitles(mgetWnd, "MGet window inactive--close daughter window to continue", (char *) ~0); 
  1812. SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  1813.  
  1814. winsig = 1 << findwindow->UserPort->mp_SigBit;
  1815.  
  1816.  while (!done)
  1817.     {
  1818.     signals = Wait(winsig);
  1819.     if (signals&winsig)
  1820.         {
  1821.         while ((!done) && (imsg = GT_GetIMsg(findwindow->UserPort)))
  1822.             {
  1823.             
  1824.             switch(imsg->Class)
  1825.                 {            
  1826.                 case IDCMP_ACTIVEWINDOW:
  1827.                     ActivateGadget(newgad,findwindow,NULL);
  1828.                     break;
  1829.                         
  1830.                 case IDCMP_GADGETUP:
  1831.                     strncpy(ss,((struct StringInfo*)newgad->SpecialInfo)->Buffer,sizeof(searchstring));
  1832.                     done = 1;
  1833.                     break;
  1834.         
  1835.                 case IDCMP_CLOSEWINDOW:
  1836.                     done = 2;
  1837.                     break;
  1838.                     
  1839.                 case IDCMP_REFRESHWINDOW:
  1840.                     GT_BeginRefresh(findwindow);
  1841.                     GT_EndRefresh(findwindow, TRUE);
  1842.                     break;
  1843.                 }
  1844.             GT_ReplyIMsg(imsg);
  1845.             }
  1846.         }
  1847.     }
  1848.     
  1849. CloseWindow(findwindow);
  1850. FreeGadgets(findgadlist);
  1851. FreeVisualInfo(findvi); 
  1852. findwindow = NULL;
  1853.  
  1854. ClearPointer(mgetWnd);
  1855. ChangeWindowTitle();  /* just in case */
  1856.  
  1857.  if ((requesttype == SELECT_REQUESTTYPE)||(requesttype == DESELECT_REQUESTTYPE))
  1858.  {
  1859.      if (strlen(sTempOutString) == 0) return(FALSE);  /* empty string = abort, don't move any items */
  1860.     strncpy(sMultiSelect,sTempOutString,sizeof(sMultiSelect));
  1861.      ChangeWindowTitle();
  1862.      return(TRUE);
  1863.  }
  1864.  
  1865.  if (requesttype == LINELENGTH_REQUESTTYPE) 
  1866.  {
  1867.         ChangeWindowTitle();    
  1868.         return(atoi(ss));
  1869.  }
  1870.  
  1871.  if (requesttype == OUTPUTFILE_REQUESTTYPE)
  1872.     {
  1873.         if (strlen(sTempOutString) == 0)
  1874.         {
  1875.             if (BStartedFromWB == FALSE)
  1876.             {
  1877.                 fpOut = stdout;
  1878.                 *sOutFileName = '\0';    /* blank out filename string */
  1879.             }
  1880.             else
  1881.             {
  1882.                 strncpy(sTempOutString,"ram:GadMget.output",sizeof(sOutFileName));
  1883.             }
  1884.         }
  1885.         else
  1886.         {
  1887.             fpTemp = fopen(sTempOutString,"w");
  1888.             if (fpTemp == NULL)
  1889.             {
  1890.                 MakeReq("Couldn't open output file!\n",NULL,"Ok");
  1891.             }
  1892.             else
  1893.             {
  1894.                 fpOut = fpTemp;
  1895.                 strncpy(sOutFileName,sTempOutString,sizeof(sOutFileName));
  1896.                 fclose(fpTemp);
  1897.             }
  1898.         }
  1899.     ChangeWindowTitle();
  1900.     return(0);
  1901.     }
  1902.     
  1903.  if ((done == 2)||(strlen(searchstring) == 0))
  1904.     {
  1905.     ChangeWindowTitle();
  1906.     return(0);    /* can use searchstring now instead of ss */
  1907.     }            /* because we're no longer worried about the nums */
  1908.  
  1909. /* Now find it in the filelist */
  1910. index = SearchList(searchstring,mgetfind_findtype);
  1911. if (index == -1) DisplayBeep(Scr); else findgadgoto(index,3);
  1912. return(1);
  1913. }
  1914.  
  1915.  
  1916.  
  1917.  
  1918.  
  1919.  
  1920. int mgetfindnext (VOID)
  1921. {
  1922. int next_index;
  1923.  
  1924. /* bump to next node */
  1925. next_index = SearchList(searchstring,SEARCHTYPE_NEXT);
  1926. if (next_index == -1) DisplayBeep(Scr); else findgadgoto(next_index,2);
  1927.  
  1928. return(TRUE);
  1929. }
  1930.  
  1931.  
  1932.  
  1933. int mgetfindprevious (VOID)
  1934. {
  1935. int prev_index;
  1936.  
  1937. /* bump to previous node */
  1938. prev_index = SearchList(searchstring,SEARCHTYPE_PREVIOUS);
  1939. if (prev_index == -1) DisplayBeep(Scr); else findgadgoto(prev_index,2);
  1940.  
  1941. return(TRUE);
  1942. }
  1943.  
  1944. int mgetfindcurrent (VOID)
  1945. {
  1946. if ((search_index == -1)||(search_current == NULL)) DisplayBeep(Scr); else findgadgoto(search_index,2);
  1947.  
  1948. return(TRUE);
  1949. }
  1950.  
  1951.  
  1952. int mgetfilesbydir (void)
  1953. {
  1954. nSortType[0] = SORTBYDIR;
  1955.  
  1956. SortList(filelist,nSortType[0]);
  1957. }
  1958.  
  1959.  
  1960. int mgetfilesbysize (void)
  1961. {
  1962. nSortType[0] = SORTBYSIZE;
  1963.  
  1964. SortList(filelist,nSortType[0]);
  1965. }
  1966.  
  1967.  
  1968. int mgetfilesbyname (void)
  1969. {
  1970. nSortType[0] = SORTBYNAME;
  1971.  
  1972. SortList(filelist,nSortType[0]);
  1973. }
  1974.  
  1975.  
  1976. int mgetfilesbydesc (void)
  1977. {
  1978. nSortType[0] = SORTBYDESC;
  1979.  
  1980. SortList(filelist,nSortType[0]);
  1981. }
  1982.  
  1983. int mgetfilesbyage (void)
  1984. {
  1985. nSortType[0] = SORTBYAGE;
  1986.  
  1987. SortList(filelist,nSortType[0]);
  1988. }
  1989.  
  1990.  
  1991. int mgetfileskeep (void)
  1992. {
  1993. if (nKeepSorted[0] == 1) 
  1994.     {
  1995.         nKeepSorted[0] = 0;
  1996.     }
  1997.     else
  1998.     {
  1999.         nKeepSorted[0] = 1;
  2000.         SortList(filelist,nSortType[0]);
  2001.     }
  2002. SetMenuValues();
  2003. }
  2004.  
  2005.  
  2006. int mgetgetbydir (void)
  2007. {
  2008. nSortType[1] = SORTBYDIR;
  2009.  
  2010. SortList(getlist,nSortType[1]);
  2011. }
  2012.  
  2013.  
  2014. int mgetgetbysize (void)
  2015. {
  2016. nSortType[1] = SORTBYSIZE;
  2017.  
  2018. SortList(getlist,nSortType[1]);
  2019. }
  2020.  
  2021.  
  2022. int mgetgetbyname (void)
  2023. {
  2024. nSortType[1] = SORTBYNAME;
  2025.  
  2026. SortList(getlist,nSortType[1]);
  2027. }
  2028.  
  2029.  
  2030. int mgetgetbydesc (void)
  2031. {
  2032. nSortType[1] = SORTBYDESC;
  2033.  
  2034. SortList(getlist,nSortType[1]);
  2035. }
  2036.  
  2037.  
  2038. int mgetgetbyage (void)
  2039. {
  2040. nSortType[1] = SORTBYAGE;
  2041.  
  2042. SortList(getlist,nSortType[1]);
  2043. }
  2044.  
  2045.  
  2046. int mgetgetkeep (void)
  2047. {
  2048. if (nKeepSorted[1] == TRUE) 
  2049.     {
  2050.         nKeepSorted[1] = FALSE;
  2051.     }
  2052.     else
  2053.     {
  2054.         nKeepSorted[1] = TRUE;
  2055.         SortList(getlist,nSortType[1]);
  2056.     }
  2057. SetMenuValues();
  2058. }
  2059.  
  2060.  
  2061.  
  2062.  
  2063.  
  2064. int SearchList(char *key, int nSearchType)
  2065. {
  2066. int found = 0, nTemp = 0, nSearchDir = SEARCH_FORWARD;
  2067. char sUpperBuffer[MAXFILELINELENGTH], sUpperSearchString[MAXFILELINELENGTH];
  2068.  
  2069. filelist->lh_Head->ln_Pred = NULL;    /* This should always be NULL, but is
  2070.                                                     sometimes set to a random value, causing
  2071.                                                     Enforcer hits whenever we traverse
  2072.                                                     Backwards.  So, we make sure.  */
  2073.  
  2074. /* keep a separate temporary search_* in case we fail */
  2075. int temp_search_index;
  2076. struct Node *temp_search_current;
  2077.  
  2078. SetWindowTitles(mgetWnd, "Searching...", (char *) ~0); 
  2079. SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  2080.  
  2081.  /* make sure search_current at least is *something* !! */
  2082.  if (search_current == NULL)
  2083.  {
  2084.     search_current = ListViewTopNode((struct Gadget *) mgetGadgets[0], filelist);
  2085.     search_index = ListViewTop((struct Gadget *) mgetGadgets[0], filelist);
  2086.  }
  2087.  
  2088. /* temporary copy */
  2089. temp_search_current = search_current;
  2090. temp_search_index = search_index;
  2091.     
  2092. /* Start at current top of display */
  2093. switch (nSearchType)
  2094. {
  2095.     case SEARCHTYPE_FORWARD:
  2096.         temp_search_current = ListViewTopNode((struct Gadget *) mgetGadgets[0], filelist);
  2097.         temp_search_index = ListViewTop((struct Gadget *) mgetGadgets[0], filelist);
  2098.         break;
  2099.  
  2100.     case SEARCHTYPE_BACKWARD:
  2101.         temp_search_current = ListViewTopNode((struct Gadget *) mgetGadgets[0], filelist);
  2102.         temp_search_index = ListViewTop((struct Gadget *) mgetGadgets[0], filelist);
  2103.         nSearchDir = SEARCH_BACKWARD;
  2104.         break;
  2105.         
  2106.     case SEARCHTYPE_NEXT:
  2107.         temp_search_current = temp_search_current->ln_Succ;
  2108.         temp_search_index++;
  2109.         break;
  2110.     
  2111.     case SEARCHTYPE_PREVIOUS:
  2112.         temp_search_current = temp_search_current->ln_Pred;
  2113.         temp_search_index--;
  2114.         nSearchDir = SEARCH_BACKWARD;
  2115.         break;
  2116.         
  2117.     case SEARCHTYPE_TOP:
  2118.         temp_search_current = filelist->lh_Head;
  2119.         temp_search_index = 0;
  2120.         break;
  2121.         
  2122.     case SEARCHTYPE_BOTTOM:
  2123.         temp_search_current = TailOf(filelist, &temp_search_index);
  2124.         nSearchDir = SEARCH_BACKWARD;
  2125.         break;        
  2126. }        
  2127.             
  2128.  
  2129. if (searchcasesensitive)    
  2130.     {
  2131.     while ((temp_search_current != NULL)&&(found == 0))
  2132.         {
  2133.         if ((temp_search_current->ln_Name != NULL)&&(strstr(temp_search_current->ln_Name,searchstring) != 0))
  2134.             found = 1;
  2135.             else
  2136.             {
  2137.                 if (nSearchDir == SEARCH_FORWARD)
  2138.                 {
  2139.                     temp_search_current = temp_search_current->ln_Succ; 
  2140.                     temp_search_index++;
  2141.                 }
  2142.                 else
  2143.                 {
  2144.                     temp_search_current = temp_search_current->ln_Pred; 
  2145.                     temp_search_index--;
  2146.                 }
  2147.             }
  2148.         }
  2149.     }
  2150.     else
  2151.     {
  2152.     strncpy(sUpperSearchString,key,sizeof(sUpperSearchString));
  2153.     UpperCase(sUpperSearchString);
  2154.     while ((temp_search_current != NULL)&&(found == 0))
  2155.         {
  2156.         if (temp_search_current->ln_Name != NULL)
  2157.             {
  2158.             strncpy(sUpperBuffer,temp_search_current->ln_Name,sizeof(sUpperBuffer)-1);
  2159.             UpperCase(sUpperBuffer);
  2160.             if (strstr(sUpperBuffer,sUpperSearchString) != 0)
  2161.                 found = 1;
  2162.             }
  2163.         if (found == 0)
  2164.             {
  2165.              if (nSearchDir == SEARCH_FORWARD)
  2166.                 {
  2167.                     temp_search_current = temp_search_current->ln_Succ; 
  2168.                     temp_search_index++;
  2169.                 }
  2170.                 else
  2171.                 {
  2172.                     temp_search_current = temp_search_current->ln_Pred; 
  2173.                     temp_search_index--;
  2174.                 }
  2175.             }
  2176.         }
  2177.     }
  2178.     
  2179. ChangeWindowTitle();
  2180. ClearPointer(mgetWnd);
  2181.  
  2182. if (found == 1) 
  2183. {    
  2184.     search_current = temp_search_current;        /* cast the temp copy in stone */
  2185.     search_index = temp_search_index;
  2186.     return(search_index); 
  2187. }
  2188. else 
  2189. {
  2190.     return(-1);
  2191. }
  2192.  
  2193. }
  2194.  
  2195.  
  2196.  
  2197.  
  2198.  
  2199.  
  2200.  
  2201.  
  2202.  
  2203.  
  2204.  
  2205. void findgadgoto (int index, int numberofflashes)
  2206. {
  2207. int i, xmin, ymin, xmax, ymax, ystep, midscreen;
  2208. int WindowHeightLines = nTopListHeight/(listfont.ta_YSize);
  2209. LONG yTop = 0;
  2210.  
  2211.  midscreen = index-(WindowHeightLines/2);
  2212.  if (midscreen < 0) midscreen = 0;
  2213.  
  2214.  GT_SetGadgetAttrs((struct Gadget *) mgetGadgets[0], mgetWnd, NULL, GTLV_Top, midscreen, TAG_END);
  2215.  yTop = ListViewTop((struct Gadget *) mgetGadgets[0], mgetWnd);
  2216.  ystep = index - yTop;
  2217.   
  2218.  xmin = Scr->WBorLeft + 4;
  2219.  ymin = (nTopListTop + ((listfont.ta_YSize) *ystep) + 2);
  2220.  xmax = windowwidth - Scr->WBorLeft - 20;
  2221.  ymax = ymin + (listfont.ta_YSize) - 1;
  2222.  
  2223.  SetDrMd(mgetWnd->RPort, 50); 
  2224.  for (i=0;i<numberofflashes;i++)
  2225.      {
  2226.      RectFill(mgetWnd->RPort,xmin,ymin,xmax,ymax);
  2227.      Delay(5);
  2228.      RectFill(mgetWnd->RPort,xmin,ymin,xmax,ymax);
  2229.      if (i<(numberofflashes-1)) Delay(5);
  2230.      }
  2231. }
  2232.  
  2233.  
  2234.  
  2235.  
  2236.  
  2237. int ClearList(struct List *thislist)
  2238. {
  2239.     struct Node *current = thislist->lh_Head;
  2240.     struct Node *nextnode;
  2241.     const int nodesize = sizeof(struct Node);
  2242.  
  2243.     if (thislist == NULL) return(FALSE);
  2244.         
  2245.     while (current != NULL)
  2246.     {
  2247.         nextnode = current->ln_Succ;
  2248.         if (current->ln_Succ != NULL) 
  2249.         {
  2250.             Remove(current);
  2251.             if (current->ln_Name != NULL)
  2252.             {
  2253.                 FreeMem(current->ln_Name,current->ln_Pri+127);
  2254.                 added_bytes -= current->ln_Pri+127;
  2255.             }        
  2256.             FreeMem(current,nodesize);        added_bytes -= nodesize;
  2257.         }
  2258.         current = nextnode;
  2259.     }
  2260.     return(TRUE);
  2261. }
  2262.  
  2263.  
  2264.  
  2265.  
  2266.  
  2267.  
  2268. int mgetclearfiles (void)
  2269. {
  2270.     /* prepare gadget for deletion */
  2271.     SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  2272.     GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  2273.  
  2274.     /* delete files list */
  2275.     ClearList(filelist);
  2276.     
  2277.     /* update window */
  2278.    GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  2279.    ChangeWindowTitle();
  2280.    ClearPointer(mgetWnd);    
  2281. }
  2282.  
  2283.  
  2284.  
  2285. int mgetclearget (void)
  2286. {
  2287.     /* prepare gadget for deletion */
  2288.     SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  2289.     GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  2290.  
  2291.     /* delete get list */
  2292.     ClearList(getlist);
  2293.  
  2294.     files_selected = 0;
  2295.     kbytes_selected = 0;
  2296.         
  2297.     /* update window */
  2298.    GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);
  2299.    ChangeWindowTitle();
  2300.    ClearPointer(mgetWnd);    
  2301. }
  2302.  
  2303.  
  2304.  
  2305.  
  2306.  
  2307.  
  2308.  
  2309. int mgetnoparse (void)
  2310. {
  2311. if (noparse) 
  2312.     {
  2313.     noparse = 0; 
  2314.     if (nKeepSorted[0] == 1) SortList(filelist,nSortType[0]);
  2315.     if (nKeepSorted[1] == 1) SortList(getlist, nSortType[1]);
  2316.     SetMenuValues();
  2317.     }
  2318.     else 
  2319.     {
  2320.     noparse = 1;        
  2321.     SetMenuValues();
  2322.     }
  2323. }
  2324.  
  2325.  
  2326.  
  2327.  
  2328.  
  2329.  
  2330.  
  2331.  
  2332. int mgetfiles (void)
  2333. {
  2334. if (filesflag) 
  2335.     {
  2336.     filesflag = 0;
  2337.     getreadmes = 1;
  2338.     SetMenuValues();     
  2339.     }
  2340.     else 
  2341.     filesflag = 1;
  2342. }
  2343.  
  2344.  
  2345.  
  2346.  
  2347.  
  2348.  
  2349.  
  2350. int mgetreadmes (void)
  2351. {
  2352. if (getreadmes) 
  2353.     {getreadmes = 0; 
  2354.      filesflag = 1;
  2355.      SetMenuValues();
  2356.     }
  2357.     else 
  2358.     getreadmes = 1;
  2359. }
  2360.  
  2361.  
  2362.  
  2363.  
  2364.  
  2365.  
  2366. int mgetsplit (void)
  2367. {
  2368. if (nosplit) nosplit = 0; else nosplit = 1;
  2369. SetMenuValues();    
  2370. }
  2371.  
  2372.  
  2373.  
  2374.  
  2375.  
  2376.  
  2377. int mgetlinelength (void)
  2378. {
  2379. int lin;
  2380.  
  2381. requesttype = LINELENGTH_REQUESTTYPE;    /* This is a HORRIBLE way to program, but I don't want  */
  2382. lin = mgetfind();                                /* to try to change the parameters since it might screw */
  2383. requesttype = FIND_REQUESTTYPE;            /* up the mget_listview2 functions...                 */
  2384.  
  2385. if (lin >  0) maxoutputlinelength = lin;
  2386. }
  2387.  
  2388.  
  2389.  
  2390.  
  2391. int mgetoutputfile (void)
  2392. {
  2393. int lin;
  2394.  
  2395. requesttype = OUTPUTFILE_REQUESTTYPE;    /* This is a HORRIBLE way to program, but I don't want  */
  2396. lin = mgetfind();                                /* to try to change the parameters since it might screw */
  2397. requesttype = FIND_REQUESTTYPE;            /* up the mget_listview2 functions...                        */
  2398.  
  2399. }
  2400.  
  2401.  
  2402.  
  2403.  
  2404.  
  2405.  
  2406. void PrintList(struct List *thislist)
  2407. {
  2408. struct Node *nodecurrent = thislist->lh_Head;
  2409.  
  2410. fprintf(fpOut,"thislist = %p\n",thislist);
  2411.  
  2412.  while (nodecurrent != NULL)
  2413.  {
  2414.     if (nodecurrent->ln_Name == NULL) 
  2415.         fprintf(fpOut,"[ <NULL> ]\n"); 
  2416.     else 
  2417.         fprintf(fpOut,"[%s]\n",nodecurrent->ln_Name);
  2418.  
  2419.     nodecurrent = nodecurrent->ln_Succ;
  2420.  }
  2421.     
  2422. return();
  2423. }
  2424.  
  2425.  
  2426.  
  2427.  
  2428.  
  2429.  
  2430.  
  2431.  
  2432. int mgetopenfile (void)
  2433. {
  2434. FILE *test = NULL;
  2435.  
  2436.  memset(inputfile,NUL,sizeof(inputfile));
  2437.  
  2438.  SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  2439.  
  2440.  while (test == NULL) 
  2441.     {
  2442.     if (RequestAFile(inputfile) == 0) 
  2443.         {
  2444.         ClearPointer(mgetWnd);
  2445.         return(0);
  2446.         }
  2447.     test = fopen(inputfile,"r");
  2448.     }
  2449.  
  2450.  fclose(test);
  2451.  SetReqDefaults(inputfile);
  2452.  
  2453.  GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  2454.  FreeFileNodes(filelist); 
  2455.  FreeMem(filelist,sizeof(struct List));
  2456.  added_bytes -= sizeof(struct List);
  2457.  ClearPointer(mgetWnd);
  2458.  
  2459.  if (!(filelist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  2460.     {
  2461.     MakeReq("mgetOpen : Couldn't create filelist!  Out of memory?\n",NULL,"Uh-oh");
  2462.     return(0);
  2463.     }
  2464.  added_bytes += sizeof(struct List);
  2465.         
  2466.  /* These are all dependant on a given filelist, so RESET! */
  2467.  filelist_length = 0;
  2468.  search_current = NULL;
  2469.  search_index = 0;
  2470.  
  2471.  NewList(filelist);      
  2472.  ReadmyFile();
  2473.  if ((nKeepSorted[0] == 1)&&(!noparse)) SortList(filelist,nSortType[0]);  /* keep sorted if that is selected! */
  2474.  GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  2475.  search_current = NULL;
  2476.  search_index = 0;
  2477.  ChangeWindowTitle();
  2478. return(1);
  2479. }
  2480.  
  2481.  
  2482.  
  2483.  
  2484.  
  2485.  
  2486.  
  2487.  
  2488. int mgetappend(void)
  2489. {
  2490. int returnme = 0;
  2491.  
  2492. /* memset(inputfile,NUL,sizeof(inputfile)); */
  2493.  
  2494. GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  2495. returnme = ReadmyFile();
  2496. ChangeWindowTitle();
  2497. if ((nKeepSorted[0] == 1)&&(!noparse)) SortList(filelist,nSortType[0]);  /* keep sorted if that is selected! */
  2498. GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  2499. return(returnme);
  2500. }
  2501.  
  2502.  
  2503.  
  2504.  
  2505.  
  2506.  
  2507. int mgetCloseWindow (void)
  2508. {
  2509. done=TRUE;
  2510. }
  2511.  
  2512.  
  2513.  
  2514.  
  2515.  
  2516.  
  2517.  
  2518.  
  2519.  
  2520. void SetMenuValues (void)
  2521. {
  2522. struct Menu *currentMenu = mgetMenus;
  2523. struct MenuItem *currentItem, *currentSub;
  2524.  
  2525.  if (currentMenu == NULL)
  2526.     {
  2527.     MakeReq("SetMenuValues:  error, mgetMenus is NULL!",NULL,"Huh?");
  2528.     return;
  2529.     }
  2530.     
  2531.  if (mgetWnd != NULL) ClearMenuStrip(mgetWnd);
  2532.  
  2533.  /* Make sure the CaseSensitive item in the second menu is checked correctly. */    
  2534.  currentMenu = currentMenu->NextMenu;     /* Search Menu */
  2535.  currentItem = currentMenu->FirstItem;        /* #1 : Find Forward */
  2536.  currentItem = currentItem->NextItem;        /* #2 : Find Backward*/
  2537.  currentItem = currentItem->NextItem;        /* #3 : Find from Top */
  2538.  currentItem = currentItem->NextItem;        /* #4 : Find from Bottom */
  2539.  currentItem = currentItem->NextItem;        /* #5 : Find Next */
  2540.  currentItem = currentItem->NextItem;        /* #5 : Find Previous */
  2541.  currentItem = currentItem->NextItem;     /* #6 : Find Current */
  2542.  currentItem = currentItem->NextItem;     /* #6 : Select */
  2543.  currentItem = currentItem->NextItem;     /* #6 : Deselect */
  2544.  currentItem = currentItem->NextItem;        /* #6 : Case Sensitive. */
  2545.  
  2546.  if (searchcasesensitive)  currentItem->Flags |= CHECKED; 
  2547.             else  currentItem->Flags &= ~(CHECKED);    
  2548.  
  2549.  /* next we do the Sort menu. */
  2550.  currentMenu = currentMenu->NextMenu;
  2551.  if (noparse) currentMenu->Flags &= ~(MENUENABLED);
  2552.        else currentMenu->Flags |= MENUENABLED;
  2553.  
  2554.  currentItem = currentMenu->FirstItem;    /* #1: Files List */
  2555.  currentSub = currentItem->SubItem;    /* #1.1 : By Directory */
  2556.  
  2557.  currentSub = currentSub->NextItem;    /* #1.2 : By Size */
  2558.  
  2559.  currentSub = currentSub->NextItem;    /* #1.3 : By FileName */
  2560.  currentSub = currentSub->NextItem;    /* #1.4 : By Description */
  2561.  currentSub = currentSub->NextItem;       /* #1.5 : By Age */
  2562.  currentSub = currentSub->NextItem;       /* #1.6 : Keep Sorted */
  2563.  if (nKeepSorted[0] == 0) currentSub->Flags &= ~(CHECKED);
  2564.                            else currentSub->Flags |= CHECKED;
  2565.  
  2566.  currentItem = currentItem->NextItem;    /* #2: Get List */
  2567.  currentSub = currentItem->SubItem;    /* #2.1 : By Directory */
  2568.  currentSub = currentSub->NextItem;    /* #2.2 : By Size */
  2569.  currentSub = currentSub->NextItem;    /* #2.3 : By FileName */
  2570.  currentSub = currentSub->NextItem;    /* #2.4 : By Description */
  2571.  currentSub = currentSub->NextItem;       /* #2.5 : By Age */
  2572.  currentSub = currentSub->NextItem;        /* #2.6 : Keep Sorted */
  2573.  if (nKeepSorted[1] == 0) currentSub->Flags &= ~(CHECKED);
  2574.                            else currentSub->Flags |= CHECKED;
  2575.  
  2576.                                       
  2577.  currentItem = currentItem->NextItem;    /* #3: Sort Type */
  2578.  currentSub = currentItem->SubItem;    /* #3.1: Tree Sort */
  2579.  if (nSortAlgorithm == TREESORT) currentSub->Flags |= CHECKED;
  2580.                                      else currentSub->Flags &= ~(CHECKED);
  2581.  currentSub = currentSub->NextItem;        /* #3.2: Bubble Sort */
  2582.  if (nSortAlgorithm == BUBBLESORT)   currentSub->Flags |= CHECKED;
  2583.                                           else currentSub->Flags &= ~(CHECKED);
  2584.  
  2585.  currentItem = currentItem->NextItem;    /* #4: Case Sensitive */
  2586.  if (sortcasesensitive == FALSE) currentItem->Flags &= ~(CHECKED);
  2587.                                       else currentItem->Flags |= (CHECKED);
  2588.                                         
  2589.                           
  2590.  /* Output menu. */
  2591.  currentMenu = currentMenu->NextMenu;
  2592.  
  2593.  currentItem = currentMenu->FirstItem;        /* #1: Aminet Parse */
  2594.  
  2595.  if (noparse) currentItem->Flags &= ~(CHECKED);
  2596.        else currentItem->Flags |= CHECKED;
  2597.        
  2598.        
  2599.  currentItem = currentItem->NextItem;        /* #2: Get Files */
  2600.  
  2601.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2602.        else currentItem->Flags |= ITEMENABLED;
  2603.  if (filesflag) currentItem->Flags |= CHECKED;
  2604.           else currentItem->Flags &= ~(CHECKED);
  2605.           
  2606.  currentItem = currentItem->NextItem;        /* #3: Get Readmes */
  2607.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2608.        else currentItem->Flags |= ITEMENABLED;
  2609.  if (getreadmes) currentItem->Flags |= CHECKED;
  2610.            else currentItem->Flags &= ~(CHECKED);
  2611.     
  2612.  currentItem = currentItem->NextItem;        /* #4: Split Commands */
  2613.  
  2614.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2615.        else currentItem->Flags |= ITEMENABLED;
  2616.  if (nosplit) currentItem->Flags &= ~(CHECKED);
  2617.            else currentItem->Flags |= CHECKED;
  2618.            
  2619.  
  2620.  currentItem = currentItem->NextItem;        /* #5: Use CD's */
  2621.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2622.        else currentItem->Flags |= ITEMENABLED;
  2623.  if (simplepaths) currentItem->Flags |= CHECKED;
  2624.            else currentItem->Flags &= ~(CHECKED);
  2625.            
  2626.  currentItem = currentItem->NextItem;        /* #6: Line length */
  2627.  if ((noparse)||(nosplit)) currentItem->Flags &= ~(ITEMENABLED);
  2628.        else currentItem->Flags |= ITEMENABLED;
  2629.  
  2630.  ResetMenuStrip( mgetWnd, mgetMenus );                 
  2631. }
  2632.  
  2633.  
  2634.  
  2635.  
  2636.  
  2637.  
  2638. /* Turns all \n's in input string into <space><newline>'s */
  2639. void FindReturns(char *mystring)
  2640. {
  2641. char *thischar=mystring, *prevchar=mystring;
  2642.  
  2643.  while (*thischar != NULL)
  2644.     {
  2645.     
  2646.     if ( (*prevchar  ==   92) &&                        /* any '/'s ? */
  2647.          ((*thischar ==   78)||(*thischar == 110)) &&      /* N's or n's */
  2648.          (prevchar   !=  NULL) &&                        /* Sanity chk */
  2649.          (thischar   !=  NULL))
  2650.         
  2651.         {
  2652.         *prevchar = ' ';   /* set this to a space--easier than shortening string */
  2653.         *thischar = 10;   /* and end this line with a newline char */
  2654.         }
  2655.     
  2656.     prevchar = thischar;
  2657.     thischar++;
  2658.     }
  2659. }
  2660.  
  2661.  
  2662.  
  2663.  
  2664.  
  2665.  
  2666.  
  2667.  
  2668.  
  2669. int AddFile(struct List *mylist, char *newstring)
  2670. {
  2671. struct Node *newnode;
  2672. char *newname, *i;
  2673. const char newlinechar = 10, spacechar = ' ';
  2674. UBYTE diff = MAXFILELINELENGTH;
  2675. const int minlinelength = 1;
  2676. int nStringLength;
  2677.  
  2678.  if (keepblanklines == 1) minlinelength = 0;
  2679.  if (newstring == NULL) return(0);
  2680.   
  2681.  /* remove nasty end-of-line carriage returns */
  2682.  nStringLength = strlen(newstring);
  2683.  if (newstring[nStringLength - 2] == '\r') 
  2684.  {
  2685.           newstring[nStringLength - 2] = ' ';
  2686.           nStringLength -= 2;
  2687.  }
  2688.  if (nStringLength < minlinelength) return(0); 
  2689.  
  2690.  if (!( newnode = AllocMem(sizeof(struct Node),MEMF_CLEAR) ))
  2691.     {
  2692.         /* emergency bailout! */
  2693.        FreeFileNodes(filelist); 
  2694.        filelist = NULL;
  2695.         FreeMem(filelist,sizeof(struct List));
  2696.         added_bytes -= sizeof(struct List);
  2697.         MakeReq("AddFile:  Aborting due to lack of memory",NULL,"Add 4 megs and retry");
  2698.         CleanUp();
  2699.         exit(20);
  2700.     }
  2701.  added_bytes += sizeof(struct Node);
  2702.     
  2703.  i = strchr(newstring, (char) newlinechar);
  2704.  if (i != NULL) diff = i-newstring;  /* number of chars into the string where newline is! */
  2705.  
  2706.  if (!( newname = AllocMem(diff+1,MEMF_CLEAR) ))
  2707.     {
  2708.         /* emergency bailout! */
  2709.         FreeMem(newnode,sizeof(struct Node));    /* get rid of that last Node */
  2710.        FreeFileNodes(filelist); 
  2711.        filelist = NULL;
  2712.         FreeMem(filelist,sizeof(struct List));
  2713.         added_bytes -= sizeof(struct List);
  2714.         MakeReq("AddFile:  Aborting due to lack of memory",NULL,"Add 4 megs and retry");
  2715.         CleanUp();
  2716.         exit(20);
  2717.     }
  2718.   added_bytes += diff+1;
  2719.     
  2720. strncpy(newname,newstring,diff);   /* copy over the bytes */
  2721.  
  2722. newnode->ln_Pri = diff - 126;        /* store string length in unused field */
  2723. newnode->ln_Name=newname;          /* and set ze pointer! */
  2724.  
  2725. AddTail(mylist, newnode);
  2726. return(1);
  2727. }
  2728.  
  2729.  
  2730.  
  2731. /* Prints out a file.  Makes sure there is a sEndOfLineString after the end of every line */
  2732. int PrintFile(char *szFileName, int PrintReturnFirst)
  2733. {
  2734.     FILE *input_file = fopen(szFileName,"r");
  2735.     char inputline[MAXFILELINELENGTH], *a, *b;
  2736.     int nLen;
  2737.  
  2738.      if (input_file == NULL) 
  2739.      {
  2740.         return(0);
  2741.      }
  2742.  
  2743.      if (PrintReturnFirst == 1)
  2744.      {
  2745.          fprintf(fpOut,sEndOfLineString);
  2746.          
  2747.      }
  2748.          
  2749.     /* Read until we get a line-end */
  2750.     while(!feof(input_file))
  2751.     {
  2752.         memset(inputline,NUL,MAXFILELINELENGTH);
  2753.         fgets(inputline,MAXFILELINELENGTH,input_file);  /* Read up to MAXFILELINELENGTH chars from inputfile */
  2754.         
  2755.         nLen = strlen(inputline);
  2756.         
  2757.         if (nLen >= 2)
  2758.         {
  2759.             /* make sure that it ends in a sEndOfLineString */
  2760.             a = &inputline[strlen(inputline)-2];
  2761.             b = &inputline[strlen(inputline)-1];
  2762.             
  2763.             if ((*a == '\r')&&(*b == '\n')) /* the easy case */
  2764.             {
  2765.                 fprintf(fpOut,"%s",inputline);
  2766.             }
  2767.             else
  2768.             {
  2769.                 if ((*a != '\r')&&(*b == '\n'))  /* the normal case, for Amigas */
  2770.                 {
  2771.                 /* make the newline a return, and then append a newline */
  2772.                     *b = '\r';
  2773.                     fprintf(fpOut,"%s\n",inputline);
  2774.                 }
  2775.                 else
  2776.                 {
  2777.                 if ((*a == '\r')&&(*b != '\n'))    /* the abnormal case */
  2778.                     {
  2779.                         *b = '\n';
  2780.                         fprintf(fpOut,"%s",inputline);
  2781.                     }
  2782.                     else
  2783.                     {
  2784.                         /* *a != \r, *b != \n */
  2785.                         fprintf(fpOut,"%s%s",inputline,sEndOfLineString);
  2786.                     }
  2787.                 }
  2788.             }
  2789.         }
  2790.         else
  2791.         if (nLen == 1) fprintf(fpOut,sEndOfLineString);
  2792.     }    
  2793.     fclose(input_file);
  2794.     return(1);
  2795. }
  2796.  
  2797.  
  2798.  
  2799. /* returns the number of lines successfully parsed and added to the list */
  2800. int ReadmyFile(void)
  2801. {
  2802. FILE *input_file = NULL;
  2803. char inputline[MAXFILELINELENGTH];
  2804. char *firstnull;
  2805. int nullpos = 0, okline = 0, nUpdate = 50;
  2806. int filelength = 0, failed_lines = 0;
  2807. int minlinelength = 1;
  2808.  
  2809. if (keepblanklines == 1) minlinelength = 0;
  2810.  
  2811. SetPointer(mgetWnd, waitPointer, 16, 16, -6, 0);
  2812.  
  2813.  while (input_file == NULL) 
  2814.     {
  2815.     input_file = fopen(inputfile,"r");
  2816.     if ((input_file == NULL)&&(RequestAFile(inputfile) == 0)) 
  2817.         {
  2818.         ClearPointer(mgetWnd);
  2819.         return(0);
  2820.         }
  2821.     }
  2822.     
  2823.  SetReqDefaults(inputfile);
  2824.  
  2825.  while (!feof(input_file))
  2826.     {
  2827.     filelength++;        
  2828.     okline=0;  
  2829.     /* Read until we get a line-end */
  2830.     while((okline==0)&&(!feof(input_file)))
  2831.         {
  2832.         memset(inputline,NUL,MAXFILELINELENGTH);
  2833.         fgets(inputline,MAXFILELINELENGTH,input_file);  /* Read up to MAXFILELINELENGTH chars from inputfile */
  2834.         firstnull = strchr(inputline,(char) 10); /* Find address of carriage return */
  2835.         nullpos = firstnull - inputline;           /* Subtract to get return pos */
  2836.         if ((nullpos >= minlinelength)&&(nullpos < MAXFILELINELENGTH)) okline=1;
  2837.         }
  2838.     
  2839.     if ((nullpos < MAXFILELINELENGTH)||(noparse))
  2840.           {
  2841.               if (AddFile(filelist, inputline) == TRUE)
  2842.               {
  2843.                   filelist_length++;
  2844.  
  2845.                     if (nUpdate == 0)
  2846.                     {
  2847.                         sprintf(windowtitle,"Loading: %i",filelist_length);   
  2848.                         SetWindowTitles(mgetWnd, windowtitle , (char *) ~0);                   
  2849.                         nUpdate = 50;
  2850.                     }
  2851.                     else
  2852.                     {
  2853.                         nUpdate--;
  2854.                     }
  2855.                  }
  2856.               else
  2857.               {
  2858.                   failed_lines++;
  2859.               }
  2860.           }
  2861.           else
  2862.           {
  2863.               failed_lines++;
  2864.           }
  2865.               
  2866.     }
  2867.  
  2868. fclose(input_file);
  2869. ClearPointer(mgetWnd);    
  2870. return(filelist_length);
  2871. }
  2872.  
  2873.  
  2874.  
  2875.  
  2876.  
  2877.  
  2878.  
  2879.  
  2880.  
  2881.  
  2882.  
  2883.  
  2884. VOID FreeFileNodes(struct List *mylist)
  2885. {
  2886. struct Node *nextnode,*worknode = mylist->lh_Head;  
  2887. const int nodesize = sizeof(struct Node);
  2888.  
  2889.  while (nextnode = (worknode->ln_Succ))
  2890.     {
  2891.     if (worknode->ln_Name != NULL)
  2892.         {
  2893.         FreeMem(worknode->ln_Name,worknode->ln_Pri+127);
  2894.         added_bytes -= worknode->ln_Pri+127;
  2895.         }        
  2896.     FreeMem(worknode,nodesize);
  2897.     worknode = nextnode;
  2898.     added_bytes -= nodesize;
  2899.     }
  2900. }
  2901.  
  2902.  
  2903.  
  2904.  
  2905.  
  2906.  
  2907.  
  2908.  
  2909.  
  2910.  
  2911.  
  2912. void ChangeWindowTitle(void)
  2913. {
  2914.     char *fstring = inputfile, *f2;
  2915.     char sSubString[60];
  2916.     int charlength = (windowwidth-81)/8 - 40;
  2917.  
  2918.     if (charlength <= 0) 
  2919.     {
  2920.         fstring = sSubString;
  2921.         fstring[0] = NUL;
  2922.     }
  2923.     else
  2924.     if (strlen(fstring) > charlength)
  2925.     {
  2926.         f2 = inputfile + strlen(inputfile) - charlength - 1;    
  2927.         if (f2 > inputfile)
  2928.         {
  2929.             fstring = sSubString;
  2930.             strcpy(fstring,f2);
  2931.         }
  2932.     }    
  2933.     sprintf(windowtitle,"(%s) %i files, %u kilobytes selected.",fstring, files_selected, kbytes_selected);   
  2934.     SetWindowTitles(mgetWnd, windowtitle , (char *) ~0); 
  2935.     return();
  2936. }
  2937.  
  2938.  
  2939.  
  2940.  
  2941.  
  2942.  
  2943.  
  2944.  
  2945.  
  2946. VOID UpdateByteCount(char *mystring, int addorsub)
  2947. {
  2948. kbytes_selected = kbytes_selected + (AminetFileSize(mystring) * addorsub);
  2949. return();
  2950. }
  2951.  
  2952.  
  2953.  
  2954.  
  2955.  
  2956.  
  2957.  
  2958.  
  2959.  
  2960.  
  2961.  
  2962. VOID CleanUp(void)
  2963. {
  2964.  
  2965. if ((fpOut != stdout)&&(fpOut != NULL)) fclose(fpOut);
  2966.  
  2967. if (listfontdata)  CloseFont(listfontdata);
  2968. if (windowisopen)  {ClosemgetWindow();  windowisopen = FALSE; mgetWnd = NULL;}
  2969. if (screenisopen)  {CloseDownScreen();  screenisopen = FALSE; Scr = NULL;}
  2970. if (filelist)        
  2971.                 {
  2972.                 FreeFileNodes(filelist); 
  2973.                 FreeMem(filelist,sizeof(struct List));
  2974.                 added_bytes -= sizeof(struct List);
  2975.                }
  2976. if (getlist) 
  2977.               {
  2978.                 FreeFileNodes(getlist);
  2979.                 FreeMem(getlist,sizeof(struct List));
  2980.                 added_bytes -= sizeof(struct List);
  2981.                }
  2982. if (WorkbenchBase) CloseLibrary((struct Library *)WorkbenchBase);
  2983. if (IconBase)         CloseLibrary((struct Library *)IconBase);
  2984. if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  2985. if (AslBase)        CloseLibrary((struct Library *)AslBase);
  2986. if (UtilityBase)   CloseLibrary((struct Library *)UtilityBase);
  2987. if (GraphicsBase)  CloseLibrary((struct GraphicsLib *)GraphicsBase);
  2988. if (GadToolsBase)  CloseLibrary((struct Library *)GadToolsBase);
  2989. return();
  2990. }
  2991.  
  2992.  
  2993.  
  2994.  
  2995.  
  2996.  
  2997.  
  2998.  
  2999.  
  3000.  
  3001.  
  3002. int RequestAFile(char *szBuffer)
  3003. {
  3004. int rvalue = 1;
  3005.  
  3006. if (strlen(defDir) == 0) strcpy(defDir,"ram:");
  3007. if (strlen(defFile)== 0) strcpy(defFile,"RECENT");
  3008.  
  3009. struct TagItem frtags[] =
  3010. {
  3011.     ASL_Hail,        (ULONG)"Select a text file to browse.",
  3012.     ASL_Height,    350,
  3013.     ASL_Width,    320,
  3014.     ASL_LeftEdge,    50,
  3015.     ASL_TopEdge,    35,
  3016.     ASL_OKText,    (ULONG)"Okay",
  3017.     ASL_CancelText,(ULONG)"Cancel",
  3018.     ASL_File,        defFile,
  3019.     ASL_Dir,         defDir,
  3020.     ASL_Window,    mgetWnd,
  3021.     TAG_DONE
  3022. };
  3023.  
  3024. struct FileRequester *fr;
  3025.  
  3026. fr = (struct FileRequester *) AllocAslRequest(ASL_FileRequest, frtags);
  3027.  
  3028. if (fr == NULL) 
  3029.     {
  3030.     rvalue = 0 ;
  3031.     }
  3032.  
  3033.  if ((rvalue)&&(AslRequest(fr, NULL)))
  3034.     {
  3035.     strcpy(szBuffer,fr->rf_Dir);
  3036.     strncpy(defDir,fr->rf_Dir,sizeof(defDir));
  3037.     strncpy(defFile,fr->rf_File,sizeof(defFile));
  3038.     if ((defDir[strlen(defDir)-1] != '/')&&
  3039.         (defDir[strlen(defDir)-1] != ':')) strcat(szBuffer,"/");
  3040.     strcat(szBuffer,fr->rf_File);
  3041.     }
  3042.     else
  3043.     rvalue = 0;
  3044.     
  3045. if (fr != NULL) FreeAslRequest(fr);
  3046.  
  3047. return(rvalue);
  3048. }
  3049.  
  3050.  
  3051.  
  3052.  
  3053.  
  3054.  
  3055.  
  3056.  
  3057.  
  3058. void TurnOnAllMenuItems(struct Menu *myMenu)
  3059. {
  3060. struct MenuItem *mItem;
  3061.  
  3062.  while (myMenu != NULL)
  3063.     {
  3064.     mItem = myMenu->FirstItem;
  3065.     while (mItem != NULL)
  3066.         {
  3067.         mItem->Flags |= ITEMENABLED;
  3068.         mItem = mItem->NextItem;
  3069.         }
  3070.     myMenu = myMenu->NextMenu;
  3071.     }
  3072. return;
  3073. }
  3074.  
  3075.  
  3076.  
  3077.  
  3078.  
  3079.  
  3080.  
  3081.  
  3082.  
  3083.  
  3084. VOID SetReqDefaults(char *szFilePath)
  3085. {
  3086. char *sFileStart;
  3087.  
  3088.  sFileStart = strrchr(szFilePath,'/');
  3089.  if (sFileStart == NULL)
  3090.      {
  3091.      sFileStart = strrchr(szFilePath,':');
  3092.      if (sFileStart == NULL)
  3093.          {
  3094.          sFileStart = szFilePath;
  3095.          }
  3096.      }
  3097.  
  3098.  if (sFileStart != NULL) strncpy(defFile,sFileStart+(sFileStart != szFilePath),sizeof(defFile));
  3099.  if ((sFileStart != NULL)&&(sFileStart != szFilePath)) strncpy(defDir,szFilePath,(sFileStart - szFilePath) + 1);
  3100.  return();
  3101. }
  3102.  
  3103.  
  3104.  
  3105.  
  3106.  
  3107.  
  3108. VOID UpperCase(char *sOldString)
  3109. {
  3110. char *i = sOldString;
  3111. const int diff = 'a' - 'A';
  3112.  
  3113.  if (sOldString == NULL) return();
  3114.  while (*i != '\0')
  3115.  {
  3116.     if ((*i >= 'a')&&(*i <= 'z')) *i = *i - diff;
  3117.     i++;
  3118.  }
  3119. return();
  3120. }
  3121.  
  3122.  
  3123.  
  3124.  
  3125.  
  3126. VOID LowerCase(char *sOldString)
  3127. {
  3128. char *i = sOldString;
  3129. const int diff = 'a' - 'A';
  3130.  
  3131.  if (sOldString == NULL) return();
  3132.  while (*i != '\0')
  3133.     {
  3134.     if ((*i >= 'A')&&(*i <= 'Z')) *i = *i + diff;
  3135.     i++;
  3136.     }
  3137.  
  3138. return();
  3139. }
  3140.  
  3141.  
  3142.  
  3143.  
  3144.  
  3145.  
  3146. int mgetoutput(void)
  3147. {
  3148. FILE *fpTemp = NULL;
  3149.  
  3150.         if (files_selected > 0) 
  3151.         {
  3152.             /* If no output name given, do default output... */
  3153.              if (strlen(sOutFileName) == 0)
  3154.              {
  3155.                  /* for Workbench, absolute default is ram:GadMget.output */
  3156.                  if (BStartedFromWB == TRUE)
  3157.                  {
  3158.                      fpTemp = fopen("ram:Gadmget.Output","w");
  3159.                      if (fpTemp == NULL) 
  3160.                      {
  3161.                         MakeReq("Error:  Couldn't open ram:GadMget.output for writing!",NULL,"Ok");
  3162.                         CleanUp();
  3163.                         exit(10);
  3164.                      }
  3165.                  }
  3166.                  else
  3167.                  {    /* for the CLI, default is stdout */
  3168.                      fpTemp = stdout;
  3169.                  }
  3170.              }
  3171.              else
  3172.              {
  3173.                  /* open requested output file for writing */
  3174.                  fpTemp = fopen(sOutFileName,"w");
  3175.                  if (fpTemp == NULL)
  3176.                  {
  3177.                      MakeReq("Error:  Couldn't open output file!",NULL,"Ok");
  3178.                  }
  3179.              }
  3180.              
  3181.              fpOut = fpTemp;
  3182.             PrintFile(szHeaderFile,0);
  3183.             if (noparse) RawOutputList(getlist);
  3184.                        else OutputList(getlist); 
  3185.             PrintFile(szFooterFile,1);
  3186.             if (fpOut != stdout) fclose(fpOut);            
  3187.         }
  3188. return(0);
  3189. }
  3190.  
  3191.  
  3192.  
  3193. VOID ParseCliArgs(int argc, char *argv[])
  3194. {
  3195.  int nextpasslookfor = 0;
  3196.  FILE *fpTemp = NULL;
  3197.  
  3198.  memset(defDir,NUL,sizeof(defDir));
  3199.  memset(defFile,NUL,sizeof(defFile));
  3200.  memset(szHeaderFile,NUL,sizeof(szHeaderFile));
  3201.  memset(szFooterFile,NUL,sizeof(szFooterFile));
  3202.  memset(inputfile,NUL,sizeof(inputfile));
  3203.  
  3204.  if (argc > 1) 
  3205.      {
  3206.      strncpy(inputfile,argv[1],sizeof(inputfile));
  3207.      SetReqDefaults(inputfile);
  3208.      }
  3209.          
  3210.  if (*inputfile == '?')
  3211.     {
  3212.     fprintf(fpOut,"%s",template);
  3213.     CleanUp();
  3214.     exit(0);
  3215.     }
  3216.  
  3217.  
  3218.  for (int i=2; i<=argc; i++)
  3219.     {
  3220.     if (nextpasslookfor == 2)
  3221.         {
  3222.         strncpy(szPubScreenName,argv[i-1],sizeof(szPubScreenName));
  3223.         pubscreenname = szPubScreenName;
  3224.         screentype = USE_PUBSCREEN;
  3225.         continue;            /* skip to next loop */
  3226.         }
  3227.    if (nextpasslookfor == 7)         /* FILE PARAMETER */
  3228.          {
  3229.          strncpy(inputfile,argv[i-1],sizeof(inputfile));
  3230.          SetReqDefaults(inputfile);
  3231.          }
  3232.     if (nextpasslookfor == 9)        /* COMMAND PARAMETER */
  3233.         {
  3234.         strncpy(szCommandString,argv[i-1],sizeof(szCommandString));
  3235.         }
  3236.     if (nextpasslookfor == 16)    /* AMINETPATH PARAMETER */
  3237.         {
  3238.         strncpy(sAminetPathString,argv[i-1],sizeof(sAminetPathString));
  3239.         }
  3240.     if (nextpasslookfor == 17)    /* EOL PARAMETER */
  3241.         {
  3242.         strncpy(sEndOfLineString,argv[i-1],sizeof(sEndOfLineString));
  3243.         EOLParse(sEndOfLineString);
  3244.         }
  3245.  
  3246.     
  3247.     UpperCase(argv[i-1]);
  3248.  
  3249.     switch(nextpasslookfor)
  3250.     {    
  3251.     case(1):
  3252.         if (atoi(argv[i-1]) > 0)  maxoutputlinelength = atoi(argv[i-1]);
  3253.         break;
  3254.         
  3255.     /* case 2 is up above, before the Upper() command */
  3256.     
  3257.     case(3):        /* WIDTH PARAMETER */
  3258.         if (atoi(argv[i-1]) > 0)  windowwidth = 155;    /* min level */
  3259.         if (atoi(argv[i-1]) > 155) windowwidth = atoi(argv[i-1]);
  3260.         break;
  3261.     case(4):        /* HEIGHT PARAMETER */
  3262.         if (atoi(argv[i-1]) > 0) windowheight = 167;    /* min level */
  3263.         if (atoi(argv[i-1]) > 167) windowheight = atoi(argv[i-1]);
  3264.         break;
  3265.     case(5):        /* TOP PARAMETER */
  3266.         if (atoi(argv[i-1]) > 0) windowtop = atoi(argv[i-1]);
  3267.         break;
  3268.     case(6):        /* LEFT PARAMETER */
  3269.         if (atoi(argv[i-1]) > 0) windowleft = atoi(argv[i-1]);
  3270.         break;
  3271.         
  3272.     /* Case 7 is up above, before the Upper() command */
  3273.     
  3274.     case(8):        /* OUTPUT PARAMETER */
  3275.         strncpy(sOutFileName,argv[i-1],sizeof(sOutFileName));
  3276.         break;
  3277.     
  3278.     /* Case 9 is up above, before the Upper() command */
  3279.     
  3280.     case(10):        /* HEADER PARAMETER */
  3281.         strncpy(szHeaderFile,argv[i-1],sizeof(szHeaderFile));
  3282.         break;
  3283.         
  3284.     case(11):        /* FOOTER PARAMETER */
  3285.         strncpy(szFooterFile,argv[i-1],sizeof(szFooterFile));
  3286.         break;
  3287.  
  3288.     case(12):        /* FONT PARAMETER */
  3289.         strncpy(sListFontName,argv[i-1],sizeof(sListFontName));
  3290.         LowerCase(sListFontName);
  3291.         if (strstr(sListFontName,".font") == NULL) strncat(sListFontName,".font",sizeof(sListFontName));
  3292.         break;
  3293.         
  3294.     case(13):        /* FONTSIZE PARAMETER */
  3295.         if (atoi(argv[i-1]) > 0) nListFontSize = atoi(argv[i-1]);
  3296.         break;
  3297.     
  3298.     case(14):        /* FILESORT PARAMETER */
  3299.         LowerCase(argv[i-1]);
  3300.         if (strcmp(argv[i-1],"directory") == 0)   nSortType[0] = SORTBYDIR;
  3301.         if (strcmp(argv[i-1],"filename") == 0)    nSortType[0] = SORTBYNAME;
  3302.         if (strcmp(argv[i-1],"size") == 0)        nSortType[0] = SORTBYSIZE;
  3303.         if (strcmp(argv[i-1],"description") == 0) nSortType[0] = SORTBYDESC;
  3304.         break;
  3305.             
  3306.     case(15):        /* GETSORT PARAMETER */
  3307.         LowerCase(argv[i-1]);
  3308.         if (strcmp(argv[i-1],"directory") == 0)   nSortType[1] = SORTBYDIR;
  3309.         if (strcmp(argv[i-1],"filename") == 0)    nSortType[1] = SORTBYNAME;
  3310.         if (strcmp(argv[i-1],"size") == 0)        nSortType[1] = SORTBYSIZE;
  3311.         if (strcmp(argv[i-1],"description") == 0) nSortType[1] = SORTBYDESC;
  3312.         break;
  3313.  
  3314.     /* Case 16 is up above the Upper() command */
  3315.  
  3316.     /* Case 17 is up above the Upper() command */
  3317.             
  3318.     default:
  3319.         /* nothing */
  3320.         break;        
  3321.     }
  3322.     nextpasslookfor = 0;
  3323.     
  3324.     
  3325.     
  3326.     if (strcmp(argv[i-1],"NOAPPWINDOW") == 0) appwindow         = FALSE;
  3327.     if (strcmp(argv[i-1],"SEARCHCASESENSITIVE") == 0) searchcasesensitive = TRUE;    
  3328.     if (strcmp(argv[i-1],"SORTCASESENSITIVE") == 0) sortcasesensitive= TRUE;    
  3329.     if (strcmp(argv[i-1],"CASESENSITIVE") == 0) 
  3330.             {
  3331.                 sortcasesensitive= TRUE;    
  3332.                 searchcasesensitive = TRUE;
  3333.             }
  3334.  
  3335.     if (strcmp(argv[i-1],"NOPARSE") == 0)         noparse             = TRUE;
  3336.     if (strcmp(argv[i-1],"NOCOMMAND") == 0)     nocommand        = TRUE;
  3337.     if (strcmp(argv[i-1],"NOSPLIT") == 0)         nosplit             = TRUE;
  3338.     if (strcmp(argv[i-1],"GETREADMES") == 0)     getreadmes         = TRUE;    
  3339.     if (strcmp(argv[i-1],"NOCD") == 0)            nocd                = TRUE;
  3340.    if (strcmp(argv[i-1],"NOFILES") == 0)     
  3341.                                             {
  3342.                                             filesflag     = FALSE;
  3343.                                             getreadmes  = TRUE;
  3344.                                             }
  3345.      if (strcmp(argv[i-1],"LINELENGTH") == 0)           nextpasslookfor= 1;
  3346.      if (strcmp(argv[i-1],"PUBSCREEN") == 0)           nextpasslookfor= 2;
  3347.     if (strcmp(argv[i-1],"DEFPUBSCREEN") == 0)       screentype = USE_PUBSCREEN;     
  3348.     if ((strcmp(argv[i-1],"WBSCREEN") == 0)||
  3349.         (strcmp(argv[i-1],"WORKBENCHSCREEN") == 0)) screentype = USE_WBSCREEN;
  3350.     if (strcmp(argv[i-1],"NOSIMPLEPATHS") == 0)       simplepaths  = FALSE;    
  3351.     if (strcmp(argv[i-1],"KEEPBLANKLINES") == 0)    keepblanklines = TRUE;
  3352.     if (strcmp(argv[i-1],"KEEPFILESSORT") == 0)   nKeepSorted[0] = TRUE;
  3353.     if (strcmp(argv[i-1],"KEEPGETSORT") == 0)     nKeepSorted[1] = TRUE;
  3354.                                                                                     
  3355.     if (strcmp(argv[i-1],"WIDTH") == 0)            nextpasslookfor = 3;
  3356.     if (strcmp(argv[i-1],"HEIGHT") == 0)        nextpasslookfor = 4;
  3357.     if (strcmp(argv[i-1],"TOP") == 0)            nextpasslookfor = 5;
  3358.     if (strcmp(argv[i-1],"LEFT") == 0)            nextpasslookfor = 6;
  3359.     if (strcmp(argv[i-1],"FILE") == 0)            nextpasslookfor = 7;
  3360.     if (strcmp(argv[i-1],"OUTPUT") == 0)        nextpasslookfor = 8;
  3361.     if (strcmp(argv[i-1],"COMMAND") == 0)        nextpasslookfor = 9;
  3362.     if (strcmp(argv[i-1],"HEADER") == 0)        nextpasslookfor = 10;
  3363.     if (strcmp(argv[i-1],"FOOTER") == 0)        nextpasslookfor = 11;
  3364.     if (strcmp(argv[i-1],"FONT") == 0)        nextpasslookfor = 12;
  3365.     if (strcmp(argv[i-1],"FONTSIZE") == 0)    nextpasslookfor = 13;
  3366.     if (strcmp(argv[i-1],"SIZE") == 0)        nextpasslookfor = 13;
  3367.     if (strcmp(argv[i-1],"FILESORT") == 0)    nextpasslookfor = 14;
  3368.     if (strcmp(argv[i-1],"GETSORT") == 0)     nextpasslookfor = 15;
  3369.     if (strcmp(argv[i-1],"AMINETPATH") == 0)  nextpasslookfor = 16;
  3370.     if (strcmp(argv[i-1],"EOL") == 0)         nextpasslookfor = 17;
  3371.     }
  3372.  
  3373. return();
  3374. }
  3375.  
  3376.  
  3377.  
  3378.  
  3379.  
  3380.  
  3381.  
  3382.  
  3383.  
  3384.  
  3385. VOID wbmain(struct WBStartup *argv)
  3386. {
  3387. BStartedFromWB = TRUE;
  3388. IconBase = OpenLibrary("icon.library",33);
  3389. if (IconBase == NULL)
  3390.      {
  3391.      exit(2);
  3392.      }
  3393. ParseWBArgs(argv);
  3394. main(0,argv);
  3395. }
  3396.  
  3397.  
  3398.  
  3399.  
  3400.  
  3401.  
  3402.  
  3403.  
  3404. VOID ParseWBArgs(struct WBStartup *argv)
  3405. {
  3406. struct WBArg *wb_arg = argv->sm_ArgList;
  3407. struct DiskObject *dobj;
  3408. char **toolarray, *sTemp;
  3409. FILE *fpTemp = NULL;
  3410.  
  3411.  
  3412. memset(defDir,NUL,sizeof(defDir));
  3413. memset(defFile,NUL,sizeof(defFile));
  3414. memset(szHeaderFile,NUL,sizeof(szHeaderFile));
  3415. memset(szFooterFile,NUL,sizeof(szFooterFile));
  3416.  
  3417.  
  3418. /* Parse the tooltypes from the program file */
  3419. dobj = GetDiskObject(wb_arg->wa_Name);
  3420.  
  3421. if (dobj != NULL)
  3422.  {
  3423.      toolarray = (char **) dobj->do_ToolTypes;
  3424.     if (toolarray != NULL)
  3425.     {
  3426.     
  3427.         if (sTemp = (char *) FindToolType(toolarray,"OUTPUT")) 
  3428.         {
  3429.           strncpy(sOutFileName,sTemp,sizeof(sOutFileName));
  3430.         }
  3431.                                             
  3432.         if (sTemp = (char *) FindToolType(toolarray,"FILE")) 
  3433.                 {
  3434.                 strncpy(inputfile,sTemp,sizeof(inputfile));
  3435.                 SetReqDefaults(inputfile);
  3436.                 }
  3437.         if (sTemp = (char *) FindToolType(toolarray,"NOPARSE"))       noparse     = TRUE;
  3438.         if (sTemp = (char *) FindToolType(toolarray,"NOCOMMAND"))      nocommand   = TRUE;
  3439.        if (sTemp = (char *) FindToolType(toolarray,"NOSPLIT"))       nosplit     = TRUE;    
  3440.        if (sTemp = (char *) FindToolType(toolarray,"GETREADMES"))  getreadmes  = TRUE;
  3441.         if (sTemp = (char *) FindToolType(toolarray,"NOFILES"))
  3442.                                                              {
  3443.                                                             filesflag     = FALSE;
  3444.                                                             getreadmes  = TRUE;
  3445.                                                             }
  3446.        if (sTemp = (char *) FindToolType(toolarray,"LINELENGTH"))
  3447.                    {
  3448.                    if (atoi(sTemp) > 0)  maxoutputlinelength = atoi(sTemp); 
  3449.                    }
  3450.                   
  3451.           if (sTemp = (char *) FindToolType(toolarray,"PUBSCREEN"))   
  3452.                       {
  3453.                       strcpy(szPubScreenName,sTemp);
  3454.                       pubscreenname = szPubScreenName;
  3455.                       screentype = USE_PUBSCREEN;
  3456.                       }
  3457.           
  3458.           if (sTemp = (char *) FindToolType(toolarray,"NOSIMPLEPATHS"))     simplepaths = FALSE;        
  3459.           if (sTemp = (char *) FindToolType(toolarray,"NOPARSE"))   noparse = TRUE;        
  3460.         if (sTemp = (char *) FindToolType(toolarray,"NOAPPWINDOW")) appwindow = FALSE;
  3461.         if (sTemp = (char *) FindToolType(toolarray,"WBSCREEN"))           screentype = USE_WBSCREEN;
  3462.         if (sTemp = (char *) FindToolType(toolarray,"WORKBENCHSCREEN")) screentype = USE_WBSCREEN;                                
  3463.         if (sTemp = (char *) FindToolType(toolarray,"NOCD"))                 nocd = TRUE;
  3464.         if (sTemp = (char *) FindToolType(toolarray,"KEEPBLANKLINES")) keepblanklines = TRUE;
  3465.         if (sTemp = (char *) FindToolType(toolarray,"KEEPFILESORT")) nKeepSorted[0] = TRUE;
  3466.         if (sTemp = (char *) FindToolType(toolarray,"KEEPGETSORT")) nKeepSorted[1] = TRUE;
  3467.         
  3468.         if (sTemp = (char *) FindToolType(toolarray,"WIDTH"))                             
  3469.                         {
  3470.                         if (atoi(sTemp) > 0)  windowwidth = 155;    /* min level */
  3471.                         if (atoi(sTemp) > 155) windowwidth = atoi(sTemp);
  3472.                         }
  3473.         if (sTemp = (char *) FindToolType(toolarray,"HEIGHT"))     
  3474.                         {                        
  3475.                         if (atoi(sTemp) > 0) windowheight = 167;    /* min level */
  3476.                         if (atoi(sTemp) > 167) windowheight = atoi(sTemp);
  3477.                         }
  3478.         if (sTemp = (char *) FindToolType(toolarray,"TOP"))                             
  3479.                         {
  3480.                         if (atoi(sTemp) > 0) windowtop = atoi(sTemp);
  3481.                         }
  3482.         if (sTemp = (char *) FindToolType(toolarray,"LEFT"))                             
  3483.                         {
  3484.                         if (atoi(sTemp) > 0) windowleft = atoi(sTemp);
  3485.                         }                    
  3486.         if (sTemp = (char *) FindToolType(toolarray,"SEARCHCASESENSITIVE"))                             
  3487.                         {
  3488.                         searchcasesensitive = 1;
  3489.                         }
  3490.         if (sTemp = (char *) FindToolType(toolarray,"SORTCASESENSITIVE"))                             
  3491.                         {
  3492.                         sortcasesensitive = 1;
  3493.                         }
  3494.         if (sTemp = (char *) FindToolType(toolarray,"CASESENSITIVE"))                             
  3495.                         {
  3496.                         searchcasesensitive = 1;
  3497.                         sortcasesensitive = 1;
  3498.                         }
  3499.  
  3500.         if (sTemp = (char *) FindToolType(toolarray,"COMMAND"))
  3501.                         {
  3502.                         strncpy(szCommandString,sTemp,sizeof(szCommandString));
  3503.                         }
  3504.         if (sTemp = (char *) FindToolType(toolarray,"HEADER"))
  3505.                         {
  3506.                         strncpy(szHeaderFile,sTemp,sizeof(szHeaderFile));
  3507.                         }
  3508.         if (sTemp = (char *) FindToolType(toolarray,"FOOTER"))
  3509.                         {
  3510.                         strncpy(szFooterFile,sTemp,sizeof(szFooterFile));
  3511.                         }
  3512.         if (sTemp = (char *) FindToolType(toolarray,"FONT"))
  3513.                         {
  3514.                         strncpy(sListFontName,sTemp,sizeof(sListFontName));
  3515.                         LowerCase(sListFontName);
  3516.                         if (strstr(sListFontName,".font") == NULL) strncat(sListFontName,".font",sizeof(sListFontName));
  3517.                         }
  3518.         if (sTemp = (char *) FindToolType(toolarray,"FONTSIZE"))
  3519.                         {
  3520.                         if (atoi(sTemp) > 0) nListFontSize = atoi(sTemp);
  3521.                         }
  3522.         if (sTemp = (char *) FindToolType(toolarray,"SIZE"))
  3523.                         {
  3524.                         if (atoi(sTemp) > 0) nListFontSize = atoi(sTemp);
  3525.                         }
  3526.         if (sTemp = (char *) FindToolType(toolarray,"FILESORT"))
  3527.                         {
  3528.                         LowerCase(sTemp);
  3529.                         if (strcmp(sTemp,"directory") == 0)   nSortType[0] = SORTBYDIR;
  3530.                         if (strcmp(sTemp,"filename") == 0)    nSortType[0] = SORTBYNAME;
  3531.                         if (strcmp(sTemp,"size") == 0)        nSortType[0] = SORTBYSIZE;
  3532.                         if (strcmp(sTemp,"description") == 0) nSortType[0] = SORTBYDESC;
  3533.                         }
  3534.         if (sTemp = (char *) FindToolType(toolarray,"GETSORT"))
  3535.                         {
  3536.                         LowerCase(sTemp);
  3537.                         if (strcmp(sTemp,"directory") == 0)   nSortType[1] = SORTBYDIR;
  3538.                         if (strcmp(sTemp,"filename") == 0)    nSortType[1] = SORTBYNAME;
  3539.                         if (strcmp(sTemp,"size") == 0)        nSortType[1] = SORTBYSIZE;
  3540.                         if (strcmp(sTemp,"description") == 0) nSortType[1] = SORTBYDESC;
  3541.                         }    
  3542.                         
  3543.         if (sTemp = (char *) FindToolType(toolarray,"AMINETPATH"))
  3544.                         strncpy(sAminetPathString,sTemp,sizeof(sAminetPathString));
  3545.         if (sTemp = (char *) FindToolType(toolarray,"EOL"))
  3546.                         {
  3547.                         strncpy(sEndOfLineString,sTemp,sizeof(sEndOfLineString));
  3548.                         EOLParse(sEndOfLineString);
  3549.                         }
  3550.                         
  3551.     }                     
  3552.  FreeDiskObject(dobj);
  3553.  }
  3554.  
  3555.  /* Get the name of the file extended_clicked, if there is one */
  3556.  if (argv->sm_NumArgs > 1) 
  3557.     {
  3558.     wb_arg++;    /* The first name is the programs name, the 2nd is the proj. icon */
  3559.     if (wb_arg->wa_Name != NULL) 
  3560.         {
  3561.         strncpy(inputfile,wb_arg->wa_Name,sizeof(inputfile));
  3562.         CurrentDir(wb_arg->wa_Lock);
  3563.         }
  3564.     }
  3565.     
  3566. return();
  3567. }
  3568.  
  3569.  
  3570.  
  3571.  
  3572.  
  3573.  
  3574.  
  3575.  
  3576.  
  3577.  
  3578. /********/
  3579. /* MAIN */
  3580. /********/
  3581. VOID main(int argc, char *argv[])
  3582. {
  3583. FILE *test = NULL;
  3584. ULONG winsig,signals;
  3585. BPTR olddir;
  3586.  
  3587. GraphicsBase = OpenLibrary("graphics.library",37);
  3588.  if (GraphicsBase==NULL)
  3589.     {
  3590.     fprintf(fpOut,"couldn't open Graphics.library v37!");
  3591.     CleanUp();
  3592.     return;
  3593.     }
  3594. UtilityBase = OpenLibrary("utility.library",37);
  3595.  if (UtilityBase==NULL)
  3596.     {
  3597.     fprintf(fpOut,"couldn't open utility.library v37!");
  3598.     CleanUp();
  3599.     return;
  3600.     }
  3601. GadToolsBase = OpenLibrary("gadtools.library",37);
  3602.  if (GadToolsBase==NULL)
  3603.     {
  3604.     fprintf(fpOut,"couldn't open gadtools.library v37!\n");
  3605.     CleanUp();
  3606.     return;
  3607.     }
  3608. AslBase = OpenLibrary("asl.library", 37L);
  3609.  if (AslBase == NULL)
  3610.     {
  3611.     fprintf(fpOut,"couldn't open asl.library v37!\n");
  3612.     CleanUp();
  3613.     return;
  3614.     }
  3615. IntuitionBase = OpenLibrary("intuition.library",37);
  3616.  if (IntuitionBase == NULL)
  3617.      {
  3618.      fprintf(fpOut,"Couldn't open intuition.library!\n");
  3619.      CleanUp();
  3620.      return;
  3621.      }
  3622. WorkbenchBase = OpenLibrary("workbench.library",37);
  3623.  if (WorkbenchBase == NULL)
  3624.      {
  3625.      fprintf(fpOut,"Couldn't open workbench.library!\n");
  3626.      CleanUp();
  3627.      return;
  3628.      }
  3629.  
  3630. /* construct program name from version string */
  3631. memset(pnamestring,NUL,20);
  3632. strcpy(pnamestring,version+6);
  3633.  
  3634. memset(searchstring,NUL,sizeof(searchstring));
  3635.  
  3636. if (argc>1) ParseCliArgs(argc,argv);
  3637.      
  3638. /* Now add data to listView */
  3639. /* First, initialize List filelist */
  3640.     
  3641.  if (!(filelist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  3642.     {
  3643.     MakeReq("Couldn't create filelist!  Out of memory?",NULL,"Oh, Dear");
  3644.     CleanUp();
  3645.     return();
  3646.     }
  3647.  added_bytes += sizeof(struct List);
  3648.     
  3649.  if (!(getlist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  3650.     {
  3651.     MakeReq("Couldn't create getlist!  Out of memory?",NULL,"Oh, Dear");
  3652.     CleanUp();
  3653.     return();
  3654.     }
  3655.  added_bytes += sizeof(struct List);
  3656.     
  3657.  NewList(filelist);
  3658.  NewList(getlist);
  3659.  
  3660.  
  3661.  lockscrnerror = SetupScreen();
  3662.  if (lockscrnerror)
  3663.     {
  3664.     if (BStartedFromWB == FALSE) printf("Couldn't open screen!\n",NULL,"Sigh");
  3665.     else
  3666.     MakeReq("Couldn't open screen!",NULL,NULL);
  3667.     
  3668.     CleanUp();
  3669.     return();
  3670.     }
  3671.  
  3672.  screenisopen = 1;
  3673.     
  3674.  winopenerror = OpenmgetWindow();
  3675.  if (winopenerror)
  3676.     {
  3677.     MakeReq("Couldn't open window!",NULL,"Sigh");
  3678.     CleanUp();
  3679.     return();
  3680.     }
  3681.  windowisopen = 1;
  3682.  
  3683.  if (ReadmyFile() > 0)
  3684.     {
  3685.         /* Sort if need be */
  3686.         if ((nKeepSorted[0] == 1)&&(!noparse)) SortList(filelist,nSortType[0]);
  3687.         
  3688.         /* First, make sure all the menus are enabled. */
  3689.         TurnOnAllMenuItems(mgetMenus);
  3690.         
  3691.         SetMenuValues();
  3692.     
  3693.         GT_SetGadgetAttrs((struct Gadget *) mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END); 
  3694.         files_selected = 0;
  3695.     
  3696.         if (noparse) SetWindowTitles(mgetWnd, "Please select desired lines now." , (char *) ~0); 
  3697.                    else ChangeWindowTitle();
  3698.         
  3699.         winsig = 1L << mgetWnd->UserPort->mp_SigBit;
  3700.         while (done==FALSE)
  3701.             {
  3702.             signals = Wait(winsig|appwinsig);
  3703.             if (signals&winsig) handlereturn = HandlemgetIDCMP();
  3704.             if (signals&appwinsig) 
  3705.                 {
  3706.                 while (amsg = (struct AppMessage *) GetMsg(awport))
  3707.                     {
  3708.                     argptr = amsg->am_ArgList;
  3709.                     if (argptr->wa_Name != NULL)
  3710.                         {
  3711.                         strcpy(inputfile,argptr->wa_Name);
  3712.                         if (argptr->wa_Lock != NULL) 
  3713.                             {
  3714.                             olddir = CurrentDir(argptr->wa_Lock);
  3715.                             SetReqDefaults(inputfile);
  3716.                              test = fopen(inputfile,"r");
  3717.                              if (test != NULL)
  3718.                                  {
  3719.                                  fclose(test);
  3720.                                  GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  3721.                                 FreeFileNodes(filelist); 
  3722.                                  FreeMem(filelist,sizeof(struct List));
  3723.                                  added_bytes -= sizeof(struct List);
  3724.                                  ClearPointer(mgetWnd);
  3725.          
  3726.                                  if (!(filelist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  3727.                                     {
  3728.                                     MakeReq("AppOpen : Couldn't create filelist!  Out of memory?",NULL,"Ok");
  3729.                                     return;
  3730.                                     }
  3731.                                  added_bytes += sizeof(struct List);
  3732.                     
  3733.                                  filelist_length = 0;
  3734.                                  search_current = NULL;
  3735.                                  search_index = 0;
  3736.                                  
  3737.                                 NewList(filelist);
  3738.                                  ReadmyFile();
  3739.                                  GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  3740.                                 CurrentDir(olddir);
  3741.                                 }
  3742.                                 else
  3743.                                 DisplayBeep(Scr);
  3744.                             }
  3745.                         }
  3746.                     ReplyMsg((struct Message *) amsg);
  3747.                     }
  3748.                 }
  3749.             }
  3750.         if (windowisopen)  ClosemgetWindow();
  3751.         if (screenisopen)  CloseDownScreen();
  3752.     
  3753.         mgetoutput();
  3754.     }
  3755. CleanUp();
  3756.         
  3757. exit(0);    
  3758. }
  3759.  
  3760. #endif
  3761.  
  3762.  
  3763.     
  3764.