Advertisement
Guest User

Untitled

a guest
Jun 28th, 2017
54
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 23.87 KB | None | 0 0
  1. #include "menu.h"
  2. #include "mouse.h"
  3. #include "common.h"
  4.  
  5. void InitFormMenuItem(FormMenu *menu)
  6. /* Initialize a form menu item, give default values */
  7. {
  8.     menu -> text = NULL;
  9.     menu -> next = NULL;
  10.     menu -> pressed = 0;
  11.     menu -> moveover = 0;
  12. }
  13.  
  14. void AddFormMenu(FormMenu *menu, char *title)
  15. /* Add an form menu item to an existing chain */
  16. {
  17.     FormMenu *menutmp, *menunew;
  18.     char *s;
  19.     menutmp = menu;
  20.     while(menutmp -> next != NULL)
  21.         menutmp = menutmp -> next;
  22.     if(menutmp -> text == NULL)
  23.     {
  24.         InitFormMenuItem(menutmp);
  25.         s = (char *)ALLOC((strlen(title) + 1) * sizeof(char));
  26.         strcpy(s, title);
  27.         menutmp -> text = s;
  28.     }
  29.     else
  30.     {
  31.         menunew = ALLOC(sizeof(FormMenu));
  32.         InitFormMenuItem(menunew);
  33.         s=(char *)ALLOC((strlen(title) + 1) * sizeof(char));
  34.         strcpy(s, title);
  35.         menunew -> text = s;
  36.         menutmp -> next = menunew;
  37.     }
  38. }
  39.    
  40. void DrawFormMenu(void *n)
  41. /* Draw all the form menus */
  42. {
  43.     State *s;
  44.     FormMenu *menu;
  45.     int x = 6;
  46.     s = (State *)n;
  47.     menu = s -> menu;
  48.     setwritemode(1);
  49.     SetColor(0);
  50.     setfillstyle(SOLID_FILL, 7);
  51.     bar(x - 3, 21, getmaxx() - 3, 43);
  52.     while(menu -> text != NULL)
  53.     {
  54.         /* Draw every form menu in right place */
  55.         OutTextxy(n, x, 24, menu -> text, 0);
  56.         if(menu -> next == NULL)
  57.             break;
  58.         menu = menu -> next;
  59.         x += 80;
  60.     }
  61. }
  62.  
  63. void IsMoveOverFormMenu(void *n)
  64. /* Judging if mouse is moving over a form menu */
  65. {
  66.     State *s;
  67.     int x = 6;
  68.     FormMenu *menu;
  69.     s = (State *)n;
  70.     menu = s -> menu;
  71.     SetColor(0);
  72.     setwritemode(1);
  73.     while(menu -> text != NULL)
  74.     {
  75.         if(!s -> ischildwindow && PinRA(
  76.                   s -> mouse . x, s -> mouse . y, x, 24, x + 70 , 44))
  77.             /* Found one! */
  78.             menu -> moveover = 1;
  79.         else
  80.             menu -> moveover = 0;
  81.         if(menu -> next == NULL)
  82.             break;
  83.         menu = menu -> next;
  84.         x += 80;
  85.     }
  86. }
  87.    
  88. void DrawMoveOverFormMenu(void *n)
  89. /* Draw the highlight effect of moving-over form menu */
  90. {
  91.     State *s;
  92.     int x = 6, y = 24, k = 0;
  93.     FormMenu *menu;
  94.     static char moveover[10]={0};
  95.     s = (State *)n;
  96.     menu = s -> menu;
  97.     setwritemode(1);
  98.     while(menu -> text != NULL)
  99.     {
  100.         if(menu -> moveover == 2 || menu -> moveover != moveover[k] && !menu -> pressed)
  101.         /* Make sure the menu is the one I should draw! */
  102.         {
  103.             CleanUp(n);
  104.             SetColor(8);
  105.             line(x-3,y-2,x-3,y+17);
  106.             line(x-2,y-2,x+71,y-2);
  107.             SetColor(15);
  108.             line(x-3,y+17,x+71,y+17);
  109.             line(x+71,y-2,x+71,y+16);
  110.             CleanUp(n);
  111.             menu -> moveover = menu -> moveover ? 1 : 0;
  112.         }
  113.         moveover[k ++] = menu -> moveover;
  114.         if(menu -> next == NULL)
  115.             break;
  116.         menu = menu -> next;
  117.         x += 80;
  118.     }
  119. }
  120.  
  121. void IsClickFormMenu(void *n)
  122. /* Judging if clicked an form menu */
  123. {
  124.     State *s;
  125.     int x = 6;
  126.     int flag = 0;
  127.     FormMenu *menu;
  128.     s = (State *)n;
  129.     menu = s -> menu;
  130.     SetColor(0);
  131.     while(menu != NULL)
  132.     {
  133.         if(menu -> moveover && s -> mouse . key && !s -> ischildwindow)
  134.         /* Click makes the state to switch on and off around */
  135.             menu -> pressed = ! menu -> pressed;
  136.         else if(!menu -> moveover && s -> mouse . key)
  137.         /* Clicked somewhere else, clear the pressed state */
  138.             menu -> pressed = 0;
  139.            
  140.         if(menu -> pressed)
  141.         /* On menu pressed state, disable editing */
  142.         {
  143.             s -> isedit = 0;
  144.             flag = 1;
  145.         }
  146.         if(menu -> next == NULL)
  147.             break;
  148.         menu = menu -> next;
  149.         x += 80;
  150.     }
  151.     if(!flag && !s -> isedit && !s -> iscontextmenu && s -> ischildwindow < 99)
  152.     /* No menu pressed, resuming editing switch */
  153.         s -> isedit = 1;
  154. }
  155.  
  156. void DoubleOver(void *n)
  157. /* Only a workaround for form menus */
  158. {
  159.     State *s;
  160.     FormMenu *menu;
  161.     s = (State *)n;
  162.     menu = s -> menu;
  163.     while(menu -> text != NULL)
  164.     {
  165.         menu -> moveover *= 2;
  166.         if(menu -> next == NULL)
  167.             break;
  168.         menu = menu -> next;
  169.     }
  170. }
  171.  
  172. void DrawClickFormMenu(void *n)
  173. /* Draw click effect for form menus */
  174. {
  175.     State *s;
  176.     int x = 6, y = 24, k = 0;
  177.     static char pressed[10]={0};
  178.     FormMenu *menu;
  179.     s = (State *)n;
  180.     menu = s -> menu;
  181.     setwritemode(1);
  182.     while(menu -> text != NULL)
  183.     {
  184.         if(menu -> pressed != pressed[k] && menu -> pressed == 0)
  185.         {
  186.             s -> isedit = 1;
  187.            
  188.             /* A redraw is needed */
  189.             CleanUp(n);
  190.             if(!s -> ischildwindow)
  191.                 if(!s -> dotted)
  192.                 {
  193.                     setactivepage(!s -> page);
  194.                     DrawMainWindow(n);
  195.                     DrawStatusBox(n);
  196.                     DoEvent(s -> redraw, n);
  197.                     CleanUp(n);
  198.                     setvisualpage(!s -> page);
  199.                     s -> page = !s -> page;
  200.                 }
  201.                 else
  202.                 {
  203.                     DoEvent(s -> redraw, n);
  204.                     CleanUp(n);
  205.                 }
  206.             else
  207.                 CleanUp(n);
  208.             DoubleOver(n);
  209.             DrawMoveOverFormMenu(n);
  210.             CleanUp(n);
  211.             OutTextxy(n, x + 1, 25, menu -> text, 7);
  212.             OutTextxy(n, x, 24, menu -> text, 0);
  213.             CleanUp(n);
  214.             pressed[k++] = menu -> pressed;
  215.         }
  216.         else
  217.             k++;
  218.         if(menu -> next == NULL)
  219.             break;
  220.         menu = menu -> next;
  221.         x += 80;
  222.     }
  223.     menu = s -> menu;
  224.     x = 6;
  225.     k = 0;
  226.     while(menu -> text != NULL)
  227.     {
  228.         if(menu -> pressed != pressed[k] && menu -> pressed)
  229.         {
  230.             DoubleOver(n);
  231.             DrawMoveOverFormMenu(n);
  232.             CleanUp(n);
  233.             SetColor(15);
  234.             line(x-3,y-2,x-3,y+17);
  235.             line(x-2,y-2,x+71,y-2);
  236.             SetColor(8);
  237.             line(x-3,y+17,x+71,y+17);
  238.             line(x+71,y-2,x+71,y+16);
  239.             OutTextxy(n, x + 1 - menu -> pressed, 24 + 1 - menu -> pressed, menu -> text, 7);
  240.             OutTextxy(n, x + menu -> pressed, 24 + menu -> pressed, menu -> text, 0);
  241.             if(menu -> pressed)
  242.                 DrawMenu(n, menu -> menu, x, y + 18);
  243.             CleanUp(n);
  244.         }
  245.         pressed[k++] = menu -> pressed;
  246.         if(menu -> next == NULL)
  247.             break;
  248.         menu = menu -> next;
  249.         x += 80;
  250.     }
  251. }
  252.  
  253. void InitMenuItem(Menu *menu)
  254. /* Menu item initialization */
  255. {
  256.     menu -> text = NULL;
  257.     menu -> next = NULL;
  258.     menu -> moveover = 0;
  259.     menu -> enabled = 1;
  260.     menu -> func = NULL;
  261. }
  262.  
  263. void AddMenu(Menu *menu, char enabled, char *title, Event *func)
  264. /* Add a menu item to an existing menu chain */
  265. {
  266.     Menu *menutmp, *menunew;
  267.     char *s;
  268.     menutmp = menu;
  269.     while(menutmp -> next != NULL)
  270.         menutmp = menutmp -> next;
  271.     if(menutmp -> text == NULL)
  272.     {
  273.         InitMenuItem(menutmp);
  274.         s=(char *)ALLOC((strlen(title) + 1) * sizeof(char));
  275.         strcpy(s, title);
  276.         menutmp -> text = s;
  277.         menutmp -> func = func;
  278.         menutmp -> enabled = enabled;
  279.     }
  280.     else
  281.     {
  282.         menunew = ALLOC(sizeof(Menu));
  283.         InitMenuItem(menunew);
  284.         s=(char *)ALLOC((strlen(title) + 1) * sizeof(char));
  285.         strcpy(s, title);
  286.         menunew -> text = s;
  287.         menunew -> func = func;
  288.         menunew -> enabled = enabled;
  289.         menutmp -> next = menunew;
  290.     }
  291. }
  292.  
  293. void DrawMenu(void *n, Menu *menu, int x, int y)
  294. /* Draw a menu */
  295. {
  296.     Menu *menutmp;
  297.     char ch[30];
  298.     State *s;
  299.     s = (State *)n;
  300.     s -> isedit = 0;
  301.     menutmp = menu;
  302.     setwritemode(0);
  303.     setfillstyle(SOLID_FILL, 7);
  304.     if(x + 180 > getmaxx())
  305.         x -= 180;
  306.     bar(x, y, x + 180, y + 5);
  307.     SetColor(7);
  308.     line(x, y, x + 180, y);
  309.     line(x, y, x, y + 5);
  310.     SetColor(15);
  311.     line(x + 1, y + 1, x + 179 , y + 1);
  312.     line(x + 1, y + 1, x + 1 , y + 4);
  313.     SetColor(8);
  314.     line(x + 179, y + 1, x + 179, y + 4);
  315.     SetColor(0);
  316.     line(x + 180, y, x + 180, y + 5);
  317.     while(menutmp -> text != NULL)
  318.     {
  319.         bar(x, y + 5, x + 180, y + 30);
  320.         SetColor(7);
  321.         line(x, y + 5, x, y + 30);
  322.         SetColor(15);
  323.         line(x + 1, y + 5, x + 1, y + 30);
  324.         SetColor(8);
  325.         line(x + 179, y + 5, x + 179, y + 30);
  326.         SetColor(0);
  327.         line(x + 180, y + 5, x + 180, y + 30);
  328.         if(menutmp -> text[0] == '-')
  329.         /* the separator */
  330.         {
  331.             SetColor(8);
  332.             line(x + 6, y + 5, x + 172, y + 5);
  333.             SetColor(15);
  334.             line(x + 6, y + 6, x + 172, y + 6);
  335.             y -= 20;
  336.         }
  337.         else if(menutmp -> enabled == 1)
  338.         /* Available item */
  339.             OutTextxy(n, x + 6, y + 6, menutmp -> text, 0);
  340.         else if(menutmp -> enabled == 2)
  341.         /* Not selected item */
  342.         {
  343.             strcpy(ch, "  ");
  344.             strcpy(ch + 2, menutmp -> text);
  345.             OutTextxy(n, x + 6, y + 6, ch, 0);
  346.         }
  347.         else if(menutmp -> enabled == 3)
  348.         /* Selected item */
  349.         {
  350.             strcpy(ch, "√");
  351.             strcpy(ch + 2, menutmp -> text);
  352.             OutTextxy(n, x + 6, y + 6, ch, 0);
  353.         }
  354.         else if(menutmp -> enabled == 4)
  355.         /* Not selected and not available item */
  356.         {
  357.             strcpy(ch, "  ");
  358.             strcpy(ch + 2, menutmp -> text);
  359.             OutTextxy(n, x + 7, y + 7, ch, 15);
  360.             OutTextxy(n, x + 6, y + 6, ch, 8);
  361.         }
  362.         else if(menutmp -> enabled == 5)
  363.         /* Selected and not available item */
  364.         {
  365.             strcpy(ch, "√");
  366.             strcpy(ch + 2, menutmp -> text);
  367.             OutTextxy(n, x + 7, y + 7, ch, 15);
  368.             OutTextxy(n, x + 6, y + 6, ch, 8);
  369.         }
  370.         else
  371.         /* Not available item */
  372.         {
  373.             OutTextxy(n, x + 7, y + 7, menutmp -> text, 15);
  374.             OutTextxy(n, x + 6, y + 6, menutmp -> text, 8);
  375.         }
  376.         if(menutmp -> next == NULL)
  377.         {
  378.             y += 25;
  379.             break;
  380.         }
  381.         menutmp = menutmp -> next;
  382.         y += 25;
  383.     }
  384.     SetColor(8);
  385.     line(x + 1, y + 5, x + 179, y + 5);
  386.     SetColor(0);
  387.     line(x, y + 6, x + 180, y + 6);
  388. }
  389.  
  390. void IsMoveOverMenu(void *n)
  391. /* Judging if moving over a menu item */
  392. {
  393.     State *s;
  394.     int x = 6, y = 42;
  395.     FormMenu *formmenu;
  396.     Menu *menu;
  397.     s = (State *)n;
  398.     formmenu = s -> menu;
  399.     while(formmenu -> next != NULL && !formmenu -> pressed)
  400.     {
  401.         formmenu = formmenu -> next;
  402.         x += 80;
  403.     }
  404.     if(formmenu -> pressed || s -> iscontextmenu)
  405.     {
  406.         if((s -> keyboard . key & 0xff00) == ESC)
  407.         {
  408.             formmenu = s -> menu;
  409.             while(formmenu -> text != NULL)
  410.             {
  411.                 formmenu -> pressed = 0;
  412.                 if(formmenu -> next == NULL)
  413.                     break;
  414.                 formmenu = formmenu -> next;
  415.             }
  416.             s -> isexit = 0;
  417.             s -> isedit = 1;
  418.             s -> iscontextmenu = 0;
  419.             return;
  420.         }
  421.        
  422.         if(formmenu -> pressed)
  423.             menu = formmenu -> menu;
  424.         else
  425.         {
  426.             menu = s -> contextmenu;
  427.             x = s -> cmmousex;
  428.             y = s -> cmmousey;
  429.         }
  430.         while(menu != NULL)
  431.         {
  432.             if(x + 180 > getmaxx())
  433.                 x -= 180;
  434.             if(PinRA(s -> mouse . x, s -> mouse . y,
  435.                x + 1, y + 5, x + 179, y + 25) && menu -> text[0] != '-'
  436.                && menu -> enabled != 0 && menu -> enabled != 4 &&
  437.                menu -> enabled != 5 && !(s -> iskeyboard))
  438.                 menu -> moveover = 1;
  439.             else if(!(s -> iskeyboard))
  440.                 menu -> moveover = 0;
  441.             if(strlen(menu -> text) > 5 && 'A' <= menu -> text[5] &&
  442.                menu -> text[5] <= 'Z')
  443.                 if((s -> keyboard . key & 0xff00) == s -> map . chs[menu -> text[5] - 'A'])
  444.                 {
  445.                     menu -> moveover = 1;
  446.                     s -> keyboard . key = ENTER;
  447.                 }
  448.             if(menu -> moveover)
  449.             {
  450.                 if(s -> mouse . key || (s -> keyboard . key & 0xff00) == ENTER)
  451.                 {
  452.                     s -> iscontextmenu = 0;
  453.                     s -> isedit = 1;
  454.                     s -> mouse . key = 0;
  455.                     DoEvent(menu -> func, n);
  456.                     formmenu = s -> menu;
  457.                     while(formmenu -> text != NULL)
  458.                     {
  459.                         formmenu -> pressed = 0;
  460.                         if(formmenu -> next == NULL)
  461.                             break;
  462.                         formmenu = formmenu -> next;
  463.                     }
  464.                     return;
  465.                 }
  466.             }
  467.             menu = menu -> next;
  468.             if(menu -> text[0] == '-')
  469.             y -= 20;
  470.             y += 25;
  471.         }
  472.     }
  473. }
  474.  
  475. void DrawMoveOverMenu(void *n)
  476. /* Draw if moving over a menu item */
  477. {
  478.     State *s;
  479.     int x = 6, y = 42, k1 = 0, k2 = 0, i, j;
  480.     char ch[30];
  481.     FormMenu *formmenu;
  482.     Menu *menu;
  483.     static char moveover[10][20]={0};
  484.     s = (State *)n;
  485.     formmenu = s -> menu;
  486.     setwritemode(0);
  487.     if(s -> isclearmenu)
  488.     /* Clear menu flag! */
  489.     {
  490.         for(i = 0; i < 10; i ++)
  491.             for(j = 0; j < 20; j ++)
  492.                 moveover[i][j] = 0;
  493.         s -> isclearmenu = 0;
  494.     }
  495.     while(formmenu -> next != NULL && !formmenu -> pressed)
  496.     {
  497.         formmenu = formmenu -> next;
  498.         x += 80;
  499.         k1 ++;
  500.     }
  501.     if(formmenu -> pressed || s -> iscontextmenu)
  502.     {
  503.         if(formmenu -> pressed)
  504.             menu = formmenu -> menu;
  505.         else
  506.         {
  507.             menu = s -> contextmenu;
  508.             x = s -> cmmousex;
  509.             y = s -> cmmousey;
  510.             k1 = 9;
  511.         }
  512.         while(menu -> text != NULL)
  513.         {
  514.             if((menu -> moveover ? 1 : 0) != moveover[k1][k2])
  515.             {
  516.                 if(x + 180 > getmaxx())
  517.                     x -= 180;
  518.                 CleanUp(n);
  519.                 setwritemode(0);
  520.                 SetColor(7 - 6 * (menu -> moveover ? 1 : 0));
  521.                 for(i = y + 5; i < y + 25; i ++)
  522.                     line(x + 3, i, x + 177, i);
  523.                 if(menu -> enabled == 2)
  524.                 {
  525.                     strcpy(ch, "  ");
  526.                     strcpy(ch + 2, menu -> text);
  527.                     OutTextxy(n, x + 6, y + 6, ch, (menu -> moveover ? 1 : 0) * 15);
  528.                 }
  529.                 else if(menu -> enabled == 3)
  530.                 {
  531.                     strcpy(ch, "√");
  532.                     strcpy(ch + 2, menu -> text);
  533.                     OutTextxy(n, x + 6, y + 6, ch, (menu -> moveover ? 1 : 0) * 15);
  534.                 }
  535.                 else
  536.                     OutTextxy(n, x + 6, y + 6, menu -> text, (menu -> moveover ? 1 : 0) * 15);
  537.                 CleanUp(n);
  538.                 //menu -> moveover = menu -> moveover ? 1 : 0;
  539.             }
  540.             moveover[k1][k2++] = menu -> moveover ? 1 : 0;
  541.             if(menu -> next == NULL)
  542.                 break;
  543.             menu = menu -> next;
  544.             k2 ++;
  545.             if(menu -> text[0] == '-')
  546.                 y -= 20;
  547.             y += 25;
  548.         }
  549.     }
  550.     else
  551.     {
  552.         for(i = 0; i < 10; i ++)
  553.             for(j = 0; j < 20; j ++)
  554.                 moveover[i][j] = 0;
  555.     }
  556. }
  557.  
  558. void ClearMenuMoveOver(void *n)
  559. /* Clear all move over states */
  560. {
  561.     State *s;
  562.     FormMenu *formmenu;
  563.     Menu *menu;
  564.     s = (State *)n;
  565.     formmenu = s -> menu;
  566.     while(formmenu -> next != NULL)
  567.     {
  568.         menu = formmenu -> menu;
  569.         while(menu -> next != NULL)
  570.         {
  571.             menu -> moveover = 0;
  572.             menu = menu -> next;
  573.         }
  574.         formmenu = formmenu -> next;
  575.     }
  576.     s -> isclearmenu = 1;
  577. }
  578.  
  579. Menu *GetUpMenu(FormMenu *formmenu, Menu *menu)
  580. /* Get the upper menu item */
  581. {
  582.     Menu *menutmp, *menusearch;
  583.     menusearch = menu;
  584.     while(1)
  585.     {
  586.         menutmp = formmenu -> menu;
  587.         while(menutmp -> next != NULL && menutmp -> next != menusearch)
  588.             menutmp = menutmp -> next;
  589.         if(menutmp -> next == menusearch && menutmp -> enabled != 0 &&
  590.             menutmp -> enabled != 4 && menutmp -> enabled != 5)
  591.             return menutmp;
  592.         else if(menutmp -> next == NULL && menutmp -> enabled != 0 &&
  593.             menutmp -> enabled != 4 && menutmp -> enabled != 5)
  594.             return menutmp;
  595.         menusearch = menutmp;
  596.     }
  597. }
  598.  
  599. Menu *GetDownMenu(FormMenu *formmenu, Menu *menu)
  600. /* Get the down menu item */
  601. {
  602.     Menu *menutmp;
  603.     menutmp = menu;
  604.    
  605.     while(menutmp != NULL)
  606.     {
  607.         menutmp = menutmp -> next;
  608.         if(menutmp != NULL && menutmp -> enabled != 0 && menutmp -> enabled != 4
  609.            && menutmp -> enabled != 5)
  610.             break;
  611.     }
  612.    
  613.     if(menutmp == NULL)
  614.     {
  615.         menutmp = formmenu -> menu;
  616.         while((menutmp -> enabled == 0 || menutmp -> enabled == 4 || menutmp -> enabled == 5) && menutmp -> next != NULL)
  617.             menutmp = menutmp -> next;
  618.     }
  619.     return menutmp;
  620. }
  621.  
  622. FormMenu *GetLeftFormMenu(State *s, FormMenu *formmenu)
  623. /* Get left form menu item */
  624. {
  625.     FormMenu *menutmp;
  626.     menutmp = s -> menu;
  627.     while(menutmp -> next != NULL && menutmp -> next != formmenu)
  628.         menutmp = menutmp -> next;
  629.     return menutmp;
  630. }
  631.  
  632. FormMenu *GetRightFormMenu(State *s, FormMenu *formmenu)
  633. /* Get right form menu item */
  634. {
  635.     FormMenu *menutmp;
  636.     menutmp = formmenu;
  637.     menutmp = menutmp -> next;
  638.     if(menutmp == NULL)
  639.         menutmp = s -> menu;
  640.     return menutmp;
  641. }
  642.  
  643. FormMenu *FindPressedFormMenu(void *n)
  644. /* Find the currently pressed form menu */
  645. {
  646.     State *s;
  647.     Menu *menu;
  648.     FormMenu *formmenu;
  649.     s = (State *)n;
  650.     formmenu = s -> menu;
  651.     while(formmenu -> next != NULL && !formmenu -> pressed)
  652.         formmenu = formmenu -> next;
  653.     if(!formmenu -> pressed)
  654.         return NULL;
  655.     return formmenu;
  656. }    
  657.  
  658. Menu *FindMoveOverMenu(void *n)
  659. /* Find the currently moving over menu item */
  660. {
  661.     Menu *menu;
  662.     FormMenu *formmenu;
  663.     formmenu = FindPressedFormMenu(n);
  664.     if(formmenu == NULL)
  665.         return NULL;
  666.     if(formmenu -> pressed)
  667.     {
  668.         menu = formmenu -> menu;
  669.         while(menu -> text != NULL)
  670.         {
  671.             if(menu -> moveover)
  672.                 return menu;
  673.             if(menu -> next == NULL)
  674.                 break;
  675.             menu = menu -> next;
  676.         }
  677.     }
  678.     return NULL;
  679. }
  680.  
  681. void MenuUp(void *n)
  682. /* Menu up! */
  683. {
  684.     Menu *menu, *menuup;
  685.     FormMenu *formmenu;
  686.     formmenu = FindPressedFormMenu(n);
  687.     if(formmenu == NULL)
  688.         return;
  689.     menu = FindMoveOverMenu(n);
  690.     if(menu != NULL)
  691.         menu -> moveover = 0;
  692.     menuup = GetUpMenu(formmenu, menu);
  693.     if(menuup != NULL)
  694.         menuup -> moveover = 1;
  695. }
  696.  
  697. void MenuDown(void *n)
  698. /* Menu down! */
  699. {
  700.     Menu *menu, *menudown;
  701.     FormMenu *formmenu;
  702.     formmenu = FindPressedFormMenu(n);
  703.     if(formmenu == NULL)
  704.         return;
  705.     menu = FindMoveOverMenu(n);
  706.     if(menu != NULL)
  707.         menu -> moveover = 0;
  708.     menudown = GetDownMenu(formmenu, menu);
  709.     if(menudown != NULL)
  710.         menudown -> moveover = 1;
  711. }
  712.  
  713. void FormMenuLeft(void *n)
  714. /* Move left form menu */
  715. {
  716.     State *s;
  717.     FormMenu *menu, *menuleft;
  718.     s = (State *)n;
  719.     menu = FindPressedFormMenu(n);
  720.     if(menu == NULL)
  721.         return;
  722.     menu -> pressed = 0;
  723.     menuleft = GetLeftFormMenu(s, menu);
  724.     menuleft -> pressed = 1;
  725. }
  726.  
  727. void FormMenuRight(void *n)
  728. /* Move right form menu */
  729. {
  730.     State *s;
  731.     FormMenu *menu, *menuright;
  732.     s = (State *)n;
  733.     menu = FindPressedFormMenu(n);
  734.     if(menu == NULL)
  735.         return;
  736.     menu -> pressed = 0;
  737.     menuright = GetRightFormMenu(s, menu);
  738.     menuright -> pressed = 1;
  739. }
  740.  
  741. void AddMenuToFormMenu(Menu *menu, FormMenu *formmenu)
  742. /* Add a menu to a form menu */
  743. {
  744.     FormMenu *tmp;
  745.     tmp = formmenu;
  746.     while(tmp -> next != NULL)
  747.     /* Add to the rear */
  748.         tmp = tmp -> next;
  749.     tmp -> menu = menu;
  750. }
  751.  
  752. void OpenMenu(FormMenu *menu, int n)
  753. /* Open a form menu */
  754. {
  755.     int i;
  756.     FormMenu *menutmp;
  757.     menutmp = menu;
  758.     for(i = 0; i < 5; i++)
  759.     {
  760.         if(i == n)
  761.             menutmp -> pressed = !menutmp -> pressed;
  762.         else
  763.             menutmp -> pressed = 0;
  764.         menutmp = menutmp -> next;
  765.     }
  766. }
  767.  
  768. void OpenMenu0(void *n)
  769. /* Open the first form menu */
  770. {
  771.     State *s;
  772.     s = (State *)n;
  773.     if(s -> ischildwindow)
  774.         return;
  775.     s -> isedit = 0;
  776.     OpenMenu(s -> menu, 0);
  777. }
  778.  
  779. void OpenMenu1(void *n)
  780. /* Open the second form menu */
  781. {
  782.     State *s;
  783.     s = (State *)n;
  784.     if(s -> ischildwindow)
  785.         return;
  786.     s -> isedit = 0;
  787.     OpenMenu(s -> menu, 1);
  788. }
  789.  
  790. void OpenMenu2(void *n)
  791. /* Open the third form menu */
  792. {
  793.     State *s;
  794.     s = (State *)n;
  795.     if(s -> ischildwindow)
  796.         return;
  797.     s -> isedit = 0;
  798.     OpenMenu(s -> menu, 2);
  799. }
  800.  
  801. void OpenMenu3(void *n)
  802. /* Open the forth form menu */
  803.  
  804. {
  805.     State *s;
  806.     s = (State *)n;
  807.     if(s -> ischildwindow)
  808.         return;
  809.     s -> isedit = 0;
  810.     OpenMenu(s -> menu, 3);
  811. }
  812.  
  813. void OpenMenu4(void *n)
  814. /* Open the fifth form menu */
  815.  
  816. {
  817.     State *s;
  818.     s = (State *)n;
  819.     if(s -> ischildwindow)
  820.         return;
  821.     s -> isedit = 0;
  822.     OpenMenu(s -> menu, 4);
  823. }
  824.  
  825. void ChildTitleContextMenu(void *n)
  826. /* Context menu operations */
  827. {
  828.     int t;
  829.     State *s;
  830.     s = (State *)n;
  831.     if(!s -> ischildwindow)
  832.         return;
  833.     if(s -> iscontextmenu && (s -> mouse . key || (s -> keyboard . key & 0xFF00) == ESC ||
  834.       (s -> keyboard . key & 0xff00) == SPACE &&
  835.       (s -> keyboard . modifier & ALT)))
  836.     {
  837.         //CleanUp(n);
  838.         //DrawMainWindow(n);
  839.         //DrawStatusBox(n);
  840.         //DoEvent(s -> redraw, n);
  841.         //CleanUp(n);
  842.         t = s -> ischildwindow;
  843.         s -> ischildwindow = -1;
  844.         switch(t)
  845.         {
  846.             case 1:
  847.             {
  848.                 DrawOpenWindow(n);
  849.                 break;
  850.             }
  851.             case 2:
  852.             {
  853.                 DrawSaveWindow(n);
  854.                 break;
  855.             }
  856.             case 3:
  857.             {
  858.                 DrawSaveAsWindow(n);
  859.                 break;
  860.             }
  861.             case 4:
  862.             {
  863.                 DrawFindWindow(n);
  864.                 break;
  865.             }
  866.             case 5:
  867.             {
  868.                 DrawReplaceWindow(n);
  869.                 break;
  870.             }
  871.         }
  872.         s -> mouse . key = 0;
  873.         s -> keyboard . key = -1;
  874.         s -> iscontextmenu = 0;
  875.         if(t < 99)
  876.             s -> isedit = 1;
  877.     }
  878.     else if(s -> mouse . key == 2 && PinRA(
  879.                     s -> mouse . x, s -> mouse . y,
  880.                     s -> childx1, s -> childy1,
  881.                     s -> childx2 - 23, s -> childy1 + 20) ||
  882.                     (s -> keyboard . key & 0xff00) == SPACE &&
  883.                     (s -> keyboard . modifier & ALT))
  884.     {
  885.         CleanUp(n);
  886.         if(!PinRA(
  887.                     s -> mouse . x, s -> mouse . y,
  888.                     s -> childx1, s -> childy1,
  889.                     s -> childx2 - 23, s -> childy1 + 20))
  890.         {
  891.             CleanUp(n);
  892.             s -> mouse . x = s -> childx1;
  893.             s -> mouse . y = s -> childy1;
  894.             SetMouseXY(s -> childx1, s -> childy1);
  895.             CleanUp(n);
  896.         }
  897.         s -> iscontextmenu = 1;
  898.         DrawMenu(n, s -> contextmenu, s -> mouse . x, s -> mouse . y);
  899.         CleanUp(n);
  900.         s -> cmmousex = s -> mouse . x;
  901.         s -> cmmousey = s -> mouse . y;
  902.         //s -> isedit = 0;
  903.     }
  904. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement