home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / MAIN.CPP < prev    next >
C/C++ Source or Header  |  1996-07-23  |  19KB  |  780 lines
  1. //
  2. //        OWL メイン関数
  3. //
  4. //        1996.1.6        T.Kobayashi
  5. //
  6.  
  7. #include <owl\owlpch.h>
  8. #include <owl\applicat.h>
  9. #include <owl\framewin.h>
  10. #include <owl\menu.h>
  11.  
  12. #include <stdio.h>
  13. #include <dos.h>
  14. #include <ctype.h>
  15. #include <jctype.h>
  16. #include <assert.h>
  17.  
  18. #include "ml.h"
  19. #include "message.h"
  20. #include "input.h"
  21. #include "menu.h"
  22. #include "button.h"
  23. #include "model.h"
  24. #include "model.rh"
  25.  
  26. extern "C" void SetWindowsMenu(int no);
  27.  
  28. //    外部参照
  29. extern "C" void    ViewSetDisplay(int h, int v);
  30. extern "C" void    ModelMain( int, char** );
  31. extern "C" void    RedrawAll( void );
  32. extern    int        QuitFlag ;
  33. extern    int    IdentCanClose;
  34. extern    MenuClass    *Menu[MAX_MENU] ;
  35. extern    int        Display_X, Display_Y;
  36.  
  37. //
  38. //        メインウインドウ
  39. //
  40. class    TMyWindow : public TFrameWindow {
  41.     public:
  42.         TMyWindow();
  43.         ~TMyWindow();
  44.  
  45.         int        KeyCode ;
  46.         int        ShiftStat ;
  47.         int        KanjiFlag ;
  48.         int        MouseX, MouseY ;
  49.         int        MouseLeft, MouseRight ;
  50.         int        MouseMove ;
  51.         int        CreateFlag ;
  52.         TMenu    *MenuRoot;
  53.         TPopupMenu    *MenuSub[MAX_MENU];
  54.  
  55.         void    KeyIn( int key )
  56.         {
  57.             KeyCode = key ;
  58.         }
  59.  
  60.     protected:
  61.         virtual BOOL CanClose();
  62.         virtual void SetupWindow ();
  63.  
  64.         // メッセージ応答関数
  65.         void    Paint( TDC&, BOOL, TRect& );
  66.         void    EvChar( UINT key, UINT count, UINT flags );
  67.         void    EvKeyDown( UINT key, UINT count, UINT flags );
  68.         void    EvKeyUp( UINT key, UINT count, UINT flags );
  69.         void    EvLButtonDown( UINT modkeys, TPoint& point );
  70.         void    EvRButtonDown( UINT modkeys, TPoint& point );
  71.         void    EvLButtonUp( UINT modkeys, TPoint& point );
  72.         void    EvRButtonUp( UINT modkeys, TPoint& point );
  73.         void    EvLButtonDblClk( UINT modkeys, TPoint& point );
  74.         void    EvRButtonDblClk( UINT modkeys, TPoint& point );
  75.         void    EvMouseMove( UINT modkeys, TPoint& point );
  76.         void    EvSize( UINT, TSize& );
  77.         void    EvWindowPosChanging(WINDOWPOS far &windowPos);    // 96/1/9 Taka2
  78.         void    EvMenu(WPARAM param);
  79.         void    EvMenuEnable(TCommandEnabler &tce);
  80.         void    EvPaletteChanged(HWND hWndPalChg);
  81.         void    EvPaletteIsChanging(HWND hWndPalChg);
  82.         BOOL    EvQueryNewPalette();
  83.  
  84.     DECLARE_RESPONSE_TABLE(TMyWindow);
  85. };
  86.  
  87. #define EV_COMMAND_AND_ID_64(start, func)    \
  88.     EV_COMMAND_AND_ID_16((start),    func),\
  89.     EV_COMMAND_AND_ID_16((start)+16, func),\
  90.     EV_COMMAND_AND_ID_16((start)+32, func),\
  91.     EV_COMMAND_AND_ID_16((start)+48, func)
  92. #define EV_COMMAND_AND_ID_16(start, func)    \
  93.     EV_COMMAND_AND_ID_4((start),    func),\
  94.     EV_COMMAND_AND_ID_4((start)+ 4, func),\
  95.     EV_COMMAND_AND_ID_4((start)+ 8, func),\
  96.     EV_COMMAND_AND_ID_4((start)+12, func)
  97. #define EV_COMMAND_AND_ID_4(start, func)    \
  98.     EV_COMMAND_AND_ID((start),   func),\
  99.     EV_COMMAND_AND_ID((start)+1, func),\
  100.     EV_COMMAND_AND_ID((start)+2, func),\
  101.     EV_COMMAND_AND_ID((start)+3, func)
  102.  
  103. #define EV_COMMAND_ENABLE_64(start, func)    \
  104.     EV_COMMAND_ENABLE_16((start),    func),\
  105.     EV_COMMAND_ENABLE_16((start)+16, func),\
  106.     EV_COMMAND_ENABLE_16((start)+32, func),\
  107.     EV_COMMAND_ENABLE_16((start)+48, func)
  108. #define EV_COMMAND_ENABLE_16(start, func)    \
  109.     EV_COMMAND_ENABLE_4((start),    func),\
  110.     EV_COMMAND_ENABLE_4((start)+ 4, func),\
  111.     EV_COMMAND_ENABLE_4((start)+ 8, func),\
  112.     EV_COMMAND_ENABLE_4((start)+12, func)
  113. #define EV_COMMAND_ENABLE_4(start, func)    \
  114.     EV_COMMAND_ENABLE((start),   func),\
  115.     EV_COMMAND_ENABLE((start)+1, func),\
  116.     EV_COMMAND_ENABLE((start)+2, func),\
  117.     EV_COMMAND_ENABLE((start)+3, func)
  118.  
  119. DEFINE_RESPONSE_TABLE1(TMyWindow, TFrameWindow)
  120.     EV_WM_CHAR,
  121.     EV_WM_KEYDOWN,
  122.     EV_WM_KEYUP,
  123.     EV_WM_LBUTTONDOWN,
  124.     EV_WM_RBUTTONDOWN,
  125.     EV_WM_LBUTTONUP,
  126.     EV_WM_RBUTTONUP,
  127.     EV_WM_LBUTTONDBLCLK,
  128.     EV_WM_RBUTTONDBLCLK,
  129.     EV_WM_MOUSEMOVE,
  130.     EV_WM_SIZE,
  131.     EV_WM_WINDOWPOSCHANGING,
  132.     EV_WM_PALETTECHANGED,
  133.     EV_WM_PALETTEISCHANGING,
  134.     EV_WM_QUERYNEWPALETTE,
  135.  
  136.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 0*KEY_MENU_STEP, EvMenuEnable),
  137.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 1*KEY_MENU_STEP, EvMenuEnable),
  138.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 2*KEY_MENU_STEP, EvMenuEnable),
  139.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 3*KEY_MENU_STEP, EvMenuEnable),
  140.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 4*KEY_MENU_STEP, EvMenuEnable),
  141.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 5*KEY_MENU_STEP, EvMenuEnable),
  142.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 6*KEY_MENU_STEP, EvMenuEnable),
  143.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 7*KEY_MENU_STEP, EvMenuEnable),
  144.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 8*KEY_MENU_STEP, EvMenuEnable),
  145.     EV_COMMAND_ENABLE_64(KEY_MENU_START+ 9*KEY_MENU_STEP, EvMenuEnable),
  146.     EV_COMMAND_ENABLE_64(KEY_MENU_START+10*KEY_MENU_STEP, EvMenuEnable),
  147.     EV_COMMAND_ENABLE_64(KEY_MENU_START+11*KEY_MENU_STEP, EvMenuEnable),
  148.     EV_COMMAND_ENABLE_64(KEY_MENU_START+12*KEY_MENU_STEP, EvMenuEnable),
  149.     EV_COMMAND_ENABLE_64(KEY_MENU_START+13*KEY_MENU_STEP, EvMenuEnable),
  150.     EV_COMMAND_ENABLE_64(KEY_MENU_START+14*KEY_MENU_STEP, EvMenuEnable),
  151.     EV_COMMAND_ENABLE_64(KEY_MENU_START+15*KEY_MENU_STEP, EvMenuEnable),
  152.  
  153.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 0*KEY_MENU_STEP, EvMenu),
  154.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 1*KEY_MENU_STEP, EvMenu),
  155.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 2*KEY_MENU_STEP, EvMenu),
  156.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 3*KEY_MENU_STEP, EvMenu),
  157.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 4*KEY_MENU_STEP, EvMenu),
  158.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 5*KEY_MENU_STEP, EvMenu),
  159.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 6*KEY_MENU_STEP, EvMenu),
  160.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 7*KEY_MENU_STEP, EvMenu),
  161.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 8*KEY_MENU_STEP, EvMenu),
  162.     EV_COMMAND_AND_ID_64(KEY_MENU_START+ 9*KEY_MENU_STEP, EvMenu),
  163.     EV_COMMAND_AND_ID_64(KEY_MENU_START+10*KEY_MENU_STEP, EvMenu),
  164.     EV_COMMAND_AND_ID_64(KEY_MENU_START+11*KEY_MENU_STEP, EvMenu),
  165.     EV_COMMAND_AND_ID_64(KEY_MENU_START+12*KEY_MENU_STEP, EvMenu),
  166.     EV_COMMAND_AND_ID_64(KEY_MENU_START+13*KEY_MENU_STEP, EvMenu),
  167.     EV_COMMAND_AND_ID_64(KEY_MENU_START+14*KEY_MENU_STEP, EvMenu),
  168.     EV_COMMAND_AND_ID_64(KEY_MENU_START+15*KEY_MENU_STEP, EvMenu),
  169.  
  170.  
  171. END_RESPONSE_TABLE;
  172.  
  173. TMyWindow        *MainWindow ;
  174. TApplication    *Application ;
  175. TDC                *ModelDC = NULL ;
  176. TPalette        *ModelPalet = NULL;
  177. extern    int        lastcolor;
  178. extern    int        paletteowner;
  179.  
  180. static    char    logname[256];
  181.  
  182. TWindow *GetModelWindow(void)
  183. {
  184.     return (TWindow*)MainWindow;
  185. }
  186.  
  187. TMyWindow::TMyWindow() : TFrameWindow( 0, "Polygon Editor" )
  188. {
  189. //    Attr.X = 256 ;
  190. //    Attr.Y = 0 ;
  191.     Attr.W = 768 ;
  192.     Attr.H = 512 ;
  193.     CreateFlag = 0 ;
  194.  
  195.     KeyCode = 0 ;
  196.     ShiftStat = 0 ;
  197.     KanjiFlag = 0 ;
  198.     MouseX = 0 ;
  199.     MouseY = 0 ;
  200.     MouseLeft = 0 ;
  201.     MouseRight = 0 ;
  202.     MouseMove = 0 ;
  203.     MenuRoot = new TMenu();;
  204.     for (int i = 0; i < MAX_MENU; ++i) {
  205.         MenuSub[i] = new TPopupMenu();
  206.         MenuRoot->AppendMenu(MF_POPUP|MF_DISABLED, *MenuSub[i], "");
  207.     }
  208. }
  209.  
  210. TMyWindow::~TMyWindow()
  211. {
  212.     delete MenuRoot;
  213.     for (int i = 0; i < MAX_MENU; ++i) {
  214.         delete MenuSub[i];
  215.     }
  216. }
  217.  
  218. void    TMyWindow::SetupWindow()
  219. {
  220.     TFrameWindow::SetupWindow();
  221.     SetMenu(*MenuRoot);
  222. }
  223.  
  224.  
  225. //    終了処理
  226. TMyWindow::CanClose()
  227. {
  228.     if (IdentCanClose >= 0) {
  229.         int flag;
  230.         DataStruct *top;
  231.         top = StackTop();
  232.         StackPushInt( 0 );
  233.         CallFunction( IdentCanClose, 1, top+1 );
  234.         flag= top[1].id.i ;
  235.         StackRelease( top );
  236.         if (flag) {
  237.             QuitFlag = 1;
  238.         }
  239.         return flag != 0;
  240.     } else {
  241.         QuitFlag = 1 ;
  242.         return TRUE ;
  243.     }
  244. }
  245.  
  246. //    再表示
  247. void    TMyWindow::Paint( TDC& tdc, BOOL, TRect&rect)
  248. {
  249.     if ( CreateFlag )
  250.     {
  251. #if 1
  252.         TDC        *restorDC ;
  253.         restorDC = ModelDC ;
  254.         ModelDC = &tdc ;
  255. //        TRect rect = tdc.GetClipBox();
  256. //printf("(%d,%d)-(%d,%d)\n", rect.left, rect.top, rect.right, rect.bottom);
  257.         if (ModelPalet != NULL && paletteowner) {
  258.             ModelDC->SelectObject(*ModelPalet);
  259.             ModelDC->RealizePalette();
  260.         }
  261.         ModelDC->SetBkMode(TRANSPARENT);
  262.         lastcolor = -1;
  263.  
  264.         char fontname[256] ;
  265.         ModelDC->GetTextFace( 256, fontname );
  266.         ModelDC->SelectObject( TFont( fontname, 0, 0, 0, 0, FW_NORMAL,
  267.             FIXED_PITCH|FF_DONTCARE ) );
  268.  
  269. //        RedrawAll();
  270.  
  271.         ViewFrame();
  272.         ViewLineAll( rect.left, rect.top, rect.right, rect.bottom, TRUE );
  273.         DrawTitleBar();
  274.         DrawControlPanel();
  275.         DrawUserButtonAll();
  276.  
  277.         ModelDC = restorDC ;
  278.         lastcolor = -1;
  279. #else
  280.         ViewFrame();
  281.         ViewLineAll( rect.left, rect.top, rect.right, rect.bottom, TRUE );
  282.         DrawTitleBar();
  283.         DrawControlPanel();
  284.         DrawUserButtonAll();
  285. #endif
  286.     }
  287. }
  288.  
  289. //    キー入力
  290. void    TMyWindow::EvChar( UINT key, UINT, UINT flag )
  291. {
  292.     if ( KanjiFlag )
  293.     {
  294.         KanjiFlag = FALSE ;
  295.     }
  296.     else
  297.     {
  298.         KanjiFlag = iskanji( key );
  299.         // ctrl-key
  300.         if ( ShiftStat == 2 && ( flag & 0xff ) == 0x73 )
  301.             key = 0x1f ;    // ctrl-_
  302.     }
  303.     if (KeyCode == 0) {
  304.        KeyIn( (int)key );
  305.     }
  306. }
  307.  
  308. typedef struct {
  309.     int    vk, key;
  310. }    VkConvert;
  311. VkConvert keytable[] = {
  312.     {VK_PRIOR,        KEY_ROLLDOWN},
  313.     {VK_NEXT,       KEY_ROLLUP},
  314.     {VK_END,        KEY_UNDO},
  315.     {VK_HOME,        KEY_HOME},
  316.     {VK_LEFT,        KEY_LEFT},
  317.     {VK_UP,            KEY_UP},
  318.     {VK_RIGHT,        KEY_RIGHT},
  319.     {VK_DOWN,        KEY_DOWN},
  320.     {VK_INSERT,        KEY_INS},
  321.     {VK_DELETE,        KEY_DEL},
  322.     {VK_HELP,        KEY_HELP},
  323.     {VK_NUMPAD0,    KEY_NUMPAD_0},
  324.     {VK_NUMPAD1,    KEY_NUMPAD_1},
  325.     {VK_NUMPAD2,    KEY_NUMPAD_2},
  326.     {VK_NUMPAD3,    KEY_NUMPAD_3},
  327.     {VK_NUMPAD4,    KEY_NUMPAD_4},
  328.     {VK_NUMPAD5,    KEY_NUMPAD_5},
  329.     {VK_NUMPAD6,    KEY_NUMPAD_6},
  330.     {VK_NUMPAD7,    KEY_NUMPAD_7},
  331.     {VK_NUMPAD8,    KEY_NUMPAD_8},
  332.     {VK_NUMPAD9,    KEY_NUMPAD_9},
  333.     {VK_MULTIPLY,    KEY_NUMPAD_ASTERISK},
  334.     {VK_ADD,         KEY_NUMPAD_PLUS},
  335.     {VK_SUBTRACT,    KEY_NUMPAD_MINUS},
  336.     {VK_DECIMAL,    KEY_NUMPAD_PERIOD},
  337.     {VK_DIVIDE,        KEY_NUMPAD_SLASH},
  338.     {VK_NUMLOCK,    KEY_CLR},
  339. };
  340.  
  341. void    TMyWindow::EvKeyDown( UINT key, UINT, UINT )
  342. {
  343. #if 0
  344.     static    int        keycode[] = {
  345.         /*    ROLLUP        ROLLDN        INS            DEL            UP            LEFT        */
  346.             0x22,        0x21,        0x2d,        0x2e,        0x26,        0x25,
  347.         /*    RIGHT        DOWN        CLR            HELP        HOME        */
  348.             0x27,        0x28,        0,            0,            0x24,        -1 };
  349.     static    int    keycode[] = {
  350.  
  351.     };
  352.     static    int    returncode[] = {
  353.     };
  354.  
  355.     // shift
  356.     if ( key == 0x10 )
  357.         ShiftStat |= 1 ;
  358.     // ctrl
  359.     if ( key == 0x11 )
  360.         ShiftStat |= 2 ;
  361.  
  362.     // function key
  363.     if ( VK_F1 <= key && key <= VK_F15 )
  364.     {
  365.         KeyIn( (int)( key - 0x70 ) + 1 + KEY_FUNC_START);
  366. #if 0
  367.         if ( ShiftStat & 1 )
  368.             KeyIn( (int)( key - 0x70 ) + KEY_SFUNC_START);
  369.         else
  370.             KeyIn( (int)( key - 0x70 ) + KEY_FUNC_START);
  371. #endif
  372.     }
  373.     else
  374.     {
  375.         for( int i = 0 ; keycode[i] != -1 ; i++ )
  376.         {
  377.             if ( key == keycode[i] )
  378.                 KeyIn( (int)i + KEY_SPECIAL_START);
  379.         }
  380.     }
  381.  
  382.     // ctrl-key
  383.     if ( ShiftStat == 2 && key == 222 )
  384.         KeyIn( 0x1e );    // ctrl-^
  385. #endif
  386.     if ( key == VK_SHIFT) {
  387.         ShiftStat |= 1 ;
  388.     } else if ( key == VK_CONTROL ) {
  389.         ShiftStat |= 2 ;
  390.     } else if ('A' <= key && key <= 'Z') {
  391.         if (ShiftStat & 2) {
  392.             KeyIn( key - 'A' + 1);
  393.         } else if ( ShiftStat & 1 ) {
  394.             KeyIn( key );
  395.         } else {
  396.             KeyIn( key - 'A' + 'a');
  397.         }
  398.     } else if ( VK_F1 <= key && key <= VK_F15 ) {
  399.         KeyIn( (int)( key - VK_F1 )  + KEY_F1);
  400.     } else {
  401.         for (int i = 0; i < sizeof(keytable) / sizeof(keytable[0]); i++) {
  402.             if (keytable[i].vk == key) {
  403.                 KeyIn(keytable[i].key);
  404.                 break;
  405.             }
  406.         }
  407.     }
  408. }
  409.  
  410. void    TMyWindow::EvKeyUp( UINT key, UINT, UINT )
  411. {
  412.     if ( key == VK_SHIFT )
  413.         ShiftStat &= 0xfe ;
  414.     if ( key == VK_CONTROL)
  415.         ShiftStat &= 0xfd ;
  416. }
  417.  
  418. void    TMyWindow::EvLButtonDown( UINT, TPoint& point )
  419. {
  420.     MouseLeft = 1 ;
  421.     SetCapture();
  422. }
  423.  
  424. void    TMyWindow::EvRButtonDown( UINT, TPoint& point )
  425. {
  426.     MouseRight = 1 ;
  427.     SetCapture();
  428. }
  429.  
  430. void    TMyWindow::EvLButtonUp( UINT, TPoint& point )
  431. {
  432.     MouseLeft = 0 ;
  433.     ReleaseCapture();
  434. }
  435.  
  436. void    TMyWindow::EvRButtonUp( UINT, TPoint& point )
  437. {
  438.     MouseRight = 0 ;
  439.     ReleaseCapture();
  440. }
  441.  
  442. void    TMyWindow::EvLButtonDblClk( UINT, TPoint& point )
  443. {
  444.     MouseLeft = 1 ;
  445. }
  446.  
  447. void    TMyWindow::EvRButtonDblClk( UINT, TPoint& point )
  448. {
  449.     MouseRight = 1 ;
  450. }
  451.  
  452. void    TMyWindow::EvMouseMove( UINT fwKeys, TPoint& point )
  453. {
  454.     MouseLeft = (fwKeys & MK_LBUTTON) ? 1 : 0;
  455.     MouseRight = (fwKeys & MK_RBUTTON) ? 1 : 0;
  456.     ShiftStat = (ShiftStat & 0xfc)
  457.               | ((fwKeys & MK_CONTROL) ? 2 : 0)
  458.               | ((fwKeys & MK_SHIFT) ? 1 : 0);
  459.     MouseX = point.x ;
  460.     MouseY = point.y ;
  461. }
  462.  
  463. void    TMyWindow::EvSize( UINT, TSize& )
  464. {
  465.     if ( CreateFlag )
  466.     {
  467.         TRect rect = GetClientRect();
  468.  
  469. #if 0
  470.         Cols = ( rect.right - rect.left ) / FontH ;
  471.         Lines = ( rect.bottom - rect.top) / FontV;
  472.         ViewSetDisplay(Cols * FontH - CTRL_WIDTH - ButtonAreaWidth, Lines * FontV);
  473. #endif
  474.         Display_X = rect.right - rect.left;
  475.         Display_Y = rect.bottom - rect.top;
  476.         ViewSetDisplay(Display_X - CTRL_WIDTH - ButtonAreaWidth, Display_Y);
  477.         RedrawAll();
  478.     }
  479. }
  480.  
  481. void    TMyWindow::EvWindowPosChanging (WINDOWPOS far& windowPos) //96/1/9 Taka2
  482. {
  483.     TFrameWindow::EvWindowPosChanging(windowPos);
  484. #if 0
  485.     if ( CreateFlag )
  486.     {
  487.         int bx, by;
  488.         bx = GetSystemMetrics(SM_CXFRAME)*2;
  489.         by = GetSystemMetrics(SM_CYCAPTION)
  490.            + GetSystemMetrics(SM_CYMENU)
  491.            + GetSystemMetrics(SM_CYFRAME)*2;
  492.         windowPos.cx = ((windowPos.cx-bx) / FontH)*FontH + bx;
  493.         windowPos.cy = ((windowPos.cy-by) / FontV)*FontV + by;
  494.     }
  495. #endif
  496. }
  497.  
  498. void TMyWindow::EvPaletteChanged(HWND hWndPalChg)
  499. {
  500.     if (hWndPalChg != HWindow && ModelDC != NULL && ModelPalet != NULL) {
  501.         paletteowner = FALSE;
  502.         ModelDC->RealizePalette();
  503. //printf("not owner\n");
  504.     }
  505.  
  506. }
  507.  
  508. void TMyWindow::EvPaletteIsChanging(HWND hWndPalChg)
  509. {
  510.     if (hWndPalChg != HWindow && ModelDC != NULL && ModelPalet != NULL) {
  511.         paletteowner = FALSE;
  512. //printf("not owner\n");
  513.     }
  514.  
  515. }
  516.  
  517. BOOL TMyWindow::EvQueryNewPalette()
  518. {
  519.     if (ModelDC != NULL && ModelPalet != NULL) {
  520. //printf("owner\n");
  521.         paletteowner = TRUE;
  522.         ModelDC->RealizePalette();
  523. //        Invalidate();
  524. //        if (Selects > 0) {
  525. //            ViewLineAll( 0, 0, DISPLAY_X, DISPLAY_Y, TRUE );
  526. //            ViewLineSelectAll();
  527. //        }
  528. //        TDC tmpdc(*ModelDC);
  529. //        Paint(tmpdc, FALSE, TRect(DISPLAY_X-2, DISPLAY_Y-2, DISPLAY_X-1, DISPLAY_Y-1));
  530.         Paint(*ModelDC, FALSE, TRect(DISPLAY_X-2, DISPLAY_Y-2, DISPLAY_X-1, DISPLAY_Y-1));
  531.         return TRUE;
  532.     }
  533.     return FALSE;
  534. }
  535.  
  536. void    TMyWindow::EvMenu(WPARAM wparam)    //96/1/10
  537. {
  538.     KeyIn(wparam);
  539. }
  540.  
  541. void    TMyWindow::EvMenuEnable(TCommandEnabler &tce)
  542. {
  543.     int x, y;
  544.     x = (tce.Id- KEY_MENU_START)/KEY_MENU_STEP;
  545.     y = (tce.Id - KEY_MENU_START)%KEY_MENU_STEP;
  546.     if (0 <= x && x <MAX_MENU && 0 <= y && y < Menu[x]->items) {
  547.         if (Menu[x]->query[y] >= 0) {
  548.             DataStruct *top;
  549.             CurrentX = x;
  550.             CurrentY = y;
  551.             top = StackTop();
  552.             StackPushInt( x );
  553.             StackPushInt( y );
  554.             CallFunction( Menu[x]->query[y], 2, top+2 );
  555.             StackRelease( top );
  556.             CurrentX = CurrentY = -1;
  557.             tce.SetText(Menu[x]->item[y]);
  558.         }
  559.         tce.SetCheck((Menu[x]->check[y] & MENU_CHECK) != 0);
  560.         tce.Enable((Menu[x]->check[y] & MENU_DISABLE) == 0);
  561.     }
  562. }
  563.  
  564. //
  565. //        イベント取得関数
  566. //
  567. int        GetKey()
  568. {
  569.     int        ret = MainWindow->KeyCode ;
  570.     MainWindow->KeyCode = 0 ;
  571.     return ret ;
  572. }
  573.  
  574. int        PeekKey()
  575. {
  576.     return MainWindow->KeyCode;
  577. }
  578.  
  579. int        GetShift()
  580. {
  581.     return MainWindow->ShiftStat ;
  582. }
  583.  
  584. void    GetMouseStat( int &left, int &right )
  585. {
  586.     left = MainWindow->MouseLeft ;
  587.     right = MainWindow->MouseRight ;
  588. }
  589.  
  590. void    GetMousePos( int &x, int &y )
  591. {
  592.     x = MainWindow->MouseX ;
  593.     y = MainWindow->MouseY ;
  594. }
  595.  
  596. int        GetMouseMove()
  597. {
  598.     return MainWindow->MouseMove ;
  599. }
  600.  
  601. //
  602. //    メニュー処理関数
  603. //
  604. static int isSeparator(char *name)
  605. {
  606.     for (; *name; ++name) {
  607.         if (*name != '-') {
  608.             return FALSE;
  609.         }
  610.     }
  611.     return TRUE;
  612. }
  613.  
  614. void    SetWindowsMenu(int no)
  615. {
  616.     int i;
  617.     if (no >= 0 && no < MAX_MENU) {
  618.         TPopupMenu *sub = MainWindow->MenuSub[no];
  619.         TMenu *root = MainWindow->MenuRoot;
  620.         for (i = sub->GetMenuItemCount(); i > 0; --i) {
  621.             sub->RemoveMenu(i-1, MF_BYPOSITION);
  622.         }
  623.         if (Menu[no] != NULL) {
  624.             for (i = 0; i <Menu[no]->items; ++i) {
  625.                 UINT flag = (Menu[no]->exec[i] > 0 ? 0 : MF_DISABLED)
  626.                           | (isSeparator(Menu[no]->item[i]) ? MF_SEPARATOR : 0);
  627.                 sub->AppendMenu(MF_STRING | flag,
  628.                                 KEY_MENU_START+no*KEY_MENU_STEP+i,
  629.                                 Menu[no]->item[i]);
  630.             }
  631.         }
  632. #if 0
  633.         char *title = (Menu[no] != NULL ? Menu[no]->title : "");
  634.         UINT flag = (Menu[no] != NULL && Menu[no]->items > 0 ? 0 : MF_DISABLED);
  635.         root->ModifyMenu(no, MF_BYPOSITION | MF_POPUP | flag, *sub, title);
  636. #else
  637.         for (i = root->GetMenuItemCount(); i > 0; --i) {
  638.             root->RemoveMenu(i-1, MF_BYPOSITION);
  639.         }
  640.         for (i = 0; i < MAX_MENU && Menu[i] != NULL; i++) {
  641.             UINT flag = (Menu[i]->items > 0 ? 0 : MF_DISABLED);
  642.             root->AppendMenu(MF_POPUP|flag, *MainWindow->MenuSub[i], Menu[i]->title);
  643.         }
  644. #endif
  645.         MainWindow->SetMenu(*root);
  646.         MainWindow->DrawMenuBar();
  647.     } else {
  648.         TMenu *root = MainWindow->MenuRoot;
  649. #if 0
  650.         for (no = 0; no < MAX_MENU; ++no) {
  651.             TPopupMenu *sub = MainWindow->MenuSub[no];
  652.             root->ModifyMenu(no, MF_BYPOSITION | MF_POPUP | MF_DISABLED, *sub, "");
  653.         }
  654. #else
  655.         for (i = root->GetMenuItemCount(); i > 0; --i) {
  656.             root->RemoveMenu(i-1, MF_BYPOSITION);
  657.         }
  658.         root->AppendMenu(MF_STRING|MF_DISABLED, 0, "");
  659. #endif
  660.         MainWindow->SetMenu(*root);
  661.         MainWindow->DrawMenuBar();
  662.     }
  663. }
  664.  
  665.  
  666. //
  667. //    アプリケーションクラス
  668. //
  669. class TMyApp : public TApplication {
  670.   public:
  671.     TMyApp() : TApplication("PolyEdit") {}
  672.  
  673.   protected:
  674.     BOOL    isidle ;
  675.     void    InitMainWindow();
  676.     virtual BOOL    IdleAction( long );
  677. };
  678.  
  679. static    TMessageWindow    *DebugWindow ;
  680.  
  681. void TMyApp::InitMainWindow()
  682. {
  683.     isidle = TRUE ;
  684.     EnableCtl3d();
  685.  
  686.     ::MainWindow = new TMyWindow();
  687.     ::MainWindow->SetIcon(this, ID_MODEL);
  688.     SetMainWindow( ::MainWindow );
  689.  
  690. #if 0
  691.     DebugWindow = new TMessageWindow( "message window", 200 );
  692.     DebugWindow->GetWindowPtr()->Create();
  693. #endif
  694. }
  695.  
  696. BOOL    TMyApp::IdleAction( long idleCount )
  697. {
  698.     if ( isidle )
  699.     {
  700.         TClientDC    dc( *::MainWindow );
  701.  
  702.         ModelDC = &dc ;
  703.         ModelDC->SetBkMode(TRANSPARENT);
  704.         lastcolor = -1;
  705.  
  706.         char fontname[256] ;
  707.         ModelDC->GetTextFace( 256, fontname );
  708.         ModelDC->SelectObject( TFont( fontname, 0, 0, 0, 0, FW_NORMAL,
  709.             FIXED_PITCH|FF_DONTCARE ) );
  710.         TSize size = ModelDC->GetTextExtent( " ", 1 );
  711.         FontH = size.cx ;
  712.         FontV = size.cy ;
  713.  
  714.         TRect rect = MainWindow->GetClientRect();
  715.  
  716. //        Cols = ( rect.right - rect.left ) / FontH ;
  717. //        Lines = ( rect.bottom - rect.top ) / FontV ;
  718.         Display_X = rect.right - rect.left;
  719.         Display_Y = rect.bottom - rect.top;
  720.  
  721.         ::MainWindow->CreateFlag = 1 ;
  722.  
  723.         int i;
  724.         strcpy(logname, _argv[0]);
  725.         i = strlen(logname);
  726.         if (logname[i-4] == '.') {
  727.             strcpy(logname + (i-3), "log");
  728.             unlink(logname);
  729.         } else {
  730.             logname[0] = '\0';
  731.         }
  732.  
  733.  
  734.  
  735. //        ModelMain( 0, NULL );
  736.         ModelMain( _argc, _argv);
  737.  
  738.         ModelDC = 0 ;
  739.         isidle = FALSE ;
  740.     }
  741.     return TApplication::IdleAction(idleCount) ;
  742. }
  743.  
  744.  
  745. int        OwlMain(int /*argc*/, char* /*argv*/ [])
  746. {
  747.     TMyApp    app ;
  748.  
  749.     Application = & app ;
  750.  
  751.     return app.Run();
  752. }
  753.  
  754.  
  755. int printf(const char *fmt, ...)
  756. {
  757. #if 0
  758.     char    buf[256] ;
  759.  
  760.     va_list    argptr ;
  761.     va_start( argptr, fmt );
  762.     vsprintf( buf, fmt, argptr );
  763.     va_end( argptr );
  764.  
  765.     LogPrintf( buf );
  766. #else
  767.     FILE *fp;
  768.     if (logname[0] && (fp = fopen(logname, "a")) != NULL) {
  769.         va_list    argptr ;
  770.         va_start( argptr, fmt );
  771.         vfprintf( fp, fmt, argptr );
  772.         va_end( argptr );
  773.         fclose(fp);
  774.     }
  775. #endif
  776.     return 0;
  777. }
  778.  
  779.  
  780.