home *** CD-ROM | disk | FTP | other *** search
/ The Arcade BBS / arcadebbs.zip / arcadebbs / bbstools / MODS / SCFG40.ZIP / SCONFIG.MOD < prev   
Encoding:
Text File  |  1994-08-20  |  20.9 KB  |  752 lines
  1. ┌─────────────────────────────────────────────────────────────────────────────┐
  2. │ ModTitle: Super Config -> Asylum Q/Nscan config 1.5a       August 14, 1994  │
  3. │ What Is?: Common 1.1+ Mod. Menu driven QScan/NScan config                   │
  4. │                                                                             │
  5. │ Difficulty: Easy, 5 or so places changed in source, and then block read the │
  6. │             rest                                                            │
  7. │ Files affected: DEFAULTS.C XFEROVL.C BBS.C                                  │
  8. │                                                                             │
  9. │ BY: Asylum Group                                                            │
  10. │ Credits: No one                                                             │
  11. └─────────────────────────────────────────────────────────────────────────────┘
  12.  
  13. If you are upgrading, all you need to do is step 4 (re-block read) and that is
  14. it!
  15.  
  16. 1.5 Notes:
  17.   A few bug fixes, one of the mods that actually didn't need any to speek of
  18.   Made is so there are two columns instead of one.
  19.   You can now read new or list files in there (hey, I was bored)
  20.  
  21.  
  22. Other Mods by the Asylum Group: (All require COMMON mod to install)
  23.  
  24.   WWIV User Pulldown Menus
  25.     Featuring script menus, once they are in, you don't need to mod the BBS to
  26.     change your menus around, includes ability to use ALL colors except for
  27.     the blinking ones in your menus, definable security for each menu item, and
  28.     instructions on how to expand the resource language.
  29.        
  30.   List Files Plus
  31.     In the people who have installed this mod words, simply the best
  32.     file list/search/tag/view/etc... mod for wwiv.  Allows you to go back and
  33.     forth in the files, selecting the files with the up and down arrow, and at
  34.     the bottom you have a menu you use the left and right arrow keys.  The
  35.     menus commands consist of such commands as show next files, show previous
  36.     files, put file in batch queue (or can be done with a space bar), view
  37.     file, download file, enter batch menu, go back and forward a directory.
  38.     And now, it shows the files description, in true vision/2 style, when you
  39.     list the files.  Now also does sysop commands and has configurable file
  40.     listing...
  41.  
  42.   Asylum QWK
  43.     Only the Asylum Group can bring you such a quality mod.  Most QWK features
  44.     are available, upload REP, download QWK, set max msgs per QWK and per sub
  45.     plus more.
  46.  
  47.  
  48.  
  49. The Modification:
  50.   
  51.   Please take steps to insure your BBS can be recovered in case of a problem.
  52.   I take no responsibility in you doing this, if you can't put in this mod
  53.   without losing your userrec or whatever else may happen, then don't install
  54.   it.
  55.   
  56.   Now... this modification seems to work real well, special care is taken to
  57.   avoid memory allocation/overrun/leaks problems (probley 99% of real problems)
  58.   but I am not prefect.
  59.  
  60.  
  61. + Add
  62. - Subtract
  63. * Change
  64. = Existing
  65. @# See number
  66.  
  67.  
  68. Step 1a)
  69.   This is a Common mod, which means you need to have COMMON installed.
  70.  
  71. Step 1b)
  72.   Put the supplied files so you can work with them, move SCONFIG.HLP to your 
  73.   GFILES directory so the users can get help.
  74.   
  75.  
  76. Step 2) XFEROVL.C
  77.   Add the following so that the config scan plus will be activated
  78.  
  79. = void config_nscan(void)
  80. = {
  81. =   char *s,s1[MAX_CONFERENCES+2],s2[120],ch;
  82. =   int i,i1,done,done1,oc,os,abort=0;
  83. = 
  84. +   if(okansi())
  85. +   {
  86. +     config_scan_plus(NSCAN);
  87. +     return;
  88. +   }
  89.   
  90.  
  91. Step 3) DEFAULTS.C
  92.   Add the following so that the config scan plus will be activated.
  93.   
  94. = void config_qscan(void)
  95. = {
  96. =   char *s, s1[MAX_CONFERENCES+2], s2[120], ch;
  97. =   int i,done,done1,oc,os,abort=0;
  98.  
  99. +   if(okansi())
  100. +   {
  101. +     config_scan_plus(QSCAN);
  102. +     return;
  103. +   }
  104.   
  105.  
  106. Step 4) DEFAULTS.C
  107.   Block read in the following at the end of DEFAULTS.C
  108.   
  109. /* ************************************************************************** */
  110. #include <conio.h>
  111.  
  112. // This defines how far from the bottom your list will stop
  113. #define STOP_LIST 0
  114.  
  115. // This is for, plain and simply, total lamers, people who do not know how to
  116. // set there system up right, users that say they have 25 screenlines, when in
  117. // fact, qmodem is taking up 2 of them, leaving them with only 23 (or 24)
  118. // This define overrides the STOP_LIST define if nessisary.
  119. // Undefine this to let the program show as many items as it can as defined by
  120. // the thisuser.screenlines variable, thus 50 line users will show about 46 or
  121. // so files, while 24, 25 etcc... will also show just the right amount to fill
  122. // up the screen
  123. // Leave it defined and it will never show more than the defined amount.
  124. // Undefine it to not have a max
  125. #define MAX_SCREEN_LINES_TO_SHOW 24
  126.  
  127.  
  128. // Side menu colors
  129. #define NORMAL_HIGHLIGHT   (YELLOW+(BLACK<<4))
  130. #define NORMAL_MENU_ITEM   (CYAN+(BLACK<<4))
  131. #define CURRENT_HIGHLIGHT  (RED+(LIGHTGRAY<<4))
  132. #define CURRENT_MENU_ITEM  (BLACK+(LIGHTGRAY<<4))
  133.  
  134.  
  135.  
  136.  
  137. void list_config_scan_plus(int first, int *amount, int type)
  138. {
  139.   int this_sub, this_dir, alias_dir;
  140.   int useconf, max_lines;
  141.   char s[101];
  142.   
  143.   useconf=((subconfnum>1) && okconf(&thisuser));
  144.  
  145.   CLS();
  146.   lines_listed=0;
  147.  
  148.   if(useconf)
  149.   {
  150.     strncpy(s, type == 0 ? stripcolors(subconfs[uconfsub[curconfsub].confnum].name) : stripcolors(dirconfs[uconfdir[curconfdir].confnum].name), 27);
  151.     s[27]=0;
  152.     npr("1Configure 7%cSCAN 9-- 2%-27s 9-- 3Press <5SPACE3> to toggle a sub\n\r", type==0 ? 'Q' : 'N', s);
  153.   }
  154.   else
  155.     npr("1Configure 7%cSCAN                                   3Press <5SPACE3> to toggle a sub\n\r", type==0 ? 'Q' : 'N');
  156.  
  157.  
  158.   // outstr("5───────────────────────────────────────────────────────────────────────────────\n\r");
  159.   // Replace the above with the below
  160.   ansic(5);
  161.   repeat_char('─', 79);
  162.   nl();
  163.   
  164. #ifdef MAX_SCREEN_LINES_TO_SHOW
  165.   max_lines = (
  166.                                 thisuser.screenlines-(4+STOP_LIST) >
  167.                                 MAX_SCREEN_LINES_TO_SHOW-(4+STOP_LIST)
  168.                 ?
  169.                 MAX_SCREEN_LINES_TO_SHOW-(4+STOP_LIST)
  170.                 :
  171.                 thisuser.screenlines-(4+STOP_LIST)
  172.               );
  173. #else
  174.   max_lines = thisuser.screenlines-(4+STOP_LIST);
  175. #endif
  176.  
  177.   
  178.   if(type==0)
  179.   {
  180.     for (this_sub=first; (this_sub<num_subs) && (usub[this_sub].subnum!=-1) &&
  181.           *amount < max_lines * 2; this_sub++)
  182.     {
  183.       lines_listed=0;
  184.  
  185.       sprintf(s,"7[1%c7] 2%s",
  186.           (qsc_q[usub[this_sub].subnum/32]&(1L<<(usub[this_sub].subnum%32)))?'■':' ',
  187.           subboards[usub[this_sub].subnum].name);
  188.  
  189.       s[44]=0; /* this is greater than 40 cuz we have 8 heart bytes to accout for */
  190.  
  191.       if(*amount >= max_lines)
  192.       {
  193.         GOTO_XY(40, 3 + *amount - max_lines);
  194.         outstr(s);
  195.       }
  196.       else
  197.         pl(s);
  198.  
  199.       ++*amount;
  200.     }
  201.   }
  202.   else
  203.   {
  204.     for (this_dir=first; (this_dir<num_dirs) && (udir[this_dir].subnum!=-1) &&
  205.           *amount < max_lines * 2; this_dir++)
  206.     {
  207.       lines_listed=0;
  208.       alias_dir=udir[this_dir].subnum;
  209.       sprintf(s,"7[1%c7] 2%s",
  210.                 qsc_n[alias_dir/32]&(1L<<(alias_dir%32)) ? '■' : ' ',
  211.                 directories[alias_dir].name);
  212.  
  213.        s[44]=0; /* this is greater than 40 cuz we have 8 heart bytes to accout for */
  214.  
  215.  
  216.       if(*amount >= max_lines)
  217.       {
  218.         GOTO_XY(40, 3 + *amount - max_lines);
  219.         outstr(s);
  220.       }
  221.       else
  222.         pl(s);
  223.  
  224.       ++*amount;
  225.     }
  226.   }
  227.   nl();
  228.   lines_listed=0;
  229. }
  230.  
  231. void config_scan_plus(int type)
  232. {
  233.   char **menu_items;
  234.   int done, redraw=0;
  235.   int pos=0, side_pos=0;
  236.   int top=0, command;
  237.   int amount=0;
  238.   int useconf;
  239.  
  240.  
  241.   struct side_menu_colors smc={NORMAL_HIGHLIGHT,
  242.                               NORMAL_MENU_ITEM,
  243.                               CURRENT_HIGHLIGHT,
  244.                               CURRENT_MENU_ITEM};
  245.  
  246.   useconf=((subconfnum>1) && okconf(&thisuser));
  247.     
  248.   helpl=32000;
  249.   
  250.   // Turn off topscreen info for this mod
  251.   topdata=0;
  252.   topscreen();
  253.   
  254.   menu_items=(char **)alloc_2d(10, 10, sizeof(char));
  255.  
  256.   strcpy(menu_items[0], "Next");
  257.   strcpy(menu_items[1], "Prev");
  258.   strcpy(menu_items[2], "Toggle");
  259.   strcpy(menu_items[3], "Clear ALL");
  260.   strcpy(menu_items[4], "Set ALL");
  261.  
  262.   if(type==0)
  263.     strcpy(menu_items[5], "Read New");
  264.   else
  265.     strcpy(menu_items[5], "List");
  266.  
  267.   if(useconf)
  268.   {
  269.     strcpy(menu_items[6], "{ Conf");
  270.     strcpy(menu_items[7], "} Conf");
  271.     strcpy(menu_items[8], "Quit");
  272.     strcpy(menu_items[9], "?");
  273.     menu_items[9][0]=0;      // Changed this line from null
  274.   }
  275.   else
  276.   {
  277.     strcpy(menu_items[6], "Quit");
  278.     strcpy(menu_items[7], "?");
  279.     menu_items[7][0]=0;      // Changed this line from null
  280.   }
  281.  
  282.  
  283.  
  284.  
  285.   
  286.   done=0;
  287.   
  288.   while(!done && !hangup)
  289.   { 
  290.     int menu_done=0;
  291.     
  292.     amount=0;
  293.     list_config_scan_plus(top, &amount, type);
  294.     
  295.     if(!amount)
  296.     {  
  297.       top=0;          
  298.       list_config_scan_plus(top, &amount, type);
  299.       if(!amount)
  300.         done=1;
  301.     }
  302.     
  303.     if(!done)  
  304.       drawscan(pos, type ? is_inscan(top+pos) :
  305.               qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  306.               
  307.     
  308.               
  309.     redraw=1;
  310.     
  311.     while(!menu_done && !hangup && !done)
  312.     {
  313.       command = side_menu(&side_pos, redraw, menu_items, 1,
  314. #ifdef MAX_SCREEN_LINES_TO_SHOW
  315.       thisuser.screenlines-STOP_LIST > MAX_SCREEN_LINES_TO_SHOW-STOP_LIST ? MAX_SCREEN_LINES_TO_SHOW-STOP_LIST : thisuser.screenlines-STOP_LIST, &smc);
  316. #else
  317.       thisuser.screenlines-STOP_LIST, &smc);
  318. #endif             
  319.  
  320.       lines_listed=0;
  321.  
  322.  
  323.       redraw=1;
  324.       ansic(0);
  325.     
  326.       if(do_sysop_command(command))
  327.       {
  328.         menu_done=1;
  329.         amount=0;
  330.       }
  331.       
  332.       switch(command)
  333.       {
  334.         case '?':
  335.         case CO:
  336.           CLS();
  337.           printfile("SCONFIG.HLP");
  338.           pausescr();
  339.           
  340.           menu_done=1;
  341.           amount=0;
  342.           break;
  343.       
  344.         case COMMAND_DOWN:
  345.           undrawscan(pos, type ? is_inscan(top+pos) :
  346.              qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  347.           ++pos;
  348.           if(pos>=amount)
  349.             pos=0;
  350.           drawscan(pos, type ? is_inscan(top+pos) :
  351.               qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  352.           redraw=0;
  353.           break;
  354.         
  355.         case COMMAND_UP:
  356.           undrawscan(pos, type ? is_inscan(top+pos) :
  357.               qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  358.           if(!pos)
  359.             pos=amount-1;
  360.           else
  361.             --pos;
  362.           drawscan(pos, type ? is_inscan(top+pos) :
  363.               qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  364.           redraw=0;
  365.           break;
  366.         
  367.         case SPACE: // Toggle
  368.           if(type==0)
  369.             qsc_q[usub[top+pos].subnum/32] ^= (1L<<(usub[top+pos].subnum%32));
  370.           else
  371.           {
  372.             int this_dir, sysdir=0;
  373.             int ad;
  374.             
  375.             // Keep the program from flipping out if there is a dir 0 present
  376.             if(strcmp(udir[0].keys,"0")==0)
  377.               sysdir=1;
  378.             
  379.             for (this_dir=0; (this_dir<num_dirs); this_dir++) 
  380.             {
  381.               char s[50];
  382.               
  383.               sprintf(s, "%d", sysdir ? top+pos : top+pos+1);
  384.               if(!strcmp(s, udir[this_dir].keys))
  385.               {
  386.                 ad=udir[this_dir].subnum;
  387.                 qsc_n[ad/32] ^= (1L<<(ad%32));
  388.               }
  389.             }
  390.           }
  391.           drawscan(pos, type ? is_inscan(top+pos) :
  392.               qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  393.           redraw=0;
  394.           break;
  395.           
  396.         case EXECUTE:
  397.           if(!useconf && side_pos > 5)
  398.             side_pos+=2;
  399.  
  400.  
  401.           switch(side_pos)
  402.           {
  403.             case 0: // Next
  404.               top+=amount;
  405.               
  406.               if(type==0)
  407.               {
  408.                 if(top>=num_subs)
  409.                   top=0;
  410.               }
  411.               else
  412.               {
  413.                 if(top>=num_dirs)
  414.                   top=0;
  415.               }
  416.               
  417.               pos=0;
  418.               menu_done=1;
  419.               amount=0;
  420.               break;  
  421.             
  422.             case 1: // Prev
  423.               
  424.               if(top > thisuser.screenlines-4)
  425.                 top-=thisuser.screenlines-4;
  426.               else
  427.                 top=0;
  428.                   
  429.               pos=0;
  430.               menu_done=1;
  431.               amount=0;
  432.               break;
  433.               
  434.             case 2: // Toggle Sub
  435.               if(type==0)
  436.                 qsc_q[usub[top+pos].subnum/32] ^= (1L<<(usub[top+pos].subnum%32));
  437.               else
  438.               {
  439.                 int this_dir, sysdir=0;
  440.                 int ad;
  441.                 
  442.                 // Keep the program from flipping out if there is a dir 0 present
  443.                 if(strcmp(udir[0].keys,"0")==0)
  444.                   sysdir=1;
  445.                 
  446.                 for (this_dir=0; (this_dir<num_dirs); this_dir++) 
  447.                 {
  448.                   char s[50];
  449.                   
  450.                   sprintf(s, "%d", sysdir ? top+pos : top+pos+1);
  451.                   if(!strcmp(s, udir[this_dir].keys))
  452.                   {
  453.                     ad=udir[this_dir].subnum;
  454.                     qsc_n[ad/32] ^= (1L<<(ad%32));
  455.                   }
  456.                 }
  457.               }
  458.               drawscan(pos, type ? is_inscan(top+pos) :
  459.                    qsc_q[usub[top+pos].subnum/32]&(1L<<(usub[top+pos].subnum%32)));
  460.               redraw=0;
  461.               break;
  462.               
  463.             case 3: // Clear all
  464.               if(type==0)
  465.               {
  466.                 int this_sub;
  467.                 for(this_sub=0; this_sub<num_subs; this_sub++) 
  468.                 {
  469.                   if(qsc_q[usub[this_sub].subnum/32]&(1L<<(usub[this_sub].subnum%32)))
  470.                     qsc_q[usub[this_sub].subnum/32]^=(1L<<(usub[this_sub].subnum%32));
  471.                 }
  472.               }
  473.               else
  474.               {
  475.                 int this_dir;
  476.                 for(this_dir=0; this_dir<num_dirs; this_dir++) 
  477.                 {
  478.                   if(qsc_n[udir[this_dir].subnum/32]&(1L<<(udir[this_dir].subnum%32)))
  479.                     qsc_n[udir[this_dir].subnum/32] ^= 1L<<(udir[this_dir].subnum%32);
  480.                 }
  481.               }
  482.               pos=0;
  483.               menu_done=1;
  484.               amount=0;
  485.               break;
  486.               
  487.             case 4: // Set all on
  488.               if(type==0)
  489.               {
  490.                 int this_sub;
  491.                 for(this_sub=0; this_sub<num_subs; this_sub++) 
  492.                 {
  493.                   if(!(qsc_q[usub[this_sub].subnum/32]&(1L<<(usub[this_sub].subnum%32))))
  494.                     qsc_q[usub[this_sub].subnum/32]^=(1L<<(usub[this_sub].subnum%32));
  495.                 }
  496.               }
  497.               else
  498.               {
  499.                 int this_dir;
  500.                 for(this_dir=0; this_dir<num_dirs; this_dir++) 
  501.                 {
  502.                   if(!(qsc_n[udir[this_dir].subnum/32]&(1L<<(udir[this_dir].subnum%32))))
  503.                     qsc_n[udir[this_dir].subnum/32] ^= 1L<<(udir[this_dir].subnum%32);
  504.                 }
  505.               }
  506.               pos=0;
  507.               menu_done=1;
  508.               amount=0;
  509.               break;
  510.               
  511.             case 5:  // Read dir, or list files
  512.               if(type==0)
  513.               {
  514.                 int i=0;
  515.                 express=0;
  516.                 expressabort=0;
  517.                 qscan(top+pos, &i);
  518.               }
  519.               else
  520.               {
  521.                 int i=curdir;
  522.                 curdir=top+pos;
  523.                 tagging=1;
  524.                 listfiles();
  525.                 tagging=0;
  526.                 curdir=i;
  527.               }
  528.               menu_done=1;
  529.               amount=0;
  530.  
  531.               break;
  532.  
  533.             case 6: // { conf
  534.               if (okconf(&thisuser)) 
  535.               {
  536.                 if(type==0)
  537.                 {
  538.                   if(curconfsub>0)
  539.                     --curconfsub;
  540.                   else
  541.                   { 
  542.                     while ((uconfsub[curconfsub+1].confnum>=0) && (curconfsub<subconfnum-1))
  543.                       ++curconfsub;
  544.                   }
  545.                   setuconf(CONF_SUBS, curconfsub, -1);
  546.                 }
  547.                 else
  548.                 {
  549.                   if(curconfdir>0)
  550.                     --curconfdir;
  551.                   else 
  552.                   {
  553.                     while ((uconfdir[curconfdir+1].confnum>=0) && (curconfdir<dirconfnum-1))
  554.                       ++curconfdir;
  555.                   }
  556.                   setuconf(CONF_DIRS, curconfdir, -1);
  557.                 }
  558.                 
  559.                 pos=0;
  560.                 menu_done=1;
  561.                 amount=0;
  562.               }
  563.  
  564.               
  565.               break;
  566.               
  567.             case 7: // } conf
  568.               if (okconf(&thisuser)) 
  569.               {
  570.                 if(type==0)
  571.                 {
  572.                   if ((curconfsub<subconfnum-1) && (uconfsub[curconfsub+1].confnum>=0))
  573.                     ++curconfsub;
  574.                   else
  575.                     curconfsub=0;
  576.                   setuconf(CONF_SUBS, curconfsub, -1);
  577.                 }
  578.                 else
  579.                 {
  580.                   if ((curconfdir<dirconfnum-1) && (uconfdir[curconfdir+1].confnum>=0))
  581.                     ++curconfdir;
  582.                   else
  583.                     curconfdir=0;
  584.                   setuconf(CONF_DIRS, curconfdir, -1);
  585.                 }
  586.                 pos=0;
  587.                 menu_done=1;
  588.                 amount=0;
  589.               }
  590.  
  591.               break;
  592.               
  593.               
  594.             case 8: // Quit
  595.               menu_done=1;
  596.               done=1;
  597.               break;
  598.               
  599.             case 9: // ? Help
  600.               CLS();
  601.               printfile("SCONFIG.HLP");
  602.               pausescr();
  603.               
  604.               menu_done=1;
  605.               amount=0;
  606.  
  607.               if(!useconf)
  608.                 side_pos-=2;
  609.               break;
  610.           }
  611.           
  612.           break;
  613.         
  614.         case GET_OUT:
  615.           menu_done=1;
  616.           done=1;
  617.           break;
  618.         
  619.       }
  620.     }
  621.   }
  622.   
  623.   lines_listed=0;
  624.   nl();
  625.   
  626.   free_2d(menu_items);
  627. }
  628.  
  629.  
  630.  
  631. void drawscan(int filepos, long tagged)
  632. {
  633.   int max_lines;
  634.  
  635. #ifdef MAX_SCREEN_LINES_TO_SHOW
  636.   max_lines = (
  637.                 thisuser.screenlines-(4+STOP_LIST)
  638.                 >
  639.                 MAX_SCREEN_LINES_TO_SHOW-(4+STOP_LIST)
  640.                 ?
  641.                 MAX_SCREEN_LINES_TO_SHOW-(4+STOP_LIST)
  642.                 :
  643.                 thisuser.screenlines-(4+STOP_LIST)
  644.               );
  645. #else
  646.   max_lines = thisuser.screenlines-(4+STOP_LIST);
  647. #endif
  648.  
  649.   if(filepos >= max_lines)
  650.     goxy(40, 3 + filepos - max_lines);
  651.   else
  652.     goxy(1, filepos+3);
  653.  
  654.   setc(BLACK+(CYAN<<4));
  655.   npr("[%c]", tagged ? '■' : ' ');
  656.   setc(YELLOW+(BLACK<<4));
  657.   
  658.   if(filepos >= max_lines)
  659.     goxy(41, 3 + filepos - max_lines);
  660.   else
  661.     goxy(2, filepos+3);
  662.  
  663.  
  664.   
  665. }
  666.  
  667. void undrawscan(int filepos, long tagged)
  668. {
  669.   int max_lines;
  670.  
  671. #ifdef MAX_SCREEN_LINES_TO_SHOW
  672.   max_lines =
  673.               (
  674.                 thisuser.screenlines-(4+STOP_LIST)
  675.                 >
  676.                 MAX_SCREEN_LINES_TO_SHOW-(4+STOP_LIST)
  677.                 ?
  678.                 MAX_SCREEN_LINES_TO_SHOW-(4+STOP_LIST)
  679.                 :
  680.                 thisuser.screenlines-(4+STOP_LIST)
  681.               );
  682. #else
  683.   max_lines = thisuser.screenlines-(4+STOP_LIST);
  684. #endif
  685.  
  686.  
  687.   if(filepos >= max_lines)
  688.     goxy(40, 3 + filepos - max_lines);
  689.   else
  690.     goxy(1, filepos+3);
  691.  
  692.  
  693.   npr("7[1%c7]", tagged ? '■' : ' ');
  694. }
  695.  
  696. long is_inscan(int dir)
  697. {
  698.   int this_dir, ad;
  699.   int sysdir=0;
  700.   
  701.   // Keep the program from flipping out if there is a dir 0 present
  702.   if(strcmp(udir[0].keys,"0")==0)
  703.     sysdir=1;
  704.   
  705.   for (this_dir=0; (this_dir<num_dirs); this_dir++) 
  706.   {
  707.     char s[50];
  708.     
  709.     sprintf(s, "%d", sysdir ? dir : dir+1);
  710.     if(!strcmp(s, udir[this_dir].keys))
  711.     {
  712.       ad=udir[this_dir].subnum;
  713.       return(qsc_n[ad/32]&(1L<<ad%32));
  714.     }
  715.   }
  716.   
  717.   return(0);
  718. }
  719.  
  720.  
  721.  
  722. Step 5) FCNS.H
  723.   Either type MAKE FCNS to rebuild or manually add the following function
  724.   definitions to fcns.h at the end of the section for /* file: defaults.c */.
  725.  
  726. void list_config_scan_plus(int first, int *amount, int type);
  727. void config_scan_plus(int type);
  728. void drawscan(int filepos, long tagged);
  729. void undrawscan(int filepos, long tagged);
  730. long is_inscan(int dir);
  731.   
  732.   
  733. 6) Recompile
  734.   Please report all bugs you may find.
  735.   
  736.   
  737. 7) Help advertise a half way decent mod, tell everyone on modnet to get Insane.
  738.  
  739.  
  740. ─═════════════════──════════════─────════════─═══════════════───══════════─═══
  741.      
  742.      
  743.  
  744. ' Void this
  745. ' Real idiots think that real programmers only use one tool
  746.  
  747.  
  748. Look for more good mods from the Asylum group...
  749.  
  750.  
  751.  
  752.