home *** CD-ROM | disk | FTP | other *** search
/ Mega A/V / mega_av.zip / mega_av / SOUNDUTL / MUSIQUE.ZIP / SOURCE.ZIP / WINDOW.C < prev    next >
C/C++ Source or Header  |  1991-09-06  |  33KB  |  948 lines
  1. /* Warning! This C source contains extended characters! */
  2.  
  3. #include <dos.h>
  4. #include <bios.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <musique.h>
  8. #include <window.e>
  9.  
  10. int coloroutline;
  11. int colortitle;
  12. /* colors of unpicked/picked menu items */
  13. int coloritem;
  14. int colorpicked;
  15.  
  16. /* background color of keyboard cursor */
  17. int colorcurrent;
  18. /* border color and background color of screen */
  19. int colorborder;
  20.  
  21. void mycputs(PARAMETERTYPE *parameter, int x, int y, char text[], int color)
  22. /* Turbo-C doesn't like extended or non-text modes */
  23. /* Turbo-C scrolls the screen too much (lower-right corner) */
  24. /* prints a string on the screen in the desired color */
  25. /* no wrap around ever performed */
  26. {
  27.   union REGS regs;
  28.   int position;
  29.   char c;
  30.  
  31.   position=0;
  32.   x--; y--;
  33.   if (parameter->rawvideo) {
  34.     x<<=1;
  35.     x+=(y*parameter->maxcolumn)<<1;
  36.     while ((c=text[position++])!='\0') {
  37.       pokeb((unsigned)parameter->videosegment,(unsigned)x++,(int)c);
  38.       pokeb((unsigned)parameter->videosegment,(unsigned)x++,color);
  39.     }
  40.   }
  41.   else 
  42.     while ((c=text[position++])!='\0') {
  43.       regs.h.ah=(unsigned)'\x2'; /* set cursor position */
  44.       regs.h.bh=(unsigned)'\x0';
  45.       regs.h.dl=(unsigned char)x++;
  46.       regs.h.dh=(unsigned char)y;
  47.       int86(0x10,®s,®s);
  48.       regs.h.ah=(unsigned)'\x9'; /* print one character */
  49.       regs.h.bh=(unsigned)'\x0';
  50.       regs.x.cx=(unsigned)0x1;
  51.       regs.h.bl=(unsigned char)color;
  52.       regs.h.al=(unsigned)c;
  53.       int86(0x10,®s,®s);
  54.     }
  55. }
  56.  
  57. void myscrollup(PARAMETERTYPE *parameter)
  58. /* scrolls up one line */
  59. {
  60.   union REGS regs;
  61.   int x,y,source,target,RAM;
  62.  
  63.   if (parameter->rawvideo) {
  64.     target=(parameter->maxcolumn<<2)+4;
  65.     source=target+(parameter->maxcolumn<<1);
  66.     for (y=2 ; y<=parameter->maxline-4 ; y++) {
  67.       for (x=2 ; x<=parameter->maxcolumn-3 ; x++) {
  68.         RAM=peek((unsigned)parameter->videosegment,(unsigned)source);
  69.         poke((unsigned)parameter->videosegment,(unsigned)target,RAM);
  70.         source+=2; target+=2;
  71.       }  
  72.       source+=8; target+=8;
  73.     }
  74.     for (x=2 ; x<=parameter->maxcolumn-3 ; x++) {
  75.       pokeb((unsigned)parameter->videosegment,(unsigned)target,' ');
  76.       target+=2;
  77.     }
  78.   }
  79.   else {
  80.     regs.x.ax=(unsigned)0x601;
  81.     regs.h.bh=(unsigned char)colorborder;
  82.     regs.x.cx=(unsigned)0x202;
  83.     regs.h.dl=(unsigned char)(parameter->maxcolumn-3);
  84.     regs.h.dh=(unsigned char)(parameter->maxline-3);
  85.     int86(0x10,®s,®s);
  86.     /* enables high intensity background */
  87.     highbackground();
  88.   }
  89. }
  90.  
  91. void myscrolldown(PARAMETERTYPE *parameter)
  92. /* scrolls down one line */
  93. {
  94.   union REGS regs;
  95.   int x,y,source,target,RAM;
  96.  
  97.   if (parameter->rawvideo) {
  98.     target=(((parameter->maxline-2)*parameter->maxcolumn)<<1)-6;
  99.     source=target-(parameter->maxcolumn<<1);
  100.     for (y=parameter->maxline-3 ; y>=3 ; y--) {
  101.       for (x=2 ; x<=parameter->maxcolumn-3 ; x++) {
  102.         RAM=peek((unsigned)parameter->videosegment,(unsigned)source);
  103.         poke((unsigned)parameter->videosegment,(unsigned)target,RAM);
  104.         source-=2; target-=2;
  105.       }  
  106.       source-=8; target-=8;
  107.     }
  108.     for (x=2 ; x<=parameter->maxcolumn-3 ; x++) {
  109.       pokeb((unsigned)parameter->videosegment,(unsigned)target,' ');
  110.       target-=2;
  111.     }  
  112.   }
  113.   else {
  114.     regs.x.ax=(unsigned)0x701;
  115.     regs.h.bh=(unsigned char)colorborder;
  116.     regs.x.cx=(unsigned)0x202;
  117.     regs.h.dl=(unsigned char)(parameter->maxcolumn-3);
  118.     regs.h.dh=(unsigned char)(parameter->maxline-3);
  119.     int86(0x10,®s,®s);
  120.     /* enables high intensity background */
  121.     highbackground();
  122.   }
  123. }
  124.  
  125. void movecursor(PARAMETERTYPE *parameter)
  126. /* moves the cursor out of the way one line too low */
  127. {
  128.   union REGS regs;
  129.  
  130.   regs.h.ah=(unsigned)'\x2';
  131.   regs.h.bh=(unsigned)'\x0';
  132.   regs.h.dl=(unsigned)'\x0';
  133.   regs.h.dh=(unsigned char)parameter->maxline;
  134.   int86(0x10,®s,®s);
  135. }
  136.  
  137. void printoutline(PARAMETERTYPE *parameter)
  138. /* prints a frame around the screen and the title */
  139. /* leaves cursor around */
  140. {
  141.   int column,line;
  142.  
  143.   mycputs(parameter,1,1,"┌",coloroutline|colorborder);
  144.   for (column=2 ; column<parameter->maxcolumn ; column++)
  145.     mycputs(parameter,column,1,"─",coloroutline|colorborder);
  146.   mycputs(parameter,parameter->maxcolumn,1,"┐",coloroutline|colorborder);
  147.   for (line=2 ; line<parameter->maxline ; line++) {
  148.     mycputs(parameter,1,line,"│",coloroutline|colorborder);
  149.     mycputs(parameter,parameter->maxcolumn,line,"│",coloroutline|colorborder);
  150.   }
  151.   mycputs(parameter,1,parameter->maxline,"└",coloroutline|colorborder);
  152.   for (column=2 ; column<parameter->maxcolumn ; column++)
  153.     mycputs(parameter,column,parameter->maxline,"─",coloroutline|colorborder);
  154.   mycputs(parameter,parameter->maxcolumn,parameter->maxline,"┘",
  155.           coloroutline|colorborder);
  156.   switch (language) {
  157.     case FRENCH:column=(parameter->maxcolumn-strlen(FTITLE)+3)/2;
  158.                 mycputs(parameter,column,1,FTITLE,colortitle|colorborder);
  159.                 break;
  160.     case ENGLISH:column=(parameter->maxcolumn-strlen(ETITLE)+3)/2;
  161.                  mycputs(parameter,column,1,ETITLE,colortitle|colorborder);
  162.                  break;
  163.     case GERMAN:column=(parameter->maxcolumn-strlen(GTITLE)+3)/2;
  164.                 mycputs(parameter,column,1,GTITLE,colortitle|colorborder);
  165.                 break;
  166.   }
  167. }
  168.  
  169. void cleverwrapper(PARAMETERTYPE *parameter, int *wrapper, int *column)
  170. /* evens out menu item columns nicely */
  171. /* uses the modulo algorithm taken from the usual line drawing algorithm */
  172. {
  173.   while (*wrapper<parameter->leftcolumn) {
  174.     (*column)++;    
  175.     *wrapper+=parameter->bigcolumn+1;
  176.   }
  177.   *wrapper-=parameter->leftcolumn;
  178. }
  179.  
  180. void putitem(int column, int line, SONGTYPE *song, int color, 
  181.              PARAMETERTYPE *parameter)
  182. /* puts a menu item in the color desired */
  183. /* leaves cursor around */
  184. {
  185.   column++;
  186.   if (parameter->verbose) {
  187.     mycputs(parameter,column,line,song->diskname,color);
  188.     column+=DISKNAMELENGTH+1;
  189.     mycputs(parameter,column,line,song->score,color);
  190.     column+=SCORELENGTH+1;
  191.   }
  192.   if (parameter->verbose || parameter->DOS) {
  193.     mycputs(parameter,column,line,song->DOSname,color);
  194.     column+=DOSNAMELENGTH+1;
  195.   }
  196.   if (parameter->verbose || !parameter->DOS)
  197.     mycputs(parameter,column,line,song->songname,color);
  198. }
  199.  
  200. void getbig(SONGSTYPE *songs, PARAMETERTYPE *parameter, int *bcolumn, 
  201.             int *bline)
  202. /* finds the coordinates of the current song in the menu window */
  203. {
  204.   *bcolumn=(songs->songcurrent-1)/parameter->hugeline+1;
  205.   *bline=songs->songcurrent-songs->songcorner-
  206.          (*bcolumn-1)*parameter->hugeline+1;
  207. }
  208.  
  209. int getmouseptr(SONGSTYPE *songs, PARAMETERTYPE *parameter, 
  210.                 MOUSETYPE *mousedata)
  211. /* finds the closest song name to the mouse cursor */
  212. {
  213.   int oldcolumn,column,halfcolumn,wrapper;
  214.   int bline,bcolumn; 
  215.   int songlimit;
  216.   int mouseptr;
  217.  
  218.   bline=mousedata->y-2;
  219.   if (bline<1) bline=1;
  220.   else 
  221.     if (bline>parameter->bigline) bline=parameter->bigline;
  222.   column=3;
  223.   wrapper=0;
  224.   bcolumn=1;
  225.   cleverwrapper(parameter,&wrapper,&column);
  226.   column+=parameter->itemlength;
  227.   oldcolumn=column;
  228.   cleverwrapper(parameter,&wrapper,&column);
  229.   halfcolumn=(column+oldcolumn)/2;
  230.   while (halfcolumn<=mousedata->x) {
  231.     column+=parameter->itemlength;
  232.     oldcolumn=column;
  233.     cleverwrapper(parameter,&wrapper,&column);
  234.     halfcolumn=(column+oldcolumn)/2;
  235.     bcolumn++;
  236.   }
  237.   if (bcolumn>parameter->bigcolumn) bcolumn=parameter->bigcolumn;
  238.   songlimit=bcolumn*parameter->hugeline;
  239.   mouseptr=songs->songcorner+(bcolumn-1)*parameter->hugeline+bline-1;
  240.   if (mouseptr>songlimit) mouseptr=songlimit;
  241.   if (mouseptr>songs->songnumber) mouseptr=songs->songnumber;
  242.   return(mouseptr);
  243. }
  244.  
  245. void putcurrent(SONGSTYPE *songs, PARAMETERTYPE *parameter, int color)
  246. /* puts the current song in the color desired */
  247. /* leaves cursor around */
  248. {
  249.   int line,column; /* screen coordinates */
  250.   int wrapper; /* used for clever column spacing */
  251.   int bline,bcolumn;
  252.  
  253.   getbig(songs,parameter,&bcolumn,&bline);
  254.   line=bline+2;
  255.   column=3;
  256.   wrapper=0;
  257.   cleverwrapper(parameter,&wrapper,&column);
  258.   while (--bcolumn>0) {
  259.     column+=parameter->itemlength;
  260.     cleverwrapper(parameter,&wrapper,&column);
  261.   }
  262.   putitem(column,line,&(songs->song[songs->songcurrent]),color,parameter);
  263. }
  264.  
  265. void unputcurrent(SONGSTYPE *songs, PARAMETERTYPE *parameter)
  266. /* unputs the current song */
  267. /* leaves cursor around */
  268. {
  269.   if (songs->song[songs->songcurrent].picked!=0) 
  270.     putcurrent(songs,parameter,colorpicked|colorborder);
  271.   else
  272.     putcurrent(songs,parameter,coloritem|colorborder);
  273. }
  274.  
  275. void changecurrent(SONGSTYPE *songs, PARAMETERTYPE *parameter, 
  276.                    MOUSETYPE *mousedata, int songptr)
  277. /* changes the current song and updates the menu window */
  278. /* moves away cursor */
  279. {
  280.   int mouseptr,intheway;
  281.  
  282.   if (songs->songcurrent!=songptr) {
  283.     if (parameter->mouse) { 
  284.       mouseptr=getmouseptr(songs,parameter,mousedata);
  285.       intheway=((mouseptr==songptr) || (mouseptr==songs->songcurrent)); 
  286.     }
  287.     else intheway=FALSE;
  288.     if (intheway)
  289.       mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  290.     unputcurrent(songs,parameter);
  291.     songs->songcurrent=songptr;
  292.     if (songs->song[songptr].picked!=0) 
  293.       putcurrent(songs,parameter,colorpicked|colorcurrent);
  294.     else
  295.       putcurrent(songs,parameter,coloritem|colorcurrent);
  296.     if (intheway)
  297.       mouseshow(mousedata->x,mousedata->y,&(mousedata->c),&(mousedata->color));
  298.     movecursor(parameter);
  299.   }
  300.   else bellit();
  301. }
  302.  
  303. void printarrows(SONGSTYPE *songs, PARAMETERTYPE *parameter)
  304. /* displays PgUp and PgDn */
  305. /* moves away cursor */
  306. {
  307.   int column;
  308.  
  309.   if (songs->songcorner>1)
  310.     mycputs(parameter,parameter->maxcolumn-strlen(PGUP),1,PGUP,
  311.             coloroutline|colorborder);
  312.   else
  313.     for (column=1 ; column<=strlen(PGUP) ; column++)
  314.       mycputs(parameter,parameter->maxcolumn-column,1,"─",
  315.               coloroutline|colorborder);
  316.   if ((songs->songcorner+parameter->bigline-1)<parameter->hugeline)
  317.    mycputs(parameter,parameter->maxcolumn-strlen(PGDN),parameter->maxline,PGDN,
  318.            coloroutline|colorborder);
  319.   else
  320.     for (column=1 ; column<=strlen(PGUP) ; column++)
  321.       mycputs(parameter,parameter->maxcolumn-column,parameter->maxline,"─",
  322.               coloroutline|colorborder);
  323.   movecursor(parameter);
  324. }
  325.  
  326. void printsongs(SONGSTYPE *songs, PARAMETERTYPE *parameter, 
  327.                 MOUSETYPE *mousedata)
  328. /* displays all the menu items and PgUp-PgDn */
  329. /* moves away cursor */
  330. {
  331.   int bline,bcolumn; /* item coordinates */
  332.   int line,column; /* screen coordinates */
  333.   int songptr,songlimit;
  334.   int wrapper; /* used for clever column spacing */
  335.  
  336.   if (parameter->mouse)
  337.     mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  338.   wrapper=0;
  339.   column=3;
  340.   songlimit=parameter->hugeline;
  341.   for (bcolumn=1 ; bcolumn<=parameter->bigcolumn ; bcolumn++) {
  342.     songptr=songs->songcorner+(bcolumn-1)*parameter->hugeline;
  343.     cleverwrapper(parameter,&wrapper,&column);
  344.     for (line=3 , bline=1 ; bline<=parameter->bigline ; line++ , bline++)
  345.       if (songptr<=songlimit)
  346.         if (songptr==songs->songcurrent) 
  347.           if (songs->song[songptr].picked!=0)
  348.             putitem(column,line,&(songs->song[songptr++]),
  349.                     colorpicked|colorcurrent,parameter);
  350.           else
  351.             putitem(column,line,&(songs->song[songptr++]),
  352.                     coloritem|colorcurrent,parameter);
  353.         else 
  354.           if (songs->song[songptr].picked!=0)
  355.             putitem(column,line,&(songs->song[songptr++]),
  356.                     colorpicked|colorborder,parameter);
  357.           else
  358.             putitem(column,line,&(songs->song[songptr++]),
  359.                     coloritem|colorborder,parameter);
  360.       else
  361.         putitem(column,line,&(songs->song[0]),coloritem|colorborder,parameter);
  362.     column+=parameter->itemlength;
  363.     songlimit+=parameter->hugeline;
  364.     /* small check for the last menu item column sometime incomplete */
  365.     if (songlimit>songs->songnumber) songlimit=songs->songnumber;
  366.   }
  367.   if (parameter->mouse)
  368.     mouseshow(mousedata->x,mousedata->y,&(mousedata->c),&(mousedata->color));
  369.   printarrows(songs,parameter);
  370. }
  371.  
  372. void dopgup(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  373. {
  374.   int bcolumn,bline; 
  375.  
  376.   if (songs->songcorner>1) {
  377.     /* move up half a screen */
  378.     songs->songcorner-=parameter->bigline/2;
  379.     /* make sure upper-left item exists */
  380.     if (songs->songcorner<1) songs->songcorner=1;
  381.     /* make sure current song is on the screen */
  382.     getbig(songs,parameter,&bcolumn,&bline);
  383.     if (bline>parameter->bigline) songs->songcurrent=songs->songcorner;
  384.     printsongs(songs,parameter,mousedata);
  385.   }
  386.   else 
  387.     /* can't scroll */
  388.     changecurrent(songs,parameter,mousedata,1);
  389. }
  390.  
  391. void dopgdn(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  392. {
  393.   int bcolumn,bline; 
  394.  
  395.   if ((songs->songcorner+parameter->bigline-1)<parameter->hugeline) {
  396.     /* move down half a screen */
  397.     songs->songcorner+=parameter->bigline/2;
  398.     /* no need to make sure upper-left item exists, it always does */
  399.     /* make sure current song is on the screen */
  400.     getbig(songs,parameter,&bcolumn,&bline);
  401.     if (bline<1) songs->songcurrent=songs->songcorner;
  402.     printsongs(songs,parameter,mousedata);
  403.   }
  404.   else 
  405.     /* can't scroll */
  406.     changecurrent(songs,parameter,mousedata,songs->songnumber);
  407. }
  408.  
  409. void doleft(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  410. {
  411.   int songptr;
  412.  
  413.   songptr=songs->songcurrent-parameter->hugeline;
  414.   if (songptr>=1) changecurrent(songs,parameter,mousedata,songptr);
  415.   else bellit();
  416. }
  417.  
  418. void doright(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  419. {
  420.   int songptr;
  421.  
  422.   songptr=songs->songcurrent+parameter->hugeline;
  423.   if (songptr<=songs->songnumber)
  424.     changecurrent(songs,parameter,mousedata,songptr);
  425.   else bellit();
  426. }
  427.  
  428. void doup(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  429. {
  430.   int wrapper; /* used for clever column spacing */
  431.   int bcolumn,bline;
  432.   int songlimit; /* first song of current column */
  433.   int songptr,column;
  434.  
  435.   getbig(songs,parameter,&bcolumn,&bline);
  436.   songlimit=parameter->hugeline*(bcolumn-1)+1;
  437.   if (bline==1) {
  438.     /* goes off screen */
  439.     if (songs->songcurrent==songlimit)
  440.       /* can't scroll vertically */
  441.       bellit();
  442.     else {
  443.       /* can scroll vertically */
  444.       if (parameter->mouse)
  445.         mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  446.       unputcurrent(songs,parameter);
  447.       myscrolldown(parameter);
  448.       songs->songcorner--;
  449.       songs->songcurrent--;
  450.       wrapper=0;
  451.       column=3;
  452.       songptr=songs->songcorner;
  453.       cleverwrapper(parameter,&wrapper,&column);
  454.       for (bcolumn=1 ; bcolumn<=parameter->bigcolumn ; bcolumn++) {
  455.         if (songptr==songs->songcurrent) 
  456.           if (songs->song[songptr].picked!=0) 
  457.             putitem(column,3,&(songs->song[songptr]),
  458.                     colorpicked|colorcurrent,parameter);
  459.           else
  460.             putitem(column,3,&(songs->song[songptr]),
  461.                     coloritem|colorcurrent,parameter);
  462.         else
  463.           if (songs->song[songptr].picked!=0)
  464.             putitem(column,3,&(songs->song[songptr]),
  465.                     colorpicked|colorborder,parameter);
  466.           else
  467.             putitem(column,3,&(songs->song[songptr]),
  468.                     coloritem|colorborder,parameter);
  469.         songptr+=parameter->hugeline;
  470.         if (songptr>songs->songnumber) break; /* unlikely though for up move */
  471.         column+=parameter->itemlength;
  472.         cleverwrapper(parameter,&wrapper,&column);
  473.       }
  474.       if (parameter->mouse)
  475.         mouseshow(mousedata->x,mousedata->y,&(mousedata->c),
  476.                   &(mousedata->color));
  477.       printarrows(songs,parameter);
  478.     }
  479.   }
  480.   else
  481.     /* stays on screen */
  482.     changecurrent(songs,parameter,mousedata,(songs->songcurrent-1));
  483. }
  484.  
  485. void dodown(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  486. {
  487.   int wrapper; /* used for clever column spacing */
  488.   int bline,bcolumn;
  489.   int songlimit; /* last song of current column */
  490.   int songptr,column;
  491.  
  492.   getbig(songs,parameter,&bcolumn,&bline);
  493.   songlimit=parameter->hugeline*bcolumn;
  494.   if (songlimit>songs->songnumber) songlimit=songs->songnumber;
  495.   if (bline==parameter->bigline) {
  496.     /* goes off screen */
  497.     if (songs->songcurrent==songlimit)
  498.       /* can't scroll vertically */
  499.       bellit();
  500.     else {
  501.       /* can scroll vertically */
  502.       if (parameter->mouse)
  503.         mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  504.       unputcurrent(songs,parameter);
  505.       myscrollup(parameter);
  506.       songs->songcorner++;
  507.       songs->songcurrent++;
  508.       wrapper=0;
  509.       column=3;
  510.       songptr=songs->songcorner+parameter->bigline-1;
  511.       cleverwrapper(parameter,&wrapper,&column);
  512.       for (bcolumn=1 ; bcolumn<=parameter->bigcolumn ; bcolumn++) {
  513.         if (songptr<=songs->songnumber)
  514.           if (songptr==songs->songcurrent) 
  515.             if (songs->song[songptr].picked!=0) 
  516.               putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  517.                       colorpicked|colorcurrent,parameter);
  518.             else
  519.               putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  520.                       coloritem|colorcurrent,parameter);
  521.           else
  522.             if (songs->song[songptr].picked!=0)
  523.               putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  524.                       colorpicked|colorborder,parameter);
  525.             else
  526.               putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  527.                       coloritem|colorborder,parameter);
  528.         songptr+=parameter->hugeline;
  529.         if (songptr>songs->songnumber) break; /* likely for down move */
  530.         column+=parameter->itemlength;
  531.         cleverwrapper(parameter,&wrapper,&column);
  532.       }
  533.       if (parameter->mouse)
  534.         mouseshow(mousedata->x,mousedata->y,&(mousedata->c),
  535.                   &(mousedata->color));
  536.       printarrows(songs,parameter);
  537.     }
  538.   }
  539.   else 
  540.     /* stays on screen */
  541.     if (songs->songcurrent<songlimit) 
  542.       changecurrent(songs,parameter,mousedata,(songs->songcurrent+1));
  543.     else bellit();
  544. }
  545.  
  546. void dohome(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  547. {
  548.   int bcolumn,bline; 
  549.  
  550.   if (songs->songcorner!=1) {
  551.     songs->songcorner=1;
  552.     /* make sure current song is on the screen */
  553.     getbig(songs,parameter,&bcolumn,&bline);
  554.     if (bline>parameter->bigline) songs->songcurrent=1;
  555.     printsongs(songs,parameter,mousedata);
  556.   }
  557.   else
  558.     /* can't scroll */
  559.     changecurrent(songs,parameter,mousedata,1);
  560. }
  561.  
  562. void doend(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  563. {
  564.   int bcolumn,bline; 
  565.  
  566.   if (songs->songcorner!=(parameter->hugeline-parameter->bigline+1)) {
  567.     songs->songcorner=parameter->hugeline-parameter->bigline+1;
  568.     /* make sure current song is on the screen */
  569.     getbig(songs,parameter,&bcolumn,&bline);
  570.     if (bline<1) songs->songcurrent=songs->songnumber;
  571.     printsongs(songs,parameter,mousedata);
  572.   }
  573.   else
  574.     /* can't scroll */
  575.     changecurrent(songs,parameter,mousedata,songs->songnumber);
  576. }
  577.  
  578. void doatslash(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  579. {
  580.   int songptr;
  581.  
  582.   songs->songpriority=0;
  583.   /* use current menu item as a basis for reversing statuses */
  584.   if (songs->song[songs->songcurrent].picked!=0)
  585.     for (songptr=1 ; songptr<=songs->songnumber ; songptr++)
  586.       songs->song[songptr].picked=0;
  587.   else
  588.     for (songptr=1 ; songptr<=songs->songnumber ; songptr++)
  589.       songs->song[songptr].picked=++songs->songpriority;
  590.   printsongs(songs,parameter,mousedata);
  591. }
  592.  
  593. void dostar(SONGSTYPE *songs) 
  594. { 
  595.   int songptr,songlimit,songnext,songsearch;
  596.  
  597.   if (songs->songpriority==0) bellit();
  598.   else {
  599.     songs->songpriority=0;
  600.     for (songptr=1 ; songptr<=songs->songnumber ; songptr++)
  601.       if (songs->song[songptr].picked!=0) {
  602.         songs->songpriority++;
  603.         songs->song[songptr].picked=-1;
  604.       }
  605.     for (songlimit=songs->songpriority ; songlimit>=1 ; songlimit--) {
  606.       songnext=1+(rand() % songlimit);
  607.       songsearch=0;
  608.       for (songptr=1 ; songptr<=songnext ; songptr++) {
  609.         songsearch++;
  610.         while (songs->song[songsearch].picked>=0) songsearch++;
  611.       }
  612.       songs->song[songsearch].picked=songlimit;
  613.     }
  614.   }
  615. }
  616.  
  617. void dospgup(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  618. {
  619.   int songptr;
  620.  
  621.   songptr=songs->songcorner+(parameter->bigcolumn-1)*parameter->hugeline;
  622.   changecurrent(songs,parameter,mousedata,songptr);
  623. }
  624.  
  625. void dospgdn(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  626. {
  627.   int songptr;
  628.  
  629.   songptr=songs->songcorner+(parameter->bigcolumn-1)*parameter->hugeline+
  630.           parameter->bigline-1;
  631.   if (songptr>songs->songnumber) songptr=songs->songnumber;
  632.   changecurrent(songs,parameter,mousedata,songptr);
  633. }
  634.  
  635. void dosleft(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  636. {
  637.   int songptr;
  638.   int bline,bcolumn;
  639.  
  640.   getbig(songs,parameter,&bcolumn,&bline);
  641.   songptr=songs->songcorner+bline-1;
  642.   changecurrent(songs,parameter,mousedata,songptr);
  643. }
  644.  
  645. void dosright(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  646. {
  647.   int songptr;
  648.   int bline,bcolumn;
  649.  
  650.   getbig(songs,parameter,&bcolumn,&bline);
  651.   songptr=songs->songcorner+(parameter->bigcolumn-1)*parameter->hugeline+
  652.           bline-1;
  653.   if (songptr>songs->songnumber) songptr-=parameter->hugeline;
  654.   changecurrent(songs,parameter,mousedata,songptr);
  655. }
  656.  
  657. void dosup(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  658. {
  659.   int songptr;
  660.   int bline,bcolumn;
  661.  
  662.   getbig(songs,parameter,&bcolumn,&bline);
  663.   songptr=songs->songcorner+(bcolumn-1)*parameter->hugeline;
  664.   changecurrent(songs,parameter,mousedata,songptr);
  665. }
  666.  
  667. void dosdown(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  668. {
  669.   int songptr;
  670.   int bline,bcolumn;
  671.  
  672.   getbig(songs,parameter,&bcolumn,&bline);
  673.   songptr=songs->songcorner+(bcolumn-1)*parameter->hugeline+
  674.           parameter->bigline-1;
  675.   if (songptr>(parameter->hugeline*bcolumn)) 
  676.     songptr=parameter->hugeline*bcolumn;
  677.   if (songptr>songs->songnumber) songptr=songs->songnumber;
  678.   changecurrent(songs,parameter,mousedata,songptr);
  679. }
  680.  
  681. void doshome(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  682. {
  683.   changecurrent(songs,parameter,mousedata,songs->songcorner);
  684. }
  685.  
  686. void dosend(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  687. {
  688.   int songptr;
  689.  
  690.   songptr=songs->songcorner+parameter->bigline-1;
  691.   if (songptr>parameter->hugeline) songptr=parameter->hugeline;
  692.   changecurrent(songs,parameter,mousedata,songptr);
  693. }
  694.  
  695. void doscenter(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  696. {
  697.   int songptr,songlimit;
  698.   int bcolumn;
  699.  
  700.   bcolumn=(parameter->bigcolumn+1)/2;
  701.   songptr=songs->songcorner+parameter->hugeline*(bcolumn-1);
  702.   songlimit=songptr+parameter->bigline-1;
  703.   if (songlimit>(parameter->hugeline*bcolumn)) 
  704.     songlimit=parameter->hugeline*bcolumn;
  705.   songptr=(songptr+songlimit)/2;
  706.   changecurrent(songs,parameter,mousedata,songptr);
  707. }
  708.  
  709. void dospace(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  710. {
  711.   int intheway,mouseptr;
  712.  
  713.   if (parameter->mouse) { 
  714.     mouseptr=getmouseptr(songs,parameter,mousedata);
  715.     intheway=(mouseptr==songs->songcurrent);
  716.   }
  717.   else intheway=FALSE;
  718.   if (intheway)
  719.     mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  720.   if (songs->song[songs->songcurrent].picked!=0) {
  721.     songs->song[songs->songcurrent].picked=0;
  722.     putcurrent(songs,parameter,coloritem|colorcurrent);
  723.   }
  724.   else {
  725.     songs->song[songs->songcurrent].picked=++songs->songpriority;
  726.     putcurrent(songs,parameter,colorpicked|colorcurrent);
  727.   }
  728.   if (intheway)
  729.     mouseshow(mousedata->x,mousedata->y,&(mousedata->c),&(mousedata->color));
  730.   movecursor(parameter);
  731. }
  732.  
  733. void domspace(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  734. {
  735.   int mouseptr,tempcurrent;
  736.  
  737.   mouseptr=getmouseptr(songs,parameter,mousedata);
  738.   mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  739.   if (songs->song[mouseptr].picked!=0) 
  740.     songs->song[mouseptr].picked=0;
  741.   else 
  742.     songs->song[mouseptr].picked=++songs->songpriority;
  743.   if (mouseptr==songs->songcurrent)
  744.     if (songs->song[mouseptr].picked!=0) 
  745.       putcurrent(songs,parameter,colorpicked|colorcurrent);
  746.     else 
  747.       putcurrent(songs,parameter,coloritem|colorcurrent);
  748.   else {
  749.     tempcurrent=songs->songcurrent;
  750.     songs->songcurrent=mouseptr;
  751.     if (songs->song[mouseptr].picked!=0) 
  752.       putcurrent(songs,parameter,colorpicked|colorborder);
  753.     else 
  754.       putcurrent(songs,parameter,coloritem|colorborder);
  755.     songs->songcurrent=tempcurrent;
  756.   }
  757.   mouseshow(mousedata->x,mousedata->y,&(mousedata->c),&(mousedata->color));
  758.   movecursor(parameter);
  759. }
  760.  
  761. void domup(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  762. {
  763.   int wrapper; /* used for clever column spacing */
  764.   int bcolumn,bline;
  765.   int songptr,column;
  766.   struct time timep;
  767.   int time,oldtime;
  768.  
  769.   if (songs->songcorner!=1) {
  770.     gettime(&timep);
  771.     oldtime=((int)timep.ti_hund)+100*((int)timep.ti_sec);
  772.     mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  773.     getbig(songs,parameter,&bcolumn,&bline);
  774.     if (bline==parameter->bigline) {
  775.       unputcurrent(songs,parameter);
  776.       songs->songcurrent--;
  777.     }
  778.     songs->songcorner--;
  779.     myscrolldown(parameter);
  780.     if (bline==parameter->bigline)
  781.       if (songs->song[songs->songcurrent].picked!=0)
  782.         putcurrent(songs,parameter,colorpicked|colorcurrent);
  783.       else
  784.         putcurrent(songs,parameter,coloritem|colorcurrent);
  785.     wrapper=0;
  786.     column=3;
  787.     songptr=songs->songcorner;
  788.     cleverwrapper(parameter,&wrapper,&column);
  789.     for (bcolumn=1 ; bcolumn<=parameter->bigcolumn ; bcolumn++) {
  790.       if (songptr==songs->songcurrent) 
  791.         if (songs->song[songptr].picked!=0) 
  792.           putitem(column,3,&(songs->song[songptr]),
  793.                   colorpicked|colorcurrent,parameter);
  794.         else
  795.           putitem(column,3,&(songs->song[songptr]),
  796.                   coloritem|colorcurrent,parameter);
  797.       else
  798.         if (songs->song[songptr].picked!=0)
  799.           putitem(column,3,&(songs->song[songptr]),
  800.                   colorpicked|colorborder,parameter);
  801.         else
  802.           putitem(column,3,&(songs->song[songptr]),
  803.                   coloritem|colorborder,parameter);
  804.       songptr+=parameter->hugeline;
  805.       if (songptr>songs->songnumber) break; /* unlikely though for up move */
  806.       column+=parameter->itemlength;
  807.       cleverwrapper(parameter,&wrapper,&column);
  808.     }
  809.     mouseshow(mousedata->x,mousedata->y,&(mousedata->c),&(mousedata->color));
  810.     printarrows(songs,parameter);
  811.     do {
  812.       gettime(&timep);
  813.       time=((int)timep.ti_hund)+100*((int)timep.ti_sec)-oldtime;
  814.       if (time<0) time+=6000;
  815.     } while (time<SCROLLDELAY);
  816.   }
  817. }
  818.  
  819. void domdown(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  820. {
  821.   int wrapper; /* used for clever column spacing */
  822.   int bline,bcolumn;
  823.   int songptr,column;
  824.   struct time timep;
  825.   int time,oldtime;
  826.  
  827.   if ((songs->songcorner+parameter->bigline-1)<parameter->hugeline) {
  828.     gettime(&timep);
  829.     oldtime=((int)timep.ti_hund)+100*((int)timep.ti_sec);
  830.     mousehide(mousedata->x,mousedata->y,mousedata->c,mousedata->color);
  831.     getbig(songs,parameter,&bcolumn,&bline);
  832.     if (bline==1) {
  833.       unputcurrent(songs,parameter);
  834.       songs->songcurrent++;
  835.     }
  836.     songs->songcorner++;
  837.     myscrollup(parameter);
  838.     if (bline==1) 
  839.       if (songs->song[songs->songcurrent].picked!=0)
  840.         putcurrent(songs,parameter,colorpicked|colorcurrent);
  841.       else
  842.         putcurrent(songs,parameter,coloritem|colorcurrent);
  843.     wrapper=0;
  844.     column=3;
  845.     songptr=songs->songcorner+parameter->bigline-1;
  846.     cleverwrapper(parameter,&wrapper,&column);
  847.     for (bcolumn=1 ; bcolumn<=parameter->bigcolumn ; bcolumn++) {
  848.       if (songptr<=songs->songnumber)
  849.         if (songptr==songs->songcurrent) 
  850.           if (songs->song[songptr].picked!=0) 
  851.             putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  852.                     colorpicked|colorcurrent,parameter);
  853.           else
  854.             putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  855.                     coloritem|colorcurrent,parameter);
  856.         else
  857.           if (songs->song[songptr].picked!=0)
  858.             putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  859.                     colorpicked|colorborder,parameter);
  860.           else
  861.             putitem(column,parameter->maxline-2,&(songs->song[songptr]),
  862.                     coloritem|colorborder,parameter);
  863.       songptr+=parameter->hugeline;
  864.       if (songptr>songs->songnumber) break; /* likely for down move */
  865.       column+=parameter->itemlength;
  866.       cleverwrapper(parameter,&wrapper,&column);
  867.     }
  868.     mouseshow(mousedata->x,mousedata->y,&(mousedata->c),&(mousedata->color));
  869.     printarrows(songs,parameter);
  870.     do {
  871.       gettime(&timep);
  872.       time=((int)timep.ti_hund)+100*((int)timep.ti_sec)-oldtime;
  873.       if (time<0) time+=6000;
  874.     } while (time<SCROLLDELAY);
  875.   }
  876. }
  877.  
  878. int picksongs(SONGSTYPE *songs, PARAMETERTYPE *parameter, MOUSETYPE *mousedata)
  879. /* updates the menu */
  880. {
  881.  
  882.   songs->songpriority=0;
  883.   do {
  884.     if (bioskey(1))
  885.       switch (bioskey(0)) {
  886.         case KEYESC:return(TRUE);
  887.         case KEYENTER:return(FALSE);
  888.         case KEYSPACE:dospace(songs,parameter,mousedata);
  889.                       break;
  890.         case KEYPGUP:dopgup(songs,parameter,mousedata);
  891.                      break;
  892.         case KEYPGDN:dopgdn(songs,parameter,mousedata);
  893.                      break;
  894.         case KEYLEFT:doleft(songs,parameter,mousedata);
  895.                      break;
  896.         case KEYRIGHT:doright(songs,parameter,mousedata);
  897.                       break;
  898.         case KEYUP:doup(songs,parameter,mousedata);
  899.                    break;
  900.         case KEYDOWN:dodown(songs,parameter,mousedata);
  901.                      break;
  902.         case KEYHOME:dohome(songs,parameter,mousedata);
  903.                      break;
  904.         case KEYEND:doend(songs,parameter,mousedata);
  905.                     break;
  906.         case KEYATSLASH:doatslash(songs,parameter,mousedata);
  907.                         break;
  908.         case KEYSTAR1:dostar(songs);
  909.                       break;
  910.         case KEYSTAR2:dostar(songs);
  911.                       break;
  912.         case SKEYPGUP:dospgup(songs,parameter,mousedata);
  913.                       break;
  914.         case SKEYPGDN:dospgdn(songs,parameter,mousedata);
  915.                       break;
  916.         case SKEYLEFT:dosleft(songs,parameter,mousedata);
  917.                       break;
  918.         case SKEYRIGHT:dosright(songs,parameter,mousedata);
  919.                        break;
  920.         case SKEYUP:dosup(songs,parameter,mousedata);
  921.                     break;
  922.         case SKEYDOWN:dosdown(songs,parameter,mousedata);
  923.                       break;
  924.         case SKEYHOME:doshome(songs,parameter,mousedata);
  925.                       break;
  926.         case SKEYEND:dosend(songs,parameter,mousedata);
  927.                      break;
  928.         case SKEYCENTER:doscenter(songs,parameter,mousedata);
  929.                         break;
  930.         default:bellit();
  931.                 break;
  932.       } 
  933.     else
  934.       if (parameter->mouse)
  935.         switch (readmouse(songs,parameter,mousedata)) {
  936.           case KEYESC:return(TRUE);
  937.           case KEYENTER:return(FALSE);
  938.           case KEYSPACE:domspace(songs,parameter,mousedata);
  939.                         break;
  940.           case KEYUP:domup(songs,parameter,mousedata);
  941.                      break;
  942.           case KEYDOWN:domdown(songs,parameter,mousedata);
  943.                        break;
  944.           default:break;
  945.         }
  946.   } while (TRUE);
  947. }
  948.