home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 544a.lha / RPN_v1.0 / Source / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-06  |  7.9 KB  |  302 lines
  1. /*---------------------------------*
  2.  | File: MENU.c - MLO 900131 V1.00 |
  3.  | Procedures for menu handling    |
  4.  *---------------------------------*/
  5.  
  6. #include "rpn.h"
  7. #include "proto.h"
  8. #include "hmenu.h"
  9. #include <math.h>
  10.  
  11. extern double stack[];
  12. extern double reg[];
  13. extern double acc[];
  14. extern double Convert, ConvertD, ConvertG, ConvertR;
  15. extern double LastX;
  16. extern double Pig;
  17. extern int LastCode;
  18. extern Boolean MathError;
  19. extern struct Window *Wrpn;
  20. extern struct Menu *MenuStrip;
  21.  
  22. static void clearStk(void);
  23. static void clearReg(void);
  24. static void clearAcc(void);
  25. static void vanity(void);
  26.  
  27. void menupick(
  28.   USHORT code
  29. )
  30. {
  31.   struct MenuItem *thisItem;
  32.   int nmenu, nitem, nsub, i;
  33.   double x, y;
  34.   double *p;
  35.  
  36. /*------------------------------*
  37.  | Pick up menu, item and (if   |
  38.  | appropriate) subitem numbers |
  39.  *------------------------------*/
  40.  
  41.   while (code != MENUNULL) {
  42.     nmenu = MENUNUM(code);
  43.     nitem = ITEMNUM(code);
  44.     if (nmenu > 3   &&   nmenu < 6) {
  45.       nsub = SUBNUM(code);
  46.     }
  47.     switch (nmenu) {
  48.       case 0:
  49.         switch (nitem) {
  50.           case 0:                               /* Quit */
  51.             cleanup(SYS_NORMAL);
  52.             break;
  53.           case 1:                               /* About */
  54.             vanity();
  55.             break;
  56.         }
  57.         break;
  58.       case 1:
  59.         switch (nitem) {
  60.           case 0:                               /* Clear X */
  61.             stack[0] = 0.0;
  62.             outStk();
  63.             LastCode = ENTER_CODE;
  64.             break;
  65.           case 1:                               /* Clear Stack */
  66.             clearStk();
  67.             LastCode = ENTER_CODE;
  68.             break;
  69.           case 2:                               /* Clear Registers */
  70.             clearReg();
  71.             break;
  72.           case 3:                               /* Clear Accumulators */
  73.             clearAcc();
  74.             break;
  75.           case 4:                               /* Clear All */
  76.             clearStk();
  77.             clearReg();
  78.             clearAcc();
  79.             LastCode = ENTER_CODE;
  80.             break;
  81.         }
  82.         break;
  83.       case 2:
  84.         switch (nitem) {
  85.           case 0:                               /* Set Deg */
  86.             Convert = ConvertD;
  87.             break;
  88.           case 1:                               /* Set Rad */
  89.             Convert = ConvertR;
  90.             break;
  91.           case 2:                               /* Set Grd */
  92.             Convert = ConvertG;
  93.             break;
  94.         }
  95.         break;
  96.       case 3:
  97.         switch (nitem) {
  98.           case 0:                               /* To H.... */
  99.             x = floor(y = fabs(stack[0]));
  100.             y = (y - x) * 100.0;
  101.             y = y / 0.36 - floor(y) / 0.9;
  102.             x += y / 100.0;
  103. hxs:        if (stack[0] < 0)   x = -x;
  104.             xs(x);
  105.             break;
  106.           case 1:                               /* To H.MMSS */
  107.             x = floor(y = fabs(stack[0]));
  108.             y = (y - x) * 60.0;
  109.             x += floor(y) * 0.004 + y * 0.006;
  110.             goto hxs;
  111.           case 2:                               /* To Rad */
  112.             x = stack[0] * ConvertD;
  113.             xs(x);
  114.             break;
  115.           case 3:                               /* To Deg */
  116.             x = stack[0] / ConvertD;
  117.             xs(x);
  118.             break;
  119.           case 4:                               /* To Polar */
  120.             x = sqrt(stack[0] * stack[0] + stack[1] * stack[1]);
  121.             y = (x == 0.0) ? 0.0 : (atan2(stack[1], stack[0]) / Convert);
  122. xys:        if (!MathError) {
  123.               stack[0] = x;
  124.               stack[1] = y;
  125.               outStk();
  126.             }
  127.             break;
  128.           case 5:                               /* To Cartesian */
  129.             x = stack[0] * cos( (y = stack[1] * Convert) );
  130.             y = stack[0] * sin(y);
  131.             goto xys;
  132.         }
  133.         break;
  134.       case 4:                                   /* Store ... */
  135.         if ((i = nsub) < NREGS) {
  136.           p = reg + i;
  137.         } else {
  138.           i -= NREGS;
  139.           p = acc + i;
  140.         }
  141.         switch (nitem) {
  142.           case 0:                               /* Store */
  143.             *p = stack[0];
  144.             outReg(nsub);
  145.             break;
  146.           case 1:                               /* Store + */
  147.             x = *p + stack[0];
  148. sxs:        if (!MathError) {
  149.               *p = x;
  150.               outReg(nsub);
  151.             }
  152.             break;
  153.           case 2:                               /* Store - */
  154.             x = *p - stack[0];
  155.             goto sxs;
  156.           case 3:                               /* Store * */
  157.             x = *p * stack[0];
  158.             goto sxs;
  159.           case 4:                               /* Store / */
  160.             x = *p / stack[0];
  161.             goto sxs;
  162.         }
  163.         break;
  164.       case 5:                                   /* Recall ... */
  165.         if ((i = nsub) < NREGS) {
  166.           p = reg + i;
  167.         } else {
  168.           i -= NREGS;
  169.           p = acc + i;
  170.         }
  171.         switch (nitem) {
  172.           case 0:                               /* Recall */
  173.             enter();
  174.             stack[0] = *p;
  175.             outStk();
  176.             break;
  177.           case 1:                               /* Recall + */
  178.             x = stack[0] + *p;
  179. rxs:        if (!MathError) {
  180.               enter();
  181.               stack[0] = x;
  182.               outStk();
  183.             }
  184.             break;
  185.           case 2:                               /* Recall - */
  186.             x = stack[0] - *p;
  187.             goto rxs;
  188.           case 3:                               /* Recall * */
  189.             x = stack[0] * *p;
  190.             goto rxs;
  191.           case 4:                               /* Recall / */
  192.             x = stack[0] / *p;
  193.             goto rxs;
  194.         }
  195.         break;
  196.       case 6:
  197.         switch (nitem) {
  198.           case 0:                               /* Last X */
  199.             enter();
  200.             stack[0] = LastX;
  201.             outStk();
  202.             break;
  203.           case 1:                               /* Fisher */
  204.             x = regCoef();
  205.             y = acc[4] - acc[3] * acc[3] / acc[0];
  206.             x = sqrt(y * (1.0 - x * x) / (acc[0] - 2.0));
  207.             if (!MathError) {
  208.               impEnter();
  209.               LastX = stack[0];
  210.               stack[0] = x;
  211.               outStk();
  212.             }
  213.             break;
  214.         }
  215.         break;
  216.     }
  217.     thisItem = (struct MenuItem *) ItemAddress(MenuStrip, code);
  218.     code = thisItem->NextSelect;
  219.   }
  220. }
  221.  
  222. static void clearStk(void)
  223. {/*---------------------------------*
  224.   | Local function. Clear all stack |
  225.   *---------------------------------*/
  226.  
  227.   int i;
  228.  
  229.   for (i=0; i<NSTACK; i++)       stack[i] = 0.0;
  230.   outStk();
  231. }
  232.  
  233. static void clearReg(void)
  234. {/*-------------------------------------*
  235.   | Local function. Clear all registers |
  236.   *-------------------------------------*/
  237.  
  238.   int i;
  239.  
  240.   for (i=0; i<NREGS; i++) {
  241.     reg[i] = 0.0;
  242.     outReg(i);
  243.   }
  244. }
  245.  
  246. static void clearAcc(void)
  247. {/*---------------------------*
  248.   | Local function. Clear     |
  249.   | all accumulator registers |
  250.   *---------------------------*/
  251.  
  252.   int i;
  253.  
  254.   for (i=0; i<NACCS; i++) {
  255.     acc[i] = 0.0;
  256.     outAcc(i);
  257.   }
  258. }
  259.  
  260. static void vanity(void)
  261. {/*-------------------------*
  262.   | Local function: display |
  263.   | 'About RPN' requester   |
  264.   *-------------------------*/
  265.  
  266.   struct IntuiText IT5 = {
  267.     BLUE_PEN, WHITE_PEN, JAM2, IT5X, IT5Y, NULL,
  268.     "ITALY", NULL
  269.   };
  270.  
  271.   struct IntuiText IT4 = {
  272.     BLUE_PEN, WHITE_PEN, JAM2, IT4X, IT4Y, NULL,
  273.     "35010 CADONEGHE (PD)", NULL
  274.   };
  275.  
  276.   struct IntuiText IT3 = {
  277.     BLUE_PEN, WHITE_PEN, JAM2, IT3X, IT3Y, NULL,
  278.     "Via G. Donizetti, 6", NULL
  279.   };
  280.   
  281.   struct IntuiText IT2 = {
  282.     BLUE_PEN, WHITE_PEN, JAM2, IT2X, IT2Y, NULL,
  283.     "by Maurizio LORETI (aka MLO or I3NOO)", NULL
  284.   };
  285.   
  286.   struct IntuiText IT1 = {
  287.     BLUE_PEN, WHITE_PEN, JAM2, IT1X, IT1Y, NULL,
  288.     "This is RPN V1.00 900131", NULL
  289.   };
  290.  
  291.   struct IntuiText ITOK = {
  292.     BLUE_PEN, WHITE_PEN, JAM2, ITOKX, ITOKY, NULL,
  293.     "OK", NULL
  294.   };
  295.  
  296.   IT1.NextText = &IT2;
  297.   IT2.NextText = &IT3;
  298.   IT3.NextText = &IT4;
  299.   IT4.NextText = &IT5;
  300.   AutoRequest(Wrpn, &IT1, NULL, &ITOK, 0, 0, ITWID, ITHEI);
  301. }
  302.