home *** CD-ROM | disk | FTP | other *** search
/ Large Pack of OldSkool DOS MOD Trackers / goattracker_2.70.zip / src / gpattern.c < prev    next >
Encoding:
C/C++ Source or Header  |  2008-04-01  |  32.9 KB  |  1,300 lines
  1. //
  2. // GOATTRACKER v2 pattern editor
  3. //
  4.  
  5. #define GPATTERN_C
  6.  
  7. #include "goattrk2.h"
  8.  
  9. unsigned char notekeytbl1[] = {KEY_Z, KEY_S, KEY_X, KEY_D, KEY_C, KEY_V,
  10.   KEY_G, KEY_B, KEY_H, KEY_N, KEY_J, KEY_M, KEY_COMMA, KEY_L, KEY_COLON};
  11.  
  12. unsigned char notekeytbl2[] = {KEY_Q, KEY_2, KEY_W, KEY_3, KEY_E, KEY_R,
  13.   KEY_5, KEY_T, KEY_6, KEY_Y, KEY_7, KEY_U, KEY_I, KEY_9, KEY_O, KEY_0, KEY_P};
  14.  
  15. unsigned char dmckeytbl[] = {KEY_A, KEY_W, KEY_S, KEY_E, KEY_D, KEY_F,
  16.   KEY_T, KEY_G, KEY_Y, KEY_H, KEY_U, KEY_J, KEY_K, KEY_O, KEY_L, KEY_P};
  17.  
  18. unsigned char patterncopybuffer[MAX_PATTROWS*4+4];
  19. unsigned char cmdcopybuffer[MAX_PATTROWS*4+4];
  20. int patterncopyrows = 0;
  21. int cmdcopyrows = 0;
  22.  
  23. int epnum[MAX_CHN];
  24. int eppos;
  25. int epview;
  26. int epcolumn;
  27. int epchn;
  28. int epoctave = 2;
  29. int epmarkchn = -1;
  30. int epmarkstart;
  31. int epmarkend;
  32.  
  33. void patterncommands(void)
  34. {
  35.   int c, scrrep;
  36.  
  37.   switch(key)
  38.   {
  39.     case '<':
  40.     case '(':
  41.     case '[':
  42.     prevpattern();
  43.     break;
  44.  
  45.     case '>':
  46.     case ')':
  47.     case ']':
  48.     nextpattern();
  49.     break;
  50.   }
  51.   {
  52.     int newnote = -1;
  53.     if (key)
  54.     {
  55.       switch (keypreset)
  56.       {
  57.         case KEY_TRACKER:
  58.         for (c = 0; c < sizeof(notekeytbl1); c++)
  59.         {
  60.           if ((rawkey == notekeytbl1[c]) && (!epcolumn) && (!shiftpressed))
  61.           {
  62.             newnote = FIRSTNOTE+c+epoctave*12;
  63.           }
  64.         }
  65.         for (c = 0; c < sizeof(notekeytbl2); c++)
  66.         {
  67.           if ((rawkey == notekeytbl2[c]) && (!epcolumn) && (!shiftpressed))
  68.           {
  69.             newnote = FIRSTNOTE+c+(epoctave+1)*12;
  70.           }
  71.         }
  72.         break;
  73.  
  74.         case KEY_DMC:
  75.         for (c = 0; c < sizeof(dmckeytbl); c++)
  76.         {
  77.           if ((rawkey == dmckeytbl[c]) && (!epcolumn) && (!shiftpressed))
  78.           {
  79.             newnote = FIRSTNOTE+c+epoctave*12;
  80.           }
  81.         }
  82.         break;
  83.       }
  84.     }
  85.  
  86.     if (newnote > LASTNOTE) newnote = -1;
  87.     if ((rawkey == 0x08) && (!epcolumn)) newnote = REST;
  88.     if ((rawkey == 0x14) && (!epcolumn)) newnote = KEYOFF;
  89.     if (rawkey == KEY_ENTER)
  90.     {
  91.       switch(epcolumn)
  92.       {
  93.         case 0:
  94.         if (shiftpressed)
  95.           newnote = KEYON;
  96.         else
  97.           newnote = KEYOFF;
  98.         break;
  99.  
  100.         case 1:
  101.         case 2:
  102.         if (pattern[epnum[epchn]][eppos*4+1])
  103.         {
  104.           gotoinstr(pattern[epnum[epchn]][eppos*4+1]);
  105.           return;
  106.         }
  107.         break;
  108.  
  109.         default:
  110.         switch (pattern[epnum[epchn]][eppos*4+2])
  111.         {
  112.           case CMD_SETWAVEPTR:
  113.           if (pattern[epnum[epchn]][eppos*4+3])
  114.           {
  115.             gototable(WTBL, pattern[epnum[epchn]][eppos*4+3] - 1);
  116.             return;
  117.           }
  118.           else
  119.           {
  120.               if (shiftpressed)
  121.               {
  122.                   int pos = gettablelen(WTBL);
  123.               if (pos >= MAX_TABLELEN-1) pos = MAX_TABLELEN - 1;
  124.               pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  125.               gototable(WTBL, pos);
  126.               return;
  127.             }
  128.           }
  129.           break;
  130.  
  131.           case CMD_SETPULSEPTR:
  132.           if (pattern[epnum[epchn]][eppos*4+3])
  133.           {
  134.             gototable(PTBL, pattern[epnum[epchn]][eppos*4+3] - 1);
  135.             return;
  136.           }
  137.           else
  138.           {
  139.               if (shiftpressed)
  140.               {
  141.                   int pos = gettablelen(PTBL);
  142.               if (pos >= MAX_TABLELEN-1) pos = MAX_TABLELEN - 1;
  143.               pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  144.               gototable(PTBL, pos);
  145.               return;
  146.             }
  147.           }
  148.           break;
  149.  
  150.           case CMD_SETFILTERPTR:
  151.           if (pattern[epnum[epchn]][eppos*4+3])
  152.           {
  153.             gototable(FTBL, pattern[epnum[epchn]][eppos*4+3] - 1);
  154.             return;
  155.           }
  156.           else
  157.           {
  158.               if (shiftpressed)
  159.               {
  160.                   int pos = gettablelen(FTBL);
  161.               if (pos >= MAX_TABLELEN-1) pos = MAX_TABLELEN - 1;
  162.               pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  163.               gototable(FTBL, pos);
  164.               return;
  165.             }
  166.           }
  167.           break;
  168.  
  169.           case CMD_FUNKTEMPO:
  170.           if (pattern[epnum[epchn]][eppos*4+3])
  171.           {
  172.             if (!shiftpressed)
  173.             {
  174.               gototable(STBL, pattern[epnum[epchn]][eppos*4+3] - 1);
  175.               return;
  176.             }
  177.             else
  178.             {
  179.               int pos = makespeedtable(pattern[epnum[epchn]][eppos*4+3], MST_FUNKTEMPO, 1);
  180.               pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  181.             }
  182.           }
  183.           else
  184.           {
  185.             if (shiftpressed)
  186.             {
  187.                 int pos = findfreespeedtable();
  188.                 if (pos >= 0)
  189.                 {
  190.                 pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  191.                 gototable(STBL, pos);
  192.                 return;
  193.               }
  194.             }
  195.           }
  196.           break;
  197.  
  198.           case CMD_PORTAUP:
  199.           case CMD_PORTADOWN:
  200.           case CMD_TONEPORTA:
  201.           if (pattern[epnum[epchn]][eppos*4+3])
  202.           {
  203.             if (!shiftpressed)
  204.             {
  205.               gototable(STBL, pattern[epnum[epchn]][eppos*4+3] - 1);
  206.               return;
  207.             }
  208.             else
  209.             {
  210.               int pos = makespeedtable(pattern[epnum[epchn]][eppos*4+3], MST_PORTAMENTO, 1);
  211.               pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  212.             }
  213.           }
  214.           else
  215.           {
  216.             if (shiftpressed)
  217.             {
  218.                 int pos = findfreespeedtable();
  219.                 if (pos >= 0)
  220.                 {
  221.                 pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  222.                 gototable(STBL, pos);
  223.                 return;
  224.               }
  225.             }
  226.           }
  227.           break;
  228.  
  229.           case CMD_VIBRATO:
  230.           if (pattern[epnum[epchn]][eppos*4+3])
  231.           {
  232.             if (!shiftpressed)
  233.             {
  234.               gototable(STBL, pattern[epnum[epchn]][eppos*4+3] - 1);
  235.               return;
  236.             }
  237.             else
  238.             {
  239.               int pos = makespeedtable(pattern[epnum[epchn]][eppos*4+3], finevibrato, 1);
  240.               pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  241.             }
  242.           }
  243.           else
  244.           {
  245.             if (shiftpressed)
  246.             {
  247.                 int pos = findfreespeedtable();
  248.                 if (pos >= 0)
  249.                 {
  250.                 pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  251.                 gototable(STBL, pos);
  252.                 return;
  253.               }
  254.             }
  255.           }
  256.           break;
  257.         }
  258.         break;
  259.       }
  260.       if ((autoadvance < 2) && (epcolumn))
  261.       {
  262.         eppos++;
  263.         if (eppos > pattlen[epnum[epchn]])
  264.         {
  265.           eppos = 0;
  266.         }
  267.       }
  268.     }
  269.  
  270.     if (newnote >= 0)
  271.     {
  272.       if ((recordmode) && (eppos < pattlen[epnum[epchn]]))
  273.       {
  274.         pattern[epnum[epchn]][eppos*4] = newnote;
  275.         if (newnote < REST)
  276.         {
  277.           pattern[epnum[epchn]][eppos*4+1] = einum;
  278.         }
  279.         else
  280.         {
  281.           pattern[epnum[epchn]][eppos*4+1] = 0;
  282.         }
  283.         if ((shiftpressed) && (newnote == REST))
  284.         {
  285.           pattern[epnum[epchn]][eppos*4+2] = 0;
  286.           pattern[epnum[epchn]][eppos*4+3] = 0;
  287.         }
  288.       }
  289.       if (recordmode)
  290.       {
  291.         if (autoadvance < 2)
  292.         {
  293.           eppos++;
  294.           if (eppos > pattlen[epnum[epchn]])
  295.           {
  296.             eppos = 0;
  297.           }
  298.         }
  299.       }
  300.       playtestnote(newnote, einum, epchn);
  301.     }
  302.   }
  303.   switch(rawkey)
  304.   {
  305.       case KEY_O:
  306.       if (shiftpressed) shrinkpattern();
  307.       break;
  308.  
  309.       case KEY_P:
  310.       if (shiftpressed) expandpattern();
  311.       break;
  312.  
  313.       case KEY_J:
  314.       if (shiftpressed) joinpattern();
  315.       break;
  316.  
  317.       case KEY_K:
  318.       if (shiftpressed) splitpattern();
  319.     break;
  320.  
  321.     case KEY_Z:
  322.     if (shiftpressed)
  323.     {
  324.       autoadvance++;
  325.       if (autoadvance > 2) autoadvance = 0;
  326.       if (keypreset == KEY_TRACKER)
  327.       {
  328.         if (autoadvance == 1) autoadvance = 2;
  329.       }
  330.     }
  331.     break;
  332.  
  333.     case KEY_E:
  334.     if (shiftpressed)
  335.     {
  336.       if (epmarkchn != -1)
  337.       {
  338.         if (epmarkstart < epmarkend)
  339.         {
  340.           int d = 0;
  341.           for (c = epmarkstart; c <= epmarkend; c++)
  342.           {
  343.             if (c >= pattlen[epnum[epmarkchn]]) break;
  344.             cmdcopybuffer[d*4+2] = pattern[epnum[epmarkchn]][c*4+2];
  345.             cmdcopybuffer[d*4+3] = pattern[epnum[epmarkchn]][c*4+3];
  346.             d++;
  347.           }
  348.           cmdcopyrows = d;
  349.         }
  350.         else
  351.         {
  352.           int d = 0;
  353.           for (c = epmarkend; c <= epmarkstart; c++)
  354.           {
  355.             if (c >= pattlen[epnum[epmarkchn]]) break;
  356.             cmdcopybuffer[d*4+2] = pattern[epnum[epmarkchn]][c*4+2];
  357.             cmdcopybuffer[d*4+3] = pattern[epnum[epmarkchn]][c*4+3];
  358.             d++;
  359.           }
  360.           cmdcopyrows = d;
  361.         }
  362.         epmarkchn = -1;
  363.       }
  364.       else
  365.       {
  366.         if (eppos < pattlen[epnum[epchn]])
  367.         {
  368.           cmdcopybuffer[2] = pattern[epnum[epchn]][eppos*4+2];
  369.           cmdcopybuffer[3] = pattern[epnum[epchn]][eppos*4+3];
  370.           cmdcopyrows = 1;
  371.         }
  372.       }
  373.     }
  374.     break;
  375.  
  376.     case KEY_R:
  377.     if (shiftpressed)
  378.     {
  379.       for (c = 0; c < cmdcopyrows; c++)
  380.       {
  381.         if (eppos >= pattlen[epnum[epchn]]) break;
  382.         pattern[epnum[epchn]][eppos*4+2] = cmdcopybuffer[c*4+2];
  383.         pattern[epnum[epchn]][eppos*4+3] = cmdcopybuffer[c*4+3];
  384.         eppos++;
  385.       }
  386.     }
  387.     break;
  388.  
  389.     case KEY_I:
  390.     if (shiftpressed)
  391.     {
  392.       int d, e;
  393.       char temp;
  394.       if (epmarkchn != -1)
  395.       {
  396.         if (epmarkstart <= epmarkend)
  397.         {
  398.           e = epmarkend;
  399.           for (c = epmarkstart; c <= epmarkend; c++)
  400.           {
  401.             if (c >= pattlen[epnum[epmarkchn]]) break;
  402.             for (d = 0; d < 4; d++)
  403.             {
  404.               temp = pattern[epnum[epmarkchn]][c*4+d];
  405.               pattern[epnum[epmarkchn]][c*4+d] = pattern[epnum[epmarkchn]][e*4+d];
  406.               pattern[epnum[epmarkchn]][e*4+d] = temp;
  407.             }
  408.             e--;
  409.             if (e < c) break;
  410.           }
  411.         }
  412.         else
  413.         {
  414.           e = epmarkstart;
  415.           for (c = epmarkend; c <= epmarkstart; c++)
  416.           {
  417.             if (c >= pattlen[epnum[epmarkchn]]) break;
  418.             for (d = 0; d < 4; d++)
  419.             {
  420.               temp = pattern[epnum[epmarkchn]][c*4+d];
  421.               pattern[epnum[epmarkchn]][c*4+d] = pattern[epnum[epmarkchn]][e*4+d];
  422.               pattern[epnum[epmarkchn]][e*4+d] = temp;
  423.             }
  424.             e--;
  425.             if (e < c) break;
  426.           }
  427.         }
  428.       }
  429.       else
  430.       {
  431.         e = pattlen[epnum[epchn]] - 1;
  432.         for (c = 0; c < pattlen[epnum[epchn]]; c++)
  433.         {
  434.           for (d = 0; d < 4; d++)
  435.           {
  436.             temp = pattern[epnum[epchn]][c*4+d];
  437.             pattern[epnum[epchn]][c*4+d] = pattern[epnum[epchn]][e*4+d];
  438.             pattern[epnum[epchn]][e*4+d] = temp;
  439.           }
  440.           e--;
  441.           if (e < c) break;
  442.         }
  443.       }
  444.     }
  445.     break;
  446.  
  447.     case KEY_Q:
  448.     if (shiftpressed)
  449.     {
  450.       if (epmarkchn != -1)
  451.       {
  452.         if (epmarkstart <= epmarkend)
  453.         {
  454.           for (c = epmarkstart; c <= epmarkend; c++)
  455.           {
  456.             if (c >= pattlen[epnum[epmarkchn]]) break;
  457.             if ((pattern[epnum[epmarkchn]][c*4] < LASTNOTE) &&
  458.                 (pattern[epnum[epmarkchn]][c*4] >= FIRSTNOTE))
  459.               pattern[epnum[epmarkchn]][c*4]++;
  460.           }
  461.         }
  462.         else
  463.         {
  464.           for (c = epmarkend; c <= epmarkstart; c++)
  465.           {
  466.             if (c >= pattlen[epnum[epmarkchn]]) break;
  467.             if ((pattern[epnum[epmarkchn]][c*4] < LASTNOTE) &&
  468.                 (pattern[epnum[epmarkchn]][c*4] >= FIRSTNOTE))
  469.               pattern[epnum[epmarkchn]][c*4]++;
  470.           }
  471.         }
  472.       }
  473.       else
  474.       {
  475.         for (c = 0; c < pattlen[epnum[epchn]]; c++)
  476.         {
  477.           if ((pattern[epnum[epchn]][c*4] < LASTNOTE) &&
  478.               (pattern[epnum[epchn]][c*4] >= FIRSTNOTE))
  479.             pattern[epnum[epchn]][c*4]++;
  480.         }
  481.       }
  482.     }
  483.     break;
  484.  
  485.     case KEY_A:
  486.     if (shiftpressed)
  487.     {
  488.       if (epmarkchn != -1)
  489.       {
  490.         if (epmarkstart <= epmarkend)
  491.         {
  492.           for (c = epmarkstart; c <= epmarkend; c++)
  493.           {
  494.             if (c >= pattlen[epnum[epmarkchn]]) break;
  495.             if ((pattern[epnum[epmarkchn]][c*4] <= LASTNOTE) &&
  496.                 (pattern[epnum[epmarkchn]][c*4] > FIRSTNOTE))
  497.               pattern[epnum[epmarkchn]][c*4]--;
  498.           }
  499.         }
  500.         else
  501.         {
  502.           for (c = epmarkend; c <= epmarkstart; c++)
  503.           {
  504.             if (c >= pattlen[epnum[epmarkchn]]) break;
  505.             if ((pattern[epnum[epmarkchn]][c*4] <= LASTNOTE) &&
  506.                 (pattern[epnum[epmarkchn]][c*4] > FIRSTNOTE))
  507.               pattern[epnum[epmarkchn]][c*4]--;
  508.           }
  509.         }
  510.       }
  511.       else
  512.       {
  513.         for (c = 0; c < pattlen[epnum[epchn]]; c++)
  514.         {
  515.           if ((pattern[epnum[epchn]][c*4] <= LASTNOTE) &&
  516.               (pattern[epnum[epchn]][c*4] > FIRSTNOTE))
  517.             pattern[epnum[epchn]][c*4]--;
  518.         }
  519.       }
  520.     }
  521.     break;
  522.  
  523.     case KEY_W:
  524.     if (shiftpressed)
  525.     {
  526.       if (epmarkchn != -1)
  527.       {
  528.         if (epmarkstart <= epmarkend)
  529.         {
  530.           for (c = epmarkstart; c <= epmarkend; c++)
  531.           {
  532.             if (c >= pattlen[epnum[epmarkchn]]) break;
  533.             if ((pattern[epnum[epmarkchn]][c*4] <= LASTNOTE) &&
  534.                 (pattern[epnum[epmarkchn]][c*4] >= FIRSTNOTE))
  535.             {
  536.               pattern[epnum[epmarkchn]][c*4] += 12;
  537.               if (pattern[epnum[epmarkchn]][c*4] > LASTNOTE)
  538.                 pattern[epnum[epmarkchn]][c*4] = LASTNOTE;
  539.             }
  540.           }
  541.         }
  542.         else
  543.         {
  544.           for (c = epmarkend; c <= epmarkstart; c++)
  545.           {
  546.             if (c >= pattlen[epnum[epmarkchn]]) break;
  547.             if ((pattern[epnum[epmarkchn]][c*4] <= LASTNOTE) &&
  548.                 (pattern[epnum[epmarkchn]][c*4] >= FIRSTNOTE))
  549.             {
  550.               pattern[epnum[epmarkchn]][c*4] += 12;
  551.               if (pattern[epnum[epmarkchn]][c*4] > LASTNOTE)
  552.                 pattern[epnum[epmarkchn]][c*4] = LASTNOTE;
  553.             }
  554.           }
  555.         }
  556.       }
  557.       else
  558.       {
  559.         for (c = 0; c < pattlen[epnum[epchn]]; c++)
  560.         {
  561.           if ((pattern[epnum[epchn]][c*4] <= LASTNOTE) &&
  562.               (pattern[epnum[epchn]][c*4] >= FIRSTNOTE))
  563.           {
  564.             pattern[epnum[epchn]][c*4] += 12;
  565.             if (pattern[epnum[epchn]][c*4] > LASTNOTE)
  566.               pattern[epnum[epchn]][c*4] = LASTNOTE;
  567.           }
  568.         }
  569.       }
  570.     }
  571.     break;
  572.  
  573.     case KEY_S:
  574.     if (shiftpressed)
  575.     {
  576.       if (epmarkchn != -1)
  577.       {
  578.         if (epmarkstart <= epmarkend)
  579.         {
  580.           for (c = epmarkstart; c <= epmarkend; c++)
  581.           {
  582.             if (c >= pattlen[epnum[epmarkchn]]) break;
  583.             if ((pattern[epnum[epmarkchn]][c*4] <= LASTNOTE) &&
  584.                 (pattern[epnum[epmarkchn]][c*4] >= FIRSTNOTE))
  585.             {
  586.               pattern[epnum[epmarkchn]][c*4] -= 12;
  587.               if (pattern[epnum[epmarkchn]][c*4] < FIRSTNOTE)
  588.                 pattern[epnum[epmarkchn]][c*4] = FIRSTNOTE;
  589.             }
  590.           }
  591.         }
  592.         else
  593.         {
  594.           for (c = epmarkend; c <= epmarkstart; c++)
  595.           {
  596.             if (c >= pattlen[epnum[epmarkchn]]) break;
  597.             if ((pattern[epnum[epmarkchn]][c*4] <= LASTNOTE) &&
  598.                 (pattern[epnum[epmarkchn]][c*4] >= FIRSTNOTE))
  599.             {
  600.               pattern[epnum[epmarkchn]][c*4] -= 12;
  601.               if (pattern[epnum[epmarkchn]][c*4] < FIRSTNOTE)
  602.                 pattern[epnum[epmarkchn]][c*4] = FIRSTNOTE;
  603.             }
  604.           }
  605.         }
  606.       }
  607.       else
  608.       {
  609.         for (c = 0; c < pattlen[epnum[epchn]]; c++)
  610.         {
  611.           if ((pattern[epnum[epchn]][c*4] <= LASTNOTE) &&
  612.               (pattern[epnum[epchn]][c*4] >= FIRSTNOTE))
  613.           {
  614.             pattern[epnum[epchn]][c*4] -= 12;
  615.             if (pattern[epnum[epchn]][c*4] < FIRSTNOTE)
  616.               pattern[epnum[epchn]][c*4] = FIRSTNOTE;
  617.           }
  618.         }
  619.       }
  620.     }
  621.     break;
  622.  
  623.     case KEY_M:
  624.     if (shiftpressed)
  625.     {
  626.       stepsize++;
  627.       if (stepsize > MAX_PATTROWS) stepsize = MAX_PATTROWS;
  628.     }
  629.     break;
  630.  
  631.     case KEY_N:
  632.     if (shiftpressed)
  633.     {
  634.       stepsize--;
  635.       if (stepsize < 2) stepsize = 2;
  636.     }
  637.     break;
  638.  
  639.     case KEY_H:
  640.     if (shiftpressed)
  641.     {
  642.       switch (pattern[epnum[epchn]][eppos*4+2])
  643.       {
  644.         case CMD_PORTAUP:
  645.         case CMD_PORTADOWN:
  646.         case CMD_VIBRATO:
  647.         case CMD_TONEPORTA:
  648.         if (pattern[epnum[epchn]][eppos*4+2] == CMD_TONEPORTA)
  649.           c = eppos-1;
  650.         else
  651.           c = eppos;
  652.         for (; c >= 0; c--)
  653.         {
  654.             if ((pattern[epnum[epchn]][c*4] >= FIRSTNOTE) &&
  655.                 (pattern[epnum[epchn]][c*4] <= LASTNOTE))
  656.             {
  657.                 int delta;
  658.             int pitch1;
  659.             int pitch2;
  660.             int pos;
  661.                 int note = pattern[epnum[epchn]][c*4] - FIRSTNOTE;
  662.             int right = pattern[epnum[epchn]][eppos*4+3] & 0xf;
  663.             int left = pattern[epnum[epchn]][eppos*4+3] >> 4;
  664.  
  665.             if (note > MAX_NOTES-1) note--;
  666.             pitch1 = freqtbllo[note] | (freqtblhi[note] << 8);
  667.             pitch2 = freqtbllo[note+1] | (freqtblhi[note+1] << 8);
  668.             delta = pitch2 - pitch1;
  669.  
  670.             while (left--) delta <<= 1;
  671.             while (right--) delta >>= 1;
  672.  
  673.             if (pattern[epnum[epchn]][eppos*4+2] == CMD_VIBRATO)
  674.             {
  675.                 if (delta > 0xff) delta = 0xff;
  676.             }
  677.             pos = makespeedtable(delta, MST_RAW, 1);
  678.             pattern[epnum[epchn]][eppos*4+3] = pos + 1;
  679.             break;
  680.           }
  681.         }
  682.         break;
  683.       }
  684.     }
  685.     break;
  686.  
  687.     case KEY_L:
  688.     if (shiftpressed)
  689.     {
  690.       if (epmarkchn == -1)
  691.       {
  692.         epmarkchn = epchn;
  693.         epmarkstart = 0;
  694.         epmarkend = pattlen[epnum[epchn]]-1;
  695.       }
  696.       else epmarkchn = -1;
  697.     }
  698.     break;
  699.  
  700.     case KEY_C:
  701.     case KEY_X:
  702.     if (shiftpressed)
  703.     {
  704.       if (epmarkchn != -1)
  705.       {
  706.         if (epmarkstart <= epmarkend)
  707.         {
  708.           int d = 0;
  709.           for (c = epmarkstart; c <= epmarkend; c++)
  710.           {
  711.             if (c >= pattlen[epnum[epmarkchn]]) break;
  712.             patterncopybuffer[d*4] = pattern[epnum[epmarkchn]][c*4];
  713.             patterncopybuffer[d*4+1] = pattern[epnum[epmarkchn]][c*4+1];
  714.             patterncopybuffer[d*4+2] = pattern[epnum[epmarkchn]][c*4+2];
  715.             patterncopybuffer[d*4+3] = pattern[epnum[epmarkchn]][c*4+3];
  716.             if (rawkey == KEY_X)
  717.             {
  718.               pattern[epnum[epmarkchn]][c*4] = REST;
  719.               pattern[epnum[epmarkchn]][c*4+1] = 0;
  720.               pattern[epnum[epmarkchn]][c*4+2] = 0;
  721.               pattern[epnum[epmarkchn]][c*4+3] = 0;
  722.             }
  723.             d++;
  724.           }
  725.           patterncopyrows = d;
  726.         }
  727.         else
  728.         {
  729.           int d = 0;
  730.           for (c = epmarkend; c <= epmarkstart; c++)
  731.           {
  732.             if (c >= pattlen[epnum[epmarkchn]]) break;
  733.             patterncopybuffer[d*4] = pattern[epnum[epmarkchn]][c*4];
  734.             patterncopybuffer[d*4+1] = pattern[epnum[epmarkchn]][c*4+1];
  735.             patterncopybuffer[d*4+2] = pattern[epnum[epmarkchn]][c*4+2];
  736.             patterncopybuffer[d*4+3] = pattern[epnum[epmarkchn]][c*4+3];
  737.             if (rawkey == KEY_X)
  738.             {
  739.               pattern[epnum[epmarkchn]][c*4] = REST;
  740.               pattern[epnum[epmarkchn]][c*4+1] = 0;
  741.               pattern[epnum[epmarkchn]][c*4+2] = 0;
  742.               pattern[epnum[epmarkchn]][c*4+3] = 0;
  743.             }
  744.             d++;
  745.           }
  746.           patterncopyrows = d;
  747.         }
  748.         epmarkchn = -1;
  749.       }
  750.       else
  751.       {
  752.         int d = 0;
  753.         for (c = 0; c < pattlen[epnum[epchn]]; c++)
  754.         {
  755.           patterncopybuffer[d*4] = pattern[epnum[epchn]][c*4];
  756.           patterncopybuffer[d*4+1] = pattern[epnum[epchn]][c*4+1];
  757.           patterncopybuffer[d*4+2] = pattern[epnum[epchn]][c*4+2];
  758.           patterncopybuffer[d*4+3] = pattern[epnum[epchn]][c*4+3];
  759.           if (rawkey == KEY_X)
  760.           {
  761.             pattern[epnum[epchn]][c*4] = REST;
  762.             pattern[epnum[epchn]][c*4+1] = 0;
  763.             pattern[epnum[epchn]][c*4+2] = 0;
  764.             pattern[epnum[epchn]][c*4+3] = 0;
  765.           }
  766.           d++;
  767.         }
  768.         patterncopyrows = d;
  769.       }
  770.     }
  771.     break;
  772.  
  773.     case KEY_V:
  774.     if ((shiftpressed) && (patterncopyrows))
  775.     {
  776.       for (c = 0; c < patterncopyrows; c++)
  777.       {
  778.         if (eppos >= pattlen[epnum[epchn]]) break;
  779.         pattern[epnum[epchn]][eppos*4] = patterncopybuffer[c*4];
  780.         pattern[epnum[epchn]][eppos*4+1] = patterncopybuffer[c*4+1];
  781.         pattern[epnum[epchn]][eppos*4+2] = patterncopybuffer[c*4+2];
  782.         pattern[epnum[epchn]][eppos*4+3] = patterncopybuffer[c*4+3];
  783.         eppos++;
  784.       }
  785.     }
  786.     break;
  787.  
  788.     case KEY_DEL:
  789.     if (epmarkchn == epchn) epmarkchn = -1;
  790.     if ((pattlen[epnum[epchn]]-eppos)*4-4 >= 0)
  791.     {
  792.       memmove(&pattern[epnum[epchn]][eppos*4],
  793.         &pattern[epnum[epchn]][eppos*4+4],
  794.         (pattlen[epnum[epchn]]-eppos)*4-4);
  795.       pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-4] = REST;
  796.       pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-3] = 0x00;
  797.       pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-2] = 0x00;
  798.       pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-1] = 0x00;
  799.     }
  800.     else
  801.     {
  802.       if (eppos == pattlen[epnum[epchn]])
  803.       {
  804.         if (pattlen[epnum[epchn]] > 1)
  805.         {
  806.           pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-4] = ENDPATT;
  807.           pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-3] = 0x00;
  808.           pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-2] = 0x00;
  809.           pattern[epnum[epchn]][pattlen[epnum[epchn]]*4-1] = 0x00;
  810.           countthispattern();
  811.           eppos = pattlen[epnum[epchn]];
  812.         }
  813.       }
  814.     }
  815.     break;
  816.  
  817.     case KEY_INS:
  818.     if (epmarkchn == epchn) epmarkchn = -1;
  819.     if ((pattlen[epnum[epchn]]-eppos)*4-4 >= 0)
  820.     {
  821.       memmove(&pattern[epnum[epchn]][eppos*4+4],
  822.         &pattern[epnum[epchn]][eppos*4],
  823.         (pattlen[epnum[epchn]]-eppos)*4-4);
  824.       pattern[epnum[epchn]][eppos*4] = REST;
  825.       pattern[epnum[epchn]][eppos*4+1] = 0x00;
  826.       pattern[epnum[epchn]][eppos*4+2] = 0x00;
  827.       pattern[epnum[epchn]][eppos*4+3] = 0x00;
  828.     }
  829.     else
  830.     {
  831.       if (eppos == pattlen[epnum[epchn]])
  832.       {
  833.         if (pattlen[epnum[epchn]] < MAX_PATTROWS)
  834.         {
  835.           pattern[epnum[epchn]][eppos*4] = REST;
  836.           pattern[epnum[epchn]][eppos*4+1] = 0x00;
  837.           pattern[epnum[epchn]][eppos*4+2] = 0x00;
  838.           pattern[epnum[epchn]][eppos*4+3] = 0x00;
  839.           pattern[epnum[epchn]][eppos*4+4] = ENDPATT;
  840.           pattern[epnum[epchn]][eppos*4+5] = 0x00;
  841.           pattern[epnum[epchn]][eppos*4+6] = 0x00;
  842.           pattern[epnum[epchn]][eppos*4+7] = 0x00;
  843.           countthispattern();
  844.           eppos = pattlen[epnum[epchn]];
  845.         }
  846.       }
  847.     }
  848.     break;
  849.  
  850.     case KEY_SPACE:
  851.     if (!shiftpressed)
  852.       recordmode ^= 1;
  853.     else
  854.     {
  855.         if (lastsonginit != PLAY_PATTERN)
  856.         {
  857.         if (eseditpos != espos[eschn])
  858.         {
  859.           int c;
  860.  
  861.           for (c = 0; c < MAX_CHN; c++)
  862.           {
  863.             if (eseditpos < songlen[esnum][c]) espos[c] = eseditpos;
  864.             if (esend[c] <= espos[c]) esend[c] = 0;
  865.           }
  866.         }
  867.         initsongpos(esnum, PLAY_POS, eppos);
  868.       }
  869.       else initsongpos(esnum, PLAY_PATTERN, eppos);
  870.       followplay = 0;
  871.     }
  872.     break;
  873.  
  874.     case KEY_RIGHT:
  875.     if (!shiftpressed)
  876.     {
  877.       epcolumn++;
  878.       if (epcolumn >= 6)
  879.       {
  880.         epcolumn = 0;
  881.         epchn++;
  882.         if (epchn >= MAX_CHN) epchn = 0;
  883.         if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  884.       }
  885.     }
  886.     else
  887.     {
  888.       if (epnum[epchn] < MAX_PATT-1)
  889.       {
  890.         epnum[epchn]++;
  891.         if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  892.       }
  893.       if (epchn == epmarkchn) epmarkchn = -1;
  894.     }
  895.     break;
  896.  
  897.     case KEY_LEFT:
  898.     if (!shiftpressed)
  899.     {
  900.       epcolumn--;
  901.       if (epcolumn < 0)
  902.       {
  903.         epcolumn = 5;
  904.         epchn--;
  905.         if (epchn < 0) epchn = MAX_CHN-1;
  906.         if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  907.       }
  908.     }
  909.     else
  910.     {
  911.       if (epnum[epchn] > 0)
  912.       {
  913.         epnum[epchn]--;
  914.         if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  915.       }
  916.       if (epchn == epmarkchn) epmarkchn = -1;
  917.     }
  918.     break;
  919.  
  920.     case KEY_HOME:
  921.     while (eppos != 0) patternup();
  922.     break;
  923.  
  924.     case KEY_END:
  925.     while (eppos != pattlen[epnum[epchn]]) patterndown();
  926.     break;
  927.  
  928.     case KEY_PGUP:
  929.     for (scrrep = PGUPDNREPEAT; scrrep; scrrep--)
  930.       patternup();
  931.     break;
  932.  
  933.     case KEY_PGDN:
  934.     for (scrrep = PGUPDNREPEAT; scrrep; scrrep--)
  935.       patterndown();
  936.     break;
  937.  
  938.     case KEY_UP:
  939.     patternup();
  940.     break;
  941.  
  942.     case KEY_DOWN:
  943.     patterndown();
  944.     break;
  945.  
  946.     case KEY_APOST2:
  947.     if (!shiftpressed)
  948.     {
  949.       epchn++;
  950.       if (epchn >= MAX_CHN) epchn = 0;
  951.       if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  952.     }
  953.     else
  954.     {
  955.       epchn--;
  956.       if (epchn < 0) epchn = MAX_CHN-1;
  957.       if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  958.     }
  959.     break;
  960.     
  961.     case KEY_1:
  962.     case KEY_2:
  963.     case KEY_3:
  964.     if (shiftpressed)
  965.       mutechannel(rawkey - KEY_1);
  966.     break;
  967.   }
  968.   if ((keypreset != KEY_TRACKER) && (hexnybble >= 0) && (hexnybble <= 7) && (!epcolumn))
  969.   {
  970.     int oldbyte = pattern[epnum[epchn]][eppos*4];
  971.     epoctave = hexnybble;
  972.     if ((oldbyte >= FIRSTNOTE) && (oldbyte <= LASTNOTE))
  973.     {
  974.       int newbyte;
  975.       int oldnote = (oldbyte - FIRSTNOTE) %12;
  976.  
  977.       if (recordmode)
  978.       {
  979.         newbyte = oldnote+epoctave*12 + FIRSTNOTE;
  980.         if (newbyte <= LASTNOTE)
  981.         {
  982.           pattern[epnum[epchn]][eppos*4] = newbyte;
  983.         }
  984.       }
  985.       if ((recordmode) && (autoadvance < 1))
  986.       {
  987.         eppos++;
  988.         if (eppos > pattlen[epnum[epchn]])
  989.         {
  990.           eppos = 0;
  991.         }
  992.       }
  993.     }
  994.   }
  995.  
  996.   if ((hexnybble >= 0) && (epcolumn) && (recordmode))
  997.   {
  998.     if (eppos < pattlen[epnum[epchn]])
  999.     {
  1000.       switch(epcolumn)
  1001.       {
  1002.         case 1:
  1003.         pattern[epnum[epchn]][eppos*4+1] &= 0x0f;
  1004.         pattern[epnum[epchn]][eppos*4+1] |= hexnybble << 4;
  1005.         pattern[epnum[epchn]][eppos*4+1] &= (MAX_INSTR - 1);
  1006.         break;
  1007.  
  1008.         case 2:
  1009.         pattern[epnum[epchn]][eppos*4+1] &= 0xf0;
  1010.         pattern[epnum[epchn]][eppos*4+1] |= hexnybble;
  1011.         pattern[epnum[epchn]][eppos*4+1] &= (MAX_INSTR - 1);
  1012.         break;
  1013.  
  1014.         case 3:
  1015.         pattern[epnum[epchn]][eppos*4+2] = hexnybble;
  1016.         if (!pattern[epnum[epchn]][eppos*4+2])
  1017.           pattern[epnum[epchn]][eppos*4+3] = 0;
  1018.         break;
  1019.  
  1020.         case 4:
  1021.         pattern[epnum[epchn]][eppos*4+3] &= 0x0f;
  1022.         pattern[epnum[epchn]][eppos*4+3] |= hexnybble << 4;
  1023.         if (!pattern[epnum[epchn]][eppos*4+2])
  1024.           pattern[epnum[epchn]][eppos*4+3] = 0;
  1025.         break;
  1026.  
  1027.         case 5:
  1028.         pattern[epnum[epchn]][eppos*4+3] &= 0xf0;
  1029.         pattern[epnum[epchn]][eppos*4+3] |= hexnybble;
  1030.         if (!pattern[epnum[epchn]][eppos*4+2])
  1031.           pattern[epnum[epchn]][eppos*4+3] = 0;
  1032.         break;
  1033.       }
  1034.     }
  1035.     if (autoadvance < 2)
  1036.     {
  1037.       eppos++;
  1038.       if (eppos > pattlen[epnum[epchn]])
  1039.       {
  1040.         eppos = 0;
  1041.       }
  1042.     }
  1043.   }
  1044.   epview = eppos-VISIBLEPATTROWS/2;
  1045. }
  1046.  
  1047.  
  1048. void patterndown(void)
  1049. {
  1050.   if (shiftpressed)
  1051.   {
  1052.     if ((epmarkchn != epchn) || (eppos != epmarkend))
  1053.     {
  1054.       epmarkchn = epchn;
  1055.       epmarkstart = epmarkend = eppos;
  1056.     }
  1057.   }
  1058.   eppos++;
  1059.   if (eppos > pattlen[epnum[epchn]])
  1060.   {
  1061.     eppos = 0;
  1062.   }
  1063.   if (shiftpressed) epmarkend = eppos;
  1064. }
  1065.  
  1066. void patternup(void)
  1067. {
  1068.   if (shiftpressed)
  1069.   {
  1070.     if ((epmarkchn != epchn) || (eppos != epmarkend))
  1071.     {
  1072.       epmarkchn = epchn;
  1073.       epmarkstart = epmarkend = eppos;
  1074.     }
  1075.   }
  1076.   eppos--;
  1077.   if (eppos < 0)
  1078.   {
  1079.     eppos = pattlen[epnum[epchn]];
  1080.   }
  1081.   if (shiftpressed) epmarkend = eppos;
  1082. }
  1083.  
  1084. void prevpattern(void)
  1085. {
  1086.   if (epnum[epchn] > 0)
  1087.   {
  1088.     epnum[epchn]--;
  1089.     if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  1090.   }
  1091.   if (epchn == epmarkchn) epmarkchn = -1;
  1092. }
  1093.  
  1094. void nextpattern(void)
  1095. {
  1096.   if (epnum[epchn] < MAX_PATT-1)
  1097.   {
  1098.     epnum[epchn]++;
  1099.     if (eppos > pattlen[epnum[epchn]]) eppos = pattlen[epnum[epchn]];
  1100.   }
  1101.   if (epchn == epmarkchn) epmarkchn = -1;
  1102. }
  1103.  
  1104. void shrinkpattern(void)
  1105. {
  1106.   int c = epnum[epchn];
  1107.   int l = pattlen[c];
  1108.   int nl = l/2;
  1109.   int d;
  1110.  
  1111.   if (pattlen[c] < 2) return;
  1112.  
  1113.   stopsong();
  1114.  
  1115.   for (d = 0; d < nl; d++)
  1116.   {
  1117.       pattern[c][d*4] = pattern[c][d*2*4];
  1118.       pattern[c][d*4+1] = pattern[c][d*2*4+1];
  1119.       pattern[c][d*4+2] = pattern[c][d*2*4+2];
  1120.       pattern[c][d*4+3] = pattern[c][d*2*4+3];
  1121.   }
  1122.  
  1123.   pattern[c][nl*4] = ENDPATT;
  1124.   pattern[c][nl*4+1] = 0;
  1125.   pattern[c][nl*4+2] = 0;
  1126.   pattern[c][nl*4+3] = 0;
  1127.  
  1128.   eppos /= 2;
  1129.  
  1130.   countthispattern();
  1131. }
  1132.  
  1133. void expandpattern(void)
  1134. {
  1135.   int c = epnum[epchn];
  1136.   int l = pattlen[c];
  1137.   int nl = l*2;
  1138.   int d;
  1139.   unsigned char temp[MAX_PATTROWS*4+4];
  1140.  
  1141.   if (nl > MAX_PATTROWS) return;
  1142.   memset(temp, 0, sizeof temp);
  1143.  
  1144.   stopsong();
  1145.  
  1146.   for (d = 0; d <= nl; d++)
  1147.   {
  1148.       if (d & 1)
  1149.       {
  1150.           temp[d*4] = REST;
  1151.           temp[d*4+1] = 0;
  1152.           temp[d*4+2] = 0;
  1153.           temp[d*4+3] = 0;
  1154.       }
  1155.       else
  1156.       {
  1157.         temp[d*4] = pattern[c][d*2];
  1158.         temp[d*4+1] = pattern[c][d*2+1];
  1159.         temp[d*4+2] = pattern[c][d*2+2];
  1160.         temp[d*4+3] = pattern[c][d*2+3];
  1161.     }
  1162.   }
  1163.  
  1164.   memcpy(pattern[c], temp, (nl+1)*4);
  1165.  
  1166.   eppos *= 2;
  1167.  
  1168.   countthispattern();
  1169. }
  1170.  
  1171. void splitpattern(void)
  1172. {
  1173.   int c = epnum[epchn];
  1174.   int l = pattlen[c];
  1175.   int d;
  1176.  
  1177.   if (eppos == 0) return;
  1178.   if (eppos == l) return;
  1179.   
  1180.   stopsong();
  1181.  
  1182.   if (insertpattern(c))
  1183.   {
  1184.       int oldesnum = esnum;
  1185.     int oldeschn = eschn;
  1186.     int oldeseditpos = eseditpos;
  1187.  
  1188.       for (d = eppos; d <= l; d++)
  1189.       {
  1190.           pattern[c+1][(d-eppos)*4] = pattern[c][d*4];
  1191.           pattern[c+1][(d-eppos)*4+1] = pattern[c][d*4+1];
  1192.           pattern[c+1][(d-eppos)*4+2] = pattern[c][d*4+2];
  1193.           pattern[c+1][(d-eppos)*4+3] = pattern[c][d*4+3];
  1194.       }
  1195.       pattern[c][eppos*4] = ENDPATT;
  1196.       pattern[c][eppos*4+1] = 0;
  1197.       pattern[c][eppos*4+2] = 0;
  1198.       pattern[c][eppos*4+3] = 0;
  1199.  
  1200.       countpatternlengths();
  1201.  
  1202.     for (esnum = 0; esnum < MAX_SONGS; esnum++)
  1203.     {
  1204.       for (eschn = 0; eschn < MAX_CHN; eschn++)
  1205.       {
  1206.           for (eseditpos = 0; eseditpos < songlen[esnum][eschn]; eseditpos++)
  1207.           {
  1208.               if (songorder[esnum][eschn][eseditpos] == c)
  1209.               {
  1210.                   songorder[esnum][eschn][eseditpos] = c+1;
  1211.                   insertorder(c);
  1212.               }
  1213.             }
  1214.         }
  1215.     }
  1216.     eschn = oldeschn;
  1217.     eseditpos = oldeseditpos;
  1218.     esnum = oldesnum;
  1219.   }
  1220. }
  1221.  
  1222. void joinpattern(void)
  1223. {
  1224.   int c = epnum[epchn];
  1225.   int d;
  1226.  
  1227.   if (eschn != epchn) return;
  1228.   if (songorder[esnum][epchn][eseditpos] != c) return;
  1229.   d = songorder[esnum][epchn][eseditpos + 1];
  1230.   if (d >= MAX_PATT) return;
  1231.   if (pattlen[c] + pattlen[d] > MAX_PATTROWS) return;
  1232.  
  1233.   stopsong();
  1234.  
  1235.   if (insertpattern(c))
  1236.   {
  1237.       int oldesnum = esnum;
  1238.     int oldeschn = eschn;
  1239.     int oldeseditpos = eseditpos;
  1240.       int e, f;
  1241.     d++;
  1242.  
  1243.     for (e = 0; e < pattlen[c]; e++)
  1244.     {
  1245.         pattern[c+1][e*4] = pattern[c][e*4];
  1246.         pattern[c+1][e*4+1] = pattern[c][e*4+1];
  1247.         pattern[c+1][e*4+2] = pattern[c][e*4+2];
  1248.         pattern[c+1][e*4+3] = pattern[c][e*4+3];
  1249.     }
  1250.     for (f = 0; f < pattlen[d]; f++)
  1251.     {
  1252.         pattern[c+1][e*4] = pattern[d][f*4];
  1253.         pattern[c+1][e*4+1] = pattern[d][f*4+1];
  1254.          pattern[c+1][e*4+2] = pattern[d][f*4+2];
  1255.          pattern[c+1][e*4+3] = pattern[d][f*4+3];
  1256.          e++;
  1257.     }
  1258.     pattern[c+1][e*4] = ENDPATT;
  1259.     pattern[c+1][e*4+1] = 0;
  1260.     pattern[c+1][e*4+2] = 0;
  1261.     pattern[c+1][e*4+3] = 0;
  1262.  
  1263.     countpatternlengths();
  1264.  
  1265.     for (esnum = 0; esnum < MAX_SONGS; esnum++)
  1266.     {
  1267.       for (eschn = 0; eschn < MAX_CHN; eschn++)
  1268.       {
  1269.           for (eseditpos = 0; eseditpos < songlen[esnum][eschn]; eseditpos++)
  1270.           {
  1271.               if ((songorder[esnum][eschn][eseditpos] == c) && (songorder[esnum][eschn][eseditpos+1] == d))
  1272.               {
  1273.             deleteorder();
  1274.             songorder[esnum][eschn][eseditpos] = c+1;
  1275.               }
  1276.             }
  1277.         }
  1278.     }
  1279.     eschn = oldeschn;
  1280.     eseditpos = oldeseditpos;
  1281.     esnum = oldesnum;
  1282.  
  1283.     findusedpatterns();
  1284.     {
  1285.         int del1 = pattused[c];
  1286.         int del2 = pattused[d];
  1287.  
  1288.       if (!del1)
  1289.       {
  1290.           deletepattern(c);
  1291.           if (d > c) d--;
  1292.       }
  1293.       if (!del2) 
  1294.         deletepattern(d);
  1295.     }
  1296.   }
  1297. }
  1298.  
  1299.  
  1300.