home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / DLOG.C < prev    next >
C/C++ Source or Header  |  1996-03-21  |  15KB  |  740 lines
  1. /*
  2.  *    ダイヤログボックス制御
  3.  *
  4.  *        Copyright    T.Kobayashi        1994.7.24
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <assert.h>
  11.  
  12. #define        iskanji( c )    ( ( (c) & 0x80 ) != 0 )
  13.  
  14. #include "graph.h"
  15. #include "input.h"
  16. #include "ml.h"
  17.  
  18. #include "dlog.h"
  19. #include "model.h"
  20.  
  21. #define ESC            0x1B
  22. #define    RET            0x0D
  23. #define TAB            9
  24. #define BS            8
  25. #define    DEL            7
  26. #define    FUNC_DEL    KEY_DEL /*(0x8000 + 24)*/
  27. #define    LEFT        ('S'-'A'+1)
  28. #define    RIGHT        ('D'-'A'+1)
  29. #define    FUNC_LEFT    KEY_LEFT /*(0x8000 + 26)*/
  30. #define    FUNC_RIGHT    KEY_RIGHT /*(0x8000 + 27)*/
  31. #define    UP            ('E'-'A'+1)
  32. #define    DOWN        ('X'-'A'+1)
  33. #define    FUNC_UP        KEY_UP /*(0x8000 + 25)*/
  34. #define    FUNC_DOWN    KEY_DOWN /*(0x8000 + 28)*/
  35.  
  36. #define    EVENT_MOUSE        0
  37. #define    EVENT_KEY        1
  38.  
  39. #define    DLOG_STEP    FontV
  40. #define    DLOG_OFFSET    (FontV*2)
  41. #define    MAX_FIELD    30
  42. #define DLOG_MAX_BUTTON 5
  43.  
  44. extern int    QuitFlag;
  45.  
  46. static    int        x1, y1, x2, y2 ;
  47.  
  48. static    DlogData    Dlog[MAX_FIELD];
  49. static    int        KeyField ;
  50.  
  51. static    void    SliderDisplay( SliderData* );
  52. static    int        SliderConv( SliderData* );
  53. static    int        _DlogWait( void );
  54. static    int        isSwitch( EventData* );
  55. static    void    ChangeKeyField( void );
  56. static    void    EventString( int, int );
  57. static    void    EventToggle( int );
  58. static    void    EventSelect( int );
  59. static    void    EventSlider( int );
  60. static    int    ConvertNumpadToChar(int);
  61.  
  62. EventData    DlogSwitch[DLOG_MAX_BUTTON];
  63. int    DlogSwitches;
  64. #if 0
  65. EventData    SwitchOK, SwitchCancel ;
  66. /*    ダイヤログウインドウのオープン    */
  67. void    DlogOpen( title, fields, sw )
  68. char    *title ;
  69. int        fields ;
  70. int        sw ;
  71. #endif
  72.  
  73. /*    ダイヤログウインドウのオープン    */
  74. void    DlogOpen( title, fields, button )
  75. char    *title ;
  76. int        fields ;
  77. char    *button[];
  78. {
  79.     int        i, x ;
  80.  
  81.     ViewCursor( OFF );
  82. #ifdef    X68K
  83.     x1 = 80 ;
  84.     x2 = DISPLAY_X - 80 ;
  85.     y1 = 80 ;
  86. #endif
  87. #ifdef    PC98
  88.     x1 = 24 ;
  89.     x2 = DISPLAY_X - 24 ;
  90.     y1 = 32 ;
  91. #endif
  92. #ifdef    PC
  93.     x1 = 80 ;
  94.     x2 = DISPLAY_X - 80 ;
  95.     y1 = 80 ;
  96. #endif
  97. #ifdef    WINDOWS
  98.     x1 = 80 ;
  99.     x2 = DISPLAY_X - 80 ;
  100.     y1 = 80 ;
  101. #endif
  102.  
  103.     y2 = y1 + DLOG_STEP * fields + FontV * 5 ;
  104.  
  105.     graph_push(x1, y1, x2-x1+1, y2-y1+1);
  106. #ifdef    X68K
  107.     graph_fill( x1+1, y1+1, x2-1, y2-1, TMP_COLOR );
  108. #endif
  109.     graph_fill( x1+1, y1+1, x2-1, y2-1, FRAME_COLOR );
  110.     graph_box( x1, y1, x2, y2, TRUE );
  111.  
  112.     graph_puts( title, x1+16, y1+3, FRAME_COLOR << 4 );
  113.     graph_line( x1+1, y1+21, x2-1, y1+21, 0 );
  114.     graph_line( x1, y1+22, x2, y1+22, 7 );
  115.  
  116.     x = x2 - 36;
  117.     for (i = 0; button[i] != NULL; i++) {
  118.         int len;
  119.         len = strlen(button[i]);
  120.         if (len == 0) {
  121.             DlogSwitch[i].x1 = DlogSwitch[i].y1 = DlogSwitch[i].x2 = DlogSwitch[i].y2 = 0;
  122.         } else {
  123.             DlogSwitch[i].x2 = x;
  124.             DlogSwitch[i].x1 = x - (len+2) * FontH;
  125.             DlogSwitch[i].y1 = y2 - 32 - 4;
  126.             DlogSwitch[i].y2 = DlogSwitch[i].y1 + FontV + 9;
  127.             graph_box( DlogSwitch[i].x1, DlogSwitch[i].y1, DlogSwitch[i].x2, DlogSwitch[i].y2, TRUE );
  128.             graph_puts( button[i], DlogSwitch[i].x1+FontH, DlogSwitch[i].y1+4, FRAME_COLOR << 4 );
  129.             x -= (len+3) * FontH;
  130.         }
  131.     }
  132.     DlogSwitches = i;
  133. #if 0
  134.     if ( sw )
  135.     {
  136.         SwitchOK.x1 = x2 - 132 ;
  137.         SwitchOK.y1 = y2 - 32 - 4 ;
  138.         SwitchOK.x2 = x2 - 88 ;
  139.         SwitchOK.y2 = SwitchOK.y1 + FontV + 9 ;
  140.         graph_box( SwitchOK.x1, SwitchOK.y1, SwitchOK.x2, SwitchOK.y2, TRUE );
  141.         graph_puts( "決定", SwitchOK.x1+8, SwitchOK.y1+4, FRAME_COLOR << 4 );
  142.  
  143.         SwitchCancel.x1 = x2 - 80 ;
  144.         SwitchCancel.y1 = y2 - 32 - 4 ;
  145.         SwitchCancel.x2 = x2 - 36 ;
  146.         SwitchCancel.y2 = SwitchCancel.y1 + FontV + 9 ;
  147.         graph_box( SwitchCancel.x1, SwitchCancel.y1, SwitchCancel.x2, SwitchCancel.y2, TRUE );
  148.         graph_puts( "中止", SwitchCancel.x1+8, SwitchCancel.y1+4, FRAME_COLOR << 4 );
  149.     }
  150.     else
  151.     {
  152.         SwitchOK.x1 = x2 - 80 ;
  153.         SwitchOK.y1 = y2 - 32 - 4 ;
  154.         SwitchOK.x2 = x2 - 36 ;
  155.         SwitchOK.y2 = SwitchOK.y1 + FontV + 9 ;
  156.         graph_box( SwitchOK.x1, SwitchOK.y1, SwitchOK.x2, SwitchOK.y2, TRUE );
  157.         graph_puts( "確認", SwitchOK.x1+8, SwitchOK.y1+4, FRAME_COLOR << 4 );
  158.  
  159.         SwitchCancel.x1 = 0 ;
  160.         SwitchCancel.y1 = 0 ;
  161.         SwitchCancel.x2 = 0 ;
  162.         SwitchCancel.y2 = 0 ;
  163.     }
  164. #endif
  165.     for( i = 0 ; i < MAX_FIELD ; i++ )
  166.         Dlog[i].type = 0 ;
  167.     KeyField = -1 ;
  168. }
  169.  
  170. /*    メッセージの表示    */
  171. int        DlogMessage( field, msg )
  172. int        field ;
  173. char    *msg ;
  174. {
  175.     graph_puts( msg, x1+16, y1+DLOG_OFFSET+field*DLOG_STEP, FRAME_COLOR << 4 );
  176.  
  177.     return x1 + 16 + 16 + strlen( msg ) * FontH ;
  178. }
  179.  
  180. /*    文字列入力フィールド表示    */
  181. void    DlogString( field, msg, str, max, wild )
  182. int        field ;
  183. char    *msg ;
  184. char    *str ;
  185. int        max ;
  186. char    *wild;
  187. {
  188.     StringData    *sd ;
  189.  
  190.     Dlog[field].type = DLOG_STRING ;
  191.     sd = &Dlog[field].str ;
  192.     sd->func = EventString ;
  193.     sd->max = max ;
  194.     strcpy( sd->str, str );
  195.  
  196.     sd->x1 = DlogMessage( field, msg );
  197.     sd->y1 = y1 + DLOG_OFFSET + field * DLOG_STEP ;
  198.     sd->x2 = sd->x1 + max * FontH - 1  ;
  199.     sd->y2 = sd->y1 + FontV - 1 ;
  200.  
  201.     graph_puts( str, sd->x1, sd->y1, FRAME_COLOR << 4 );
  202.     graph_box( sd->x1-2, sd->y1-2, sd->x2+2, sd->y2+2, FALSE );
  203.  
  204.     if ( KeyField < 0 )
  205.     {
  206.         KeyField = field ;
  207.         Locate( sd->x1/FontH + strlen( str ), sd->y1/FontV );
  208.     }
  209.     CursorON();
  210. }
  211.  
  212. /*    トグルスイッチ表示    */
  213. void    DlogToggle( field, msg, str, sw )
  214. int        field ;
  215. char    *msg, *str ;
  216. int        sw ;
  217. {
  218.     ToggleData    *td ;
  219.  
  220.     Dlog[field].type = DLOG_TOGGLE ;
  221.     td = &Dlog[field].toggle ;
  222.     td->func = EventToggle ;
  223.     td->x1 = DlogMessage( field, msg );
  224.     td->y1 = y1 + DLOG_OFFSET + field * DLOG_STEP ;
  225.     td->x2 = td->x1 + strlen( str ) * FontH ;
  226.     td->y2 = td->y1 + FontV - 1 ;
  227.     td->stat = sw ;
  228.  
  229.     graph_puts( str, td->x1, td->y1, FRAME_COLOR << 4 );
  230.     graph_box( td->x1-4, td->y1-4, td->x2+4, td->y2+4, ! sw );
  231. }
  232.  
  233. /*    選択スイッチ表示    */
  234. void    DlogSelect( field, msg, item, stat )
  235. int        field ;
  236. char    *msg ;
  237. char    **item ;
  238. int        stat ;
  239. {
  240.     int        i, len, n, max ;
  241.     int        x ;
  242.     SelectData    *sd ;
  243.  
  244.     max = 0 ;
  245.     for( n = 0 ; item[n] != NULL ; n++ )
  246.     {
  247.         len = strlen( item[n] ) ;
  248.         if ( max < len )
  249.             max = len ;
  250.     }
  251.  
  252.     Dlog[field].type = DLOG_SELECT ;
  253.     sd = &Dlog[field].select ;
  254.     sd->func = EventSelect ;
  255.     sd->x1 = DlogMessage( field, msg );
  256.     sd->y1 = y1 + DLOG_OFFSET + field * DLOG_STEP ;
  257.     sd->x2 = sd->x1 + ( max + 1 ) * FontH * n ;
  258.     sd->y2 = sd->y1 + FontV - 1 ;
  259.     sd->step = ( max + 1 ) * FontH ;
  260.     sd->sels = n ;
  261.     sd->stat = stat ;
  262.  
  263.     x = sd->x1 ;
  264.     for( i = 0 ; i < n ; i++ )
  265.     {
  266.         graph_puts( item[i], x, sd->y1, FRAME_COLOR << 4 );
  267.         graph_box( x-4, sd->y1-4, x+sd->step-5, sd->y2+4, ! ( stat == i ) );
  268.         x += sd->step ;
  269.     }
  270. }
  271.  
  272. /*    スライドスイッチ表示    */
  273. void    DlogSlider( field, msg, size, step, start, ident )
  274. int        field ;
  275. char    *msg ;
  276. int        size, step, start, ident ;
  277. {
  278.     SliderData    *sd ;
  279.  
  280.     Dlog[field].type = DLOG_SLIDER ;
  281.     sd = &Dlog[field].slider ;
  282.     sd->func = EventSlider ;
  283.     sd->x1 = DlogMessage( field, msg );
  284.     sd->y1 = y1 + DLOG_OFFSET + field * DLOG_STEP + 3 ;
  285.     sd->x2 = sd->x1 + size + FontV ;
  286.     sd->y2 = sd->y1 + 10 - 1 ;
  287.     sd->size = size ;
  288.     sd->step = step;
  289.     sd->count = start ;
  290.     sd->ident = ident ;
  291.  
  292.     graph_box( sd->x1-1, sd->y1-1, sd->x2+1, sd->y2+1, FALSE );
  293.  
  294.     SliderDisplay( sd );
  295. }
  296.  
  297. static    void    SliderDisplay( sd )
  298. SliderData    *sd ;
  299. {
  300.     int        slider ;
  301.     char    str[10] ;
  302.  
  303.     slider = sd->x1 + sd->count * sd->size / (sd->step-1);
  304.     graph_fill( sd->x1, sd->y1, sd->x2, sd->y2, FRAME_COLOR );
  305.     graph_box( slider, sd->y1, slider+FontV, sd->y2, TRUE );
  306.  
  307.     sprintf( str, "%6d", SliderConv( sd ) );
  308.     graph_puts( str, sd->x2 + 16, sd->y1 - 2, FRAME_COLOR<<4 );
  309. }
  310.  
  311. static    int        SliderConv( sd )
  312. SliderData    *sd ;
  313. {
  314.     int            slider ;
  315.     DataStruct    *mark ;
  316.  
  317.     if ( sd->ident >= 0 )
  318.     {
  319.         mark = StackTop();
  320.         StackPushInt( sd->count );
  321.  
  322.         CallFunction( sd->ident, 1, mark+1 );
  323.         slider = mark[1].id.i ;
  324.         StackRelease( mark );
  325.     }
  326.     else
  327.     {
  328.         slider = sd->count ;
  329.     }
  330.     return slider ;
  331. }
  332.  
  333. /*    入力待ち    */
  334. int        DlogWait()
  335. {
  336.     int        ret ;
  337.  
  338.     ret = _DlogWait();
  339.     CursorOFF();
  340.     if (graph_pop() == FALSE) {
  341.         ViewFrame();
  342.         ViewLineAll( x1, y1, x2, y2, TRUE );
  343.         DrawTitleBar();
  344.         DrawUserButtonAll();
  345.         DrawControlPanel();
  346.     }
  347.  
  348.     ViewCursor( ON );
  349.     return ret ;
  350. }
  351.  
  352. static    int        _DlogWait()
  353. {
  354.     int        i ;
  355.  
  356.     for(;;)
  357.     {
  358.         WaitMouseOrKey();
  359.         if (QuitFlag) {
  360.             return 0;
  361.         }
  362.         switch( KeyCode )
  363.         {
  364.             case ESC:
  365.                 return 0 ;
  366.             case RET:
  367.             case KEY_NUMPAD_ENTER:
  368.                 return RET ;
  369.             case TAB:
  370.                 if (ShiftStat & 1) {
  371.                     for( i = KeyField - 1 ; i >= 0 ; i-- )
  372.                     {
  373.                         if ( Dlog[i].type == DLOG_STRING )
  374.                             break ;
  375.                     }
  376.                     if (i < 0) {
  377.                         for (i = MAX_FIELD-1; i >= KeyField; i--) {
  378.                             if ( Dlog[i].type == DLOG_STRING )
  379.                                 break ;
  380.                         }
  381.                     }
  382.                     if ( i >= 0 )
  383.                     {
  384.                         KeyField = i ;
  385.                         ChangeKeyField();
  386.                     }
  387.                 } else {
  388.                     for( i = KeyField + 1 ; i < MAX_FIELD ; i++ )
  389.                     {
  390.                         if ( Dlog[i].type == DLOG_STRING )
  391.                             break ;
  392.                     }
  393.                     if (i >= MAX_FIELD) {
  394.                         for (i = 0; i <= KeyField; i++) {
  395.                             if ( Dlog[i].type == DLOG_STRING )
  396.                                 break ;
  397.                         }
  398.                     }
  399.                     if ( i < MAX_FIELD )
  400.                     {
  401.                         KeyField = i ;
  402.                         ChangeKeyField();
  403.                     }
  404.                 }
  405.                 break;
  406.             case UP:
  407.             case FUNC_UP:
  408.                 for( i = KeyField - 1 ; i >= 0 ; i-- )
  409.                 {
  410.                     if ( Dlog[i].type == DLOG_STRING )
  411.                         break ;
  412.                 }
  413.                 if ( i >= 0 )
  414.                 {
  415.                     KeyField = i ;
  416.                     ChangeKeyField();
  417.                 }
  418.                 break ;
  419.             case DOWN:
  420.             case FUNC_DOWN:
  421.                 for( i = KeyField + 1 ; i < MAX_FIELD ; i++ )
  422.                 {
  423.                     if ( Dlog[i].type == DLOG_STRING )
  424.                         break ;
  425.                 }
  426.                 if ( i < MAX_FIELD )
  427.                 {
  428.                     KeyField = i ;
  429.                     ChangeKeyField();
  430.                 }
  431.                 break ;
  432.             default:
  433.                 if ( KeyCode > 0 && KeyField >= 0 )
  434.                     (*Dlog[KeyField].event.func)( KeyField, EVENT_KEY );
  435.         }
  436.         if ( MouseLeft || MouseRight )
  437.         {
  438.             for( i = 0 ; i < MAX_FIELD ; i++ )
  439.             {
  440.                 if ( Dlog[i].type > 0 &&
  441.                     Dlog[i].event.x1 < MouseX && MouseX < Dlog[i].event.x2 &&
  442.                     Dlog[i].event.y1 < MouseY && MouseY < Dlog[i].event.y2 )
  443.                 {
  444.                     (*Dlog[i].event.func)( i, EVENT_MOUSE );
  445.                 }
  446.             }
  447.             for (i = 0; i < DlogSwitches; i++) {
  448.                 if (isSwitch( &(DlogSwitch[i]))) {
  449.                     return i;
  450.                 }
  451.             }
  452. #if 0
  453.             if ( isSwitch( &SwitchOK ) )
  454.                 return TRUE ;
  455.             if ( isSwitch( &SwitchCancel ) )
  456.                 return FALSE ;
  457. #endif
  458.         }
  459.     }
  460.     return 0 ;
  461. }
  462.  
  463. static    int        isSwitch( sw )
  464. EventData    *sw ;
  465. {
  466.     if ( sw->x1 <= MouseX && MouseX <= sw->x2 && sw->y1 <= MouseY && MouseY <= sw->y2 )
  467.     {
  468.         graph_box( sw->x1, sw->y1, sw->x2, sw->y2, FALSE );
  469.         WaitMouseOff();
  470.         return TRUE ;
  471.     }
  472.     return FALSE ;
  473. }
  474.  
  475. static    void    ChangeKeyField()
  476. {
  477.     int        x, y ;
  478.     StringData    *sd ;
  479.  
  480.     GetCursorPosition( &x, &y );
  481.     sd = &Dlog[KeyField].str ;
  482.  
  483.     y = sd->y1 / FontV ;
  484.     if ( x > sd->x1 / FontH + strlen( sd->str ) )
  485.         x = sd->x1 / FontH + strlen( sd->str );
  486.     Locate( x, y );
  487. }
  488.  
  489. /*    文字列入力のイベント処理ルーチン    */
  490. static    void    EventString( n, event )
  491. int        n ;
  492. int        event ;
  493. {
  494.     int    keycode;
  495.     int        x, y ;
  496.     int        i, j, px, top, cur, len ;
  497.     char    *p ;
  498.     static    int        kanji ;
  499.     StringData    *sd ;
  500.  
  501.     sd = &Dlog[n].str ;
  502.  
  503.     switch( event )
  504.     {
  505.         case EVENT_MOUSE:
  506.             x = ( MouseX - sd->x1 ) / FontH ;
  507.             if ( x > strlen( sd->str ) )
  508.                 x = strlen( sd->str );
  509.             Locate( x + sd->x1/FontH, MouseY/FontV );
  510.             KeyField = n ;
  511.             break ;
  512.         case EVENT_KEY:
  513.             GetCursorPosition( &cur, &y );
  514.             y = sd->y1 / FontV ;
  515.             top = sd->x1 / FontH ;
  516.             cur = cur - top ;
  517.             Locate( top+cur, y );
  518.  
  519.             p = sd->str + cur ;
  520.             len = strlen( sd->str );
  521.  
  522.             px = -1 ;
  523.             kanji = 0 ;
  524.  
  525.             keycode = ConvertNumpadToChar(KeyCode);
  526.  
  527.             switch( keycode )
  528.             {
  529.                 case BS :
  530.                     if ( cur > 1 && iskanji( *(p-2) ) )
  531.                     {
  532.                         cur -= 2 ;
  533.                         p -= 2 ;
  534.                     }
  535.                     else if ( cur > 0 )
  536.                     {
  537.                         cur -- ;
  538.                         p -- ;
  539.                     }
  540.                     else
  541.                         break ;
  542.                 case DEL :
  543.                 case FUNC_DEL :
  544.                     if ( cur < len )
  545.                     {
  546.                         if ( iskanji( *p ) )
  547.                         {
  548.                             memcpy( p, p+2, len - cur );
  549.                             len -= 2 ;
  550.                         }
  551.                         else
  552.                         {
  553.                             memcpy( p, p+1, len - cur );
  554.                             len -- ;
  555.                         }
  556.                         sd->str[len] = '\0' ;
  557.                         px = cur ;
  558.                     }
  559.                     break ;
  560.                 case LEFT :
  561.                 case FUNC_LEFT :
  562.                     i = 0 ;
  563.                     do
  564.                     {
  565.                         j = i ;
  566.                         if ( iskanji( sd->str[i] ) )
  567.                                 i += 2 ;
  568.                         else
  569.                             i ++ ;
  570.                     }
  571.                     while( i < cur );
  572.                     cur = j ;
  573.                     break ;
  574.                 case RIGHT :
  575.                 case FUNC_RIGHT :
  576.                     if ( cur < len && cur < sd->max - 1 )
  577.                     {
  578.                         if ( iskanji( *p ) )
  579.                             cur += 2 ;
  580.                         else
  581.                             cur ++ ;
  582.                     }
  583.                     break ;
  584.                 default :
  585.                     if ( ( keycode & 0xFF ) >= ' ' )
  586.                     {
  587.                         if ( len < sd->max )
  588.                             memcpy( p+1, p, len-cur+1 );
  589.                         *p = keycode ;
  590.                         if ( kanji == 0 )
  591.                         {
  592.                             if ( iskanji( keycode ) )
  593.                             {
  594.                                 px = -1 ;
  595.                                 kanji = keycode ;
  596.                             }
  597.                             else
  598.                                 px = cur ;
  599.                         }
  600.                         else
  601.                         {
  602.                             px = cur - 1 ;
  603.                             p -- ;
  604.                             kanji = 0 ;
  605.                         }
  606.                         if ( cur < sd->max - 1 )
  607.                             cur ++ ;
  608.                     }
  609.                     break ;
  610.             }
  611.             if ( px >= 0 )
  612.             {
  613.                 graph_puts( sd->str, sd->x1, sd->y1, FRAME_COLOR << 4 );
  614.                 graph_puts( " ", sd->x1+strlen(sd->str)*FontH, sd->y1, FRAME_COLOR << 4 );
  615.             }
  616.             Locate( top+cur, y );
  617.             break ;
  618.     }
  619. }
  620.  
  621. /*    トグルスイッチのイベント処理ルーチン    */
  622. static    void    EventToggle( n )
  623. int        n ;
  624. {
  625.     ToggleData    *td ;
  626.  
  627.     td = &Dlog[n].toggle ;
  628.     td->stat = ! td->stat ;
  629.     graph_box( td->x1-4, td->y1-4, td->x2+4, td->y2+4, ! td->stat );
  630.     WaitMouseOff();
  631. }
  632.  
  633. /*    選択スイッチのイベント処理ルーチン    */
  634. static    void    EventSelect( n )
  635. int        n ;
  636. {
  637.     int        i, x ;
  638.     SelectData    *sd ;
  639.  
  640.     sd = &Dlog[n].select ;
  641.     n = ( MouseX + 4 - sd->x1 ) / sd->step ;
  642.     if ( 0 <= n && n < sd->sels )
  643.     {
  644.         for( i = 0 ; i < 2 ; i++ )
  645.         {
  646.             x = sd->x1 + sd->step * sd->stat ;
  647.             graph_box( x-4, sd->y1-4, x+sd->step-5, sd->y2+4, i == 0 );
  648.             sd->stat = n ;
  649.         }
  650.     }
  651.     WaitMouseOff();
  652. }
  653.  
  654. /*    スライドスイッチのイベント処理ルーチン    */
  655. static    void    EventSlider( n )
  656. int        n ;
  657. {
  658.     SliderData    *sd ;
  659.  
  660.     sd = &Dlog[n].slider ;
  661.     sd->count = ((MouseX - 8 - sd->x1) * (sd->step-1) + sd->size/2) / sd->size;
  662.     if ( sd->count < 0 )
  663.         sd->count = 0 ;
  664.     if ( sd->count >= sd->step)
  665.         sd->count = sd->step - 1 ;
  666.  
  667.     SliderDisplay( sd );
  668. }
  669.  
  670. /*    答を得る    */
  671. int        DlogAnswer( n, str, ip )
  672. int        n ;
  673. char    *str ;
  674. int        *ip ;
  675. {
  676.     switch( Dlog[n].type )
  677.     {
  678.         case DLOG_STRING:
  679.             strcpy( str, Dlog[n].str.str );
  680.             return DLOG_STRING ;
  681.         case DLOG_TOGGLE:
  682.             *ip = Dlog[n].toggle.stat ;
  683.             return DLOG_TOGGLE ;
  684.         case DLOG_SELECT:
  685.             *ip = Dlog[n].select.stat ;
  686.             return DLOG_SELECT ;
  687.         case DLOG_SLIDER:
  688.             *ip = Dlog[n].slider.count ;
  689.             return DLOG_SLIDER ;
  690.         default:
  691.             return 0 ;
  692.     }
  693. }
  694.  
  695. static    int    ConvertNumpadToChar(int c)
  696. {
  697.     switch (c) {
  698.     case KEY_NUMPAD_0:
  699.         return '0';
  700.     case KEY_NUMPAD_1:
  701.         return '1';
  702.     case KEY_NUMPAD_2:
  703.         return '2';
  704.     case KEY_NUMPAD_3:
  705.         return '3';
  706.     case KEY_NUMPAD_4:
  707.         return '4';
  708.     case KEY_NUMPAD_5:
  709.         return '5';
  710.     case KEY_NUMPAD_6:
  711.         return '6';
  712.     case KEY_NUMPAD_7:
  713.         return '7';
  714.     case KEY_NUMPAD_8:
  715.         return '8';
  716.     case KEY_NUMPAD_9:
  717.         return '9';
  718.     case KEY_NUMPAD_SLASH:
  719.         return '/';
  720.     case KEY_NUMPAD_ASTERISK:
  721.         return '*';
  722.     case KEY_NUMPAD_MINUS:
  723.         return '-';
  724.     case KEY_NUMPAD_PLUS:
  725.         return '+';
  726.     case KEY_NUMPAD_EQUAL:
  727.         return '=';
  728.     case KEY_NUMPAD_ENTER:
  729.         return 0x0d;
  730.     case KEY_NUMPAD_COMMA:
  731.         return ',';
  732.     case KEY_NUMPAD_PERIOD:
  733.         return '.';
  734.     default:
  735.         return c;
  736.     }
  737. }
  738.  
  739.  
  740.