Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "debug.h"
  6. #include "dbgpaint.h"
  7. #include "dx.h"
  8. #include "draw.h"
  9. #include "dxrframe.h"
  10. #include "font16.h"
  11. #include "util.h"
  12.  
  13. #include "debug_tools.h"                // [NS]
  14.  
  15.  
  16.  
  17. //=============================================================================
  18.  
  19. // 640x480      80x30
  20. // 768x586      96x36,625
  21.  
  22. //unsigned char gdi_dbg_buf[ 2 * 1048576]; //2MB
  23.  
  24. const int c8 = 8;                                                               // [NS]
  25. const int c16 = 16;
  26.  
  27. //#define SB80  84      // в dbgpaint.h
  28. //#define SB30  30
  29.  
  30. const int s80 = 80;//84;//80;
  31. const int s30 = 30;//32;//30;
  32.  
  33.  
  34. const int s192 = 192;
  35. const int s640 = 640;//672;//640;
  36. const int s480 = 480;//512;//480;
  37.  
  38. //unsigned char txtscr[ 80 * 30 * 2];
  39. unsigned char txtscr[ SB80 * SB30 * 2]; // не принимает переменные
  40.  
  41. //=============================================================================
  42.  
  43.  
  44.  
  45. //=============================================================================
  46. static struct
  47. {
  48.     unsigned char x;
  49.     unsigned char y;
  50.     unsigned char dx;
  51.     unsigned char dy;
  52.     unsigned char c;
  53. } frames[ 20];
  54.  
  55. //=============================================================================
  56.  
  57.  
  58. unsigned nfr;
  59.  
  60.  
  61.  
  62.  
  63.  
  64. //=============================================================================
  65. void debugflip()
  66. {
  67.  
  68. // printf("debugflip()\n");
  69. // printf("temp.scx %d\n",temp.scx);
  70.        
  71.     //-------------------------------------------------------------------------
  72.     // обновление debug tools-ов при активном дебагере
  73.     for (int cnt = 0;    cnt < DEBUG_TOOLS_MAX_COUNT;    cnt++)
  74.     {
  75.         //---------------------------------------------------------------------
  76.         // обновляем только открытые окна
  77.         if (debug_tool_exist[ cnt])
  78.         {
  79.             InvalidateRect( debug_tool_hwnd[ cnt], NULL, FALSE); // не стирать фон
  80.             UpdateWindow(   debug_tool_hwnd[ cnt]);              // [NS] test
  81.         }
  82.         //---------------------------------------------------------------------
  83.     }
  84.     //-------------------------------------------------------------------------
  85.  
  86.  
  87.  
  88.     /*
  89.     if (!active)                        // [NS] неясно зачем пропускать отрисовку когдаа она нада?
  90.     {                                   // может пушо этим занималсо WM_PAINT из dx.cpp
  91.         printf("debugflip() skip\n");   // который обычно отрисовывал всяйик шлак
  92.         return;                         // заскриншоченный 5 минут нназад
  93.     }
  94.     */
  95.        
  96.     setpal( 0);
  97.  
  98. //  unsigned char * const bptr = gdibuf;
  99.     unsigned char * const bptr = gdi_dbg_buf;   // рисуем в свой отдельный буфер [NS]
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.     //-------------------------------------------------------------------------
  108.     // отрисовка маленького превиева
  109.     //          должна быть ИМЕННО ТУТ!!!
  110.     //          пушо превиев может перекрыватсо всплывающими "окнами"
  111.     //-------------------------------------------------------------------------
  112.     if (show_scrshot)
  113.     {
  114.         //---------------------------------------------------------------------
  115.         // для raypainted
  116.         memcpy( save_buf,
  117.                 rbuf,
  118.                 rb2_offs
  119.                 );             
  120.         //---------------------------------------------------------------------
  121.         switch (show_scrshot)
  122.         {
  123.             case 1:     paint_scr( 0);  break;                  // [NS]
  124.             case 2:     paint_scr( 1);  break;
  125.             case 3:     paint_scr( 2);  break;
  126.         }
  127.         //---------------------------------------------------------------------
  128.         unsigned char *dst = bptr + (wat_y * c16 * s640) + (wat_x * c8);
  129.        
  130. //      unsigned char *src = rbuf + (temp.scx / 4) * (temp.b_top +  (192 / 2) - (wat_sz *  16 / 2));
  131.         unsigned char *src = rbuf + (temp.scx / 4) * (temp.b_top + (s192 / 2) - (wat_sz * c16 / 2));
  132.      
  133.         src += (temp.scx /  8) - (37 / 2 * 2);
  134. //      src += (temp.scx / c8) - (37 / 2 * 2);
  135.        
  136. //      unsigned char *ray_pos = raypointer();  // [NS}
  137.        
  138.         // перекидывание zx экрана в экран дебагера
  139.         //---------------------------------------------------------------------
  140.         for (unsigned y = 0;    y < wat_sz * 16;    y++)        // wat_sz = 13 (Y размер знакомест в дебагере)
  141.         {
  142.             //-----------------------------------------------------------------
  143.             // 1 байт на пиксель !!!!
  144.             for (unsigned x = 0;    x < 37;    x++)             //37 знакомест
  145.             {
  146.                 // НО все равно просто так не вырватсо из мерзского hardware multicolor-а [NS]
  147.                 //-------------------------------------------------------------
  148.                 // отрисованные пиксели
  149.                 //if (reinterpret_cast<int>(src+(2*x)) < reinterpret_cast<int>(ray_pos))
  150.                 //{
  151.                 //левые 4 пикселя
  152.                 *(unsigned*) (dst + x * 8 + 0) = t.sctab8[ 0][( src[ x * 2] >>  4) + src[ 2 * x + 1] * 16];    
  153.                 //правые 4 пикселя
  154.                 *(unsigned*) (dst + x * 8 + 4) = t.sctab8[ 0][( src[ x * 2] & 0xF) + src[ 2 * x + 1] * 16];
  155.                 //}
  156.                 //-------------------------------------------------------------
  157.                 // пиксели с предыдущего кадра
  158.                 //else
  159.                 //{
  160.                 ////левые 4 пикселя
  161.                 //*(unsigned*)(dst + x * 8 + 0) = (t.sctab8[0][(src[x * 2] >>  4) + src[2 * x + 1] * 16]);     
  162.                 ////правые 4 пикселя
  163.                 //*(unsigned*)(dst + x * 8 + 4) = (t.sctab8[0][(src[x * 2] & 0xF) + src[2 * x + 1] * 16]);
  164.                 //}
  165.             } // x
  166.             //-----------------------------------------------------------------
  167.             src += temp.scx / 4;
  168.             //dst += 640;
  169.             dst += s640;
  170.         } // y
  171.         //---------------------------------------------------------------------
  172.         // для raypainted
  173.         memcpy( rbuf,
  174.                 save_buf,
  175.                 rb2_offs);
  176.         //---------------------------------------------------------------------
  177.     }
  178.     //-------------------------------------------------------------------------
  179.  
  180.        
  181.        
  182.        
  183.        
  184.        
  185.        
  186.        
  187.        
  188.        
  189.        
  190.        
  191.     //-------------------------------------------------------------------------
  192.     // print text mode
  193.     //-------------------------------------------------------------------------
  194.     int x;
  195.     int y;
  196.     unsigned char *tptr = txtscr;
  197.     //-------------------------------------------------------------------------
  198. //  for (y = 0;    y < (16 * 30 * 640);    y += (16 * 640))
  199.     for (y = 0;    y < (c16 * s30 * s640);    y += (c16 * s640))
  200.     {
  201.         //---------------------------------------------------------------------
  202.         // for (x = 0;    x < 80;    x++, tptr++)
  203.         for (x = 0;    x < s80;    x++, tptr++)
  204.         {
  205.             unsigned ch = *tptr;
  206.             //unsigned at = tptr[ 80 * 30];
  207.             unsigned at = tptr[ s80 * s30];
  208.             //-----------------------------------------------------------------
  209.             //transparent color - НЕНУЖЕН
  210.             if (at == 0xFF)
  211.                 continue;
  212.             //-----------------------------------------------------------------
  213.             //const unsigned char *fnt = &font16[ ch * 16];
  214.             const unsigned char *fnt = &font16[ ch * c16];
  215.             at <<= 4;
  216.             //-----------------------------------------------------------------
  217.             //for (int yy = 0;    yy < 16;    yy++, fnt++)
  218.             for (int yy = 0;    yy < c16;    yy++, fnt++)
  219.             {
  220.             //  unsigned sctab8[2][16*0x100];  //4 bits data+pc-attribute -> 4 palette pixels
  221.            
  222.                 //правые 4 пикселя
  223.                 //*(unsigned*) (bptr + y + (640 * yy) + (x * 8) + 0) = t.sctab8[ 0][( *fnt >>  4) + at];
  224.                 *(unsigned*) (bptr + y + (s640 * yy) + (x * 8) + 0) = t.sctab8[ 0][( *fnt >>  4) + at];
  225.                
  226.                 //левые 4 пикселя
  227.                 //*(unsigned*) (bptr + y + (640 * yy) + (x * 8) + 4) = t.sctab8[ 0][( *fnt & 0xF) + at];
  228.                 *(unsigned*) (bptr + y + (s640 * yy) + (x * 8) + 4) = t.sctab8[ 0][( *fnt & 0xF) + at];
  229.             }
  230.             //-----------------------------------------------------------------
  231.         }
  232.         //---------------------------------------------------------------------
  233.     }
  234.     //-------------------------------------------------------------------------
  235.  
  236.  
  237.  
  238.  
  239.  
  240.    
  241.     //-------------------------------------------------------------------------
  242.     // отрисовка "рамочек" из буфера
  243.     // но РАМОЧКИ НЕНУЖНЫ
  244.     /*
  245.     for (unsigned i = 0;    i < nfr;    i++)
  246.     {
  247.         //unsigned char a1 = (frames[i].c | 0x08) * 0x11;
  248.         unsigned char a1 = (frames[ i].c & 0x0F) | ((frames[ i].c & 0x0F) << 4);        //attr 256c ?
  249.         //---------------------------------------------------------------------
  250.         //y = frames[i].y * 16 - 1;
  251.         y = frames[i].y * c16 - 1;
  252.         //---------------------------------------------------------------------
  253.         for (x = 8 * frames[ i].x - 1;    x < (frames[ i].x + frames[ i].dx) * 8;    x++)
  254.         {
  255.             // bptr[ y * 640 + x] = a1;
  256.             bptr[ y * s640 + x] = a1;
  257.         }
  258.         //---------------------------------------------------------------------
  259.         //y = (frames[ i].y + frames[ i].dy) * 16;
  260.         y = (frames[ i].y + frames[ i].dy) * c16;
  261.         //---------------------------------------------------------------------
  262.         for (x = 8 * frames[ i].x - 1;    x < (frames[ i].x + frames[ i].dx) * 8;    x++)
  263.         {
  264.             // bptr[ y * 640 + x] = a1;
  265.             bptr[ y * s640 + x] = a1;
  266.         }
  267.         //---------------------------------------------------------------------
  268.         x = frames[i].x * 8 - 1;
  269.         //---------------------------------------------------------------------
  270.         for (y = 16 * frames[ i].y;    y < (frames[ i].y + frames[ i].dy) * 16;    y++)
  271.         {
  272.             // bptr[ y * 640 + x] = a1;
  273.             bptr[ y * s640 + x] = a1;
  274.         }
  275.         //---------------------------------------------------------------------
  276.         x = (frames[ i].x + frames[ i].dx) * 8;
  277.         //---------------------------------------------------------------------
  278.         for (y = 16 * frames[ i].y;    y < (frames[ i].y + frames[ i].dy) * 16;    y++)
  279.         {
  280.             //bptr[ y * 640 + x] = a1;
  281.             bptr[ y * s640 + x] = a1;
  282.         }
  283.         //---------------------------------------------------------------------
  284.     }
  285.     */
  286.     //-------------------------------------------------------------------------
  287.  
  288. //      //---------------------------------------------------------------------
  289. //      //tzt
  290. //      for (unsigned y = 0;    y < 50;    y++)         // wat_sz = 13 (Y размер знакомест в дебагере)
  291. //      {
  292. //              *(bptr + y + (y*s640)) = 0xFF;
  293. //      }
  294. //      //---------------------------------------------------------------------
  295.        
  296.        
  297.        
  298.        
  299.        
  300.        
  301.        
  302.        
  303.        
  304.        
  305.        
  306.  
  307.        
  308.        
  309.        
  310.        
  311.  
  312.  
  313.        
  314.        
  315.        
  316.        
  317.  
  318. //  gdibmp.header.bmiHeader.biBitCount = 8;
  319.     gdi_dbg_bmp.header.bmiHeader.biBitCount = 8;
  320.  
  321.     //может нужно перенести выше до отррисовки?
  322.     //-------------------------------------------------------------------------
  323.     if (needclr)
  324.         gdi_frame();
  325.     //-------------------------------------------------------------------------
  326.    
  327. /*
  328.    SetDIBitsToDevice(   temp.gdidc,             //ORIG
  329.                         int(temp.gx),
  330.                         int(temp.gy),
  331.                         640,
  332.                         480,
  333.                        
  334.                         0,
  335.                         0,
  336.                         0,
  337.                         480,
  338.                         bptr,
  339.                         &gdibmp.header,
  340.                         DIB_RGB_COLORS
  341.                      );
  342. */
  343.                 //написано без доки !!!
  344.                 //нужно уточнение всех параметров
  345.                
  346.               //для дебагера отдельный
  347.  
  348.     gdi_dbg_bmp.header.bmiHeader.biSize = sizeof( BITMAPINFOHEADER);
  349.     gdi_dbg_bmp.header.bmiHeader.biPlanes = 1;
  350.     gdi_dbg_bmp.header.bmiHeader.biBitCount = 8;
  351.    
  352.     gdi_dbg_bmp.header.bmiHeader.biWidth = LONG( s640);         // [NS]
  353.     gdi_dbg_bmp.header.bmiHeader.biHeight = -LONG( s480);
  354.     gdi_dbg_bmp.header.bmiHeader.biBitCount = WORD( temp.obpp);
  355.      
  356.      
  357. //      bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  358. //      bmi.bmiHeader.biPlanes = 1;
  359. //      bmi.bmiHeader.biBitCount = 32;
  360. //      bmi.bmiHeader.biCompression = BI_RGB;
  361. //      bmi.bmiHeader.biWidth = 320;
  362. //      bmi.bmiHeader.biHeight = 160;
  363.  
  364.  
  365.  
  366. // printf("temp.gx %d temp.gy %d\n",temp.gx,temp.gy);
  367.  
  368.     RECT current_mainwnd_size;
  369.     GetClientRect( wnd, &current_mainwnd_size);
  370.     int new_wnd_size_x = current_mainwnd_size.right - current_mainwnd_size.left;
  371.     int new_wnd_size_y = current_mainwnd_size.bottom - current_mainwnd_size.top;
  372.  
  373. //  сделать на upscale COLORONCOLOR или HALFTONE
  374. //  для downscale по выбору HALFTONE COLORONCOLOR WHITEONBLACK
  375.  
  376.   //SetStretchBltMode(temp.gdidc, BLACKONWHITE);        //так ниче не видно (и по дефолту)
  377.   //SetStretchBltMode(temp.gdidc, WHITEONBLACK);        //так жирный белый шрифт
  378.     SetStretchBltMode( temp.gdidc, COLORONCOLOR);       //так биения и наверно бысстрей всего
  379.   //SetStretchBltMode(temp.gdidc, HALFTONE);            //так размывает но нагрузка на проц
  380.   //SetStretchBltMode(temp.gdidc, 5);           //WHITEONBLACK
  381.   //SetStretchBltMode(temp.gdidc, 0);           //WHITEONBLACK
  382.  
  383.  
  384.    
  385.     StretchDIBits(      temp.gdidc,                             //NS
  386.                         0,      //int(temp.gx), //= 0   //куда вмещать
  387.                         0,      //int(temp.gy), //= 0?
  388.                         new_wnd_size_x, //temp.ox,//320,//640,
  389.                         new_wnd_size_y, //temp.oy,//240,//480,
  390.                                
  391.                         0,      //какую часть кидить
  392.                         0,
  393.                         s640,   //640,
  394.                         s480,   //480,
  395.                         bptr,
  396.                         &gdi_dbg_bmp.header,//&gdibmp.header,
  397.                         DIB_RGB_COLORS,
  398.                         SRCCOPY
  399.                 );
  400.  
  401. //  gdibmp.header.bmiHeader.biBitCount = u16(temp.obpp);
  402.     gdi_dbg_bmp.header.bmiHeader.biBitCount = u16( temp.obpp);  // [NS]
  403. }
  404. //=============================================================================
  405.  
  406.  
  407. //=============================================================================
  408. void frame( unsigned x, unsigned y, unsigned dx, unsigned dy, unsigned char attr)
  409. {
  410. // DEPRECATED
  411.     /*
  412.     frames[ nfr].x =  u8( x);
  413.     frames[ nfr].y =  u8( y);
  414.     frames[ nfr].dx = u8( dx);
  415.     frames[ nfr].dy = u8( dy);
  416.     frames[ nfr].c = attr;
  417.     nfr++;
  418.     */
  419. }
  420. //=============================================================================
  421.  
  422.  
  423. //=============================================================================
  424. // Отрисовка строки с указанием атрибута
  425. void tprint( unsigned x, unsigned y, const char *str, unsigned char attr)
  426. {
  427.     for (unsigned ptr = y * s80 + x;    *str;    str++, ptr++)
  428.     {
  429.         txtscr[ ptr] = u8( *str);
  430.         txtscr[ ptr + s80 * s30] = attr;        //запись атрибута вместо
  431.     }
  432. }
  433. //=============================================================================
  434.  
  435.  
  436. //=============================================================================
  437. // Отрисовка строки с указанием атрибута только ink-а (но можно влиять на paper !)
  438. void tprint_fg( unsigned x, unsigned y, const char *str, unsigned char attr)
  439. {
  440.     for (unsigned ptr = y * s80 + x;    *str;    str++, ptr++)
  441.     {
  442.         txtscr[ ptr] = u8( *str);
  443.         txtscr[ ptr + s80 * s30] = (txtscr[ ptr + s80 * s30] & 0xF0) + attr;
  444.     }
  445. }
  446. //=============================================================================
  447.  
  448.  
  449. // Новые цвета для дебагера [NS]
  450.  
  451. #define DBG_ATTR_BCKGRND                0x00    //0     0
  452. #define DBG_ATTR_BCKGRND_ACTIVE         0x10    //blue
  453.  
  454. #define DBG_ATTR_WINDOW_FRAME           0x02    //
  455.  
  456. #define DBG_ATTR_INPUT_HIGHLIGHT        0xC0    //br+GREEN      0
  457. #define DBG_ATTR_INPUT_CURSOR           0xE0    //br+YELLOW     9
  458.  
  459. #define DBG_ATTR_WINDOW_TITLE           0xF0//0x1F      //blue  br+WHITE
  460.  
  461. #define DBG_ATTR_WINDOW_BACK_COLOR      0x70//0x70//white       0
  462. #define DBG_ATTR_WINDOW_TEXT            0x70
  463. #define DBG_ATTR_WINDOW_TEXT_GRAY       0x7A            //почемуто юзаеттссо как error
  464. #define DBG_ATTR_WINDOW_TEXT_ERROR      0x72            //white red
  465. #define DBG_ATTR_WINDOW_TEXT_CURSOR     0xE0            //white red
  466.  
  467.  
  468.  
  469. //=============================================================================
  470. // рисовалка текстовых окошек
  471. void filledframe( unsigned x, unsigned y, unsigned dx, unsigned dy, unsigned char color)
  472. {
  473.     //-------------------------------------------------------------------------
  474.     for (unsigned yy = y;    yy < (y + dy);    yy++)
  475.     {
  476.         for (unsigned xx = x;    xx < (x + dx);    xx++)
  477.         {
  478.             txtscr[ yy * s80 + xx] = ' ';
  479.             txtscr[ yy * s80 + xx + s30 * s80] = color;
  480.         }
  481.     }
  482.     //-------------------------------------------------------------------------
  483.     nfr = 0; // delete other frames while dialog
  484.     frame(      x,
  485.                 y,
  486.                 dx,
  487.                 dy,
  488.                 DBG_ATTR_WINDOW_FRAME   //FFRAME_FRAME
  489.           );
  490. }
  491. //=============================================================================
  492.  
  493.  
  494. //=============================================================================
  495. void fillattr( unsigned x, unsigned y, unsigned dx, unsigned char color)
  496. {
  497.     for (unsigned xx = x;    xx < (x + dx);    xx++)
  498.     {
  499.         txtscr[ y * s80 + xx + s30 * s80] = color;
  500.     }
  501. }
  502. //=============================================================================
  503.  
  504.  
  505.  
  506. //=============================================================================
  507.  
  508. char str[ 0x80];
  509.  
  510. //=============================================================================
  511. unsigned inputhex( unsigned x, unsigned y, unsigned sz, bool hex, bool insert_mode)
  512. {
  513. // ВНЕЗАПНО ИСПОЛЬЗУЕТСО И ДЛЯ ТЕКСТА
  514.  
  515. //  insert_mode = TRUE; (by default) [NS]       для совместимости со старым вызовом без указания insert_mode
  516. //                                              режим ввода заменой под курсором
  517.     unsigned cr = 0;
  518.     mousepos = 0;
  519.  
  520.     //-------------------------------------------------------------------------
  521.     for (    ;    ;    )
  522.     {
  523. //      str[sz] = 0;
  524.         str[ sz + 5] = 0;
  525.  
  526.         size_t i;
  527.         //---------------------------------------------------------------------
  528.         for (i = strlen( str);    i < sz;    i++)
  529.         {
  530.             //printf("*\n");
  531.             str[ i] = ' ';
  532.         }
  533.         //---------------------------------------------------------------------
  534.         for (i = 0;    i < sz;    i++)  //sz - количество символов для ввода
  535.         {
  536.             unsigned vl = (unsigned char) str[ i];
  537.             tprint(     unsigned( x + i),
  538.                         unsigned( y),
  539.                         (char*) &vl,
  540.                         (i == cr)   ?   DBG_ATTR_INPUT_CURSOR :         //W_INPUTCUR :
  541.                                         DBG_ATTR_INPUT_HIGHLIGHT        //W_INPUTBG
  542.                    );
  543.         }
  544.         //---------------------------------------------------------------------
  545.         debugflip();
  546.         //---------------------------------------------------------------------
  547.         unsigned key;
  548.         //---------------------------------------------------------------------
  549.         // Ожидание нажатия клавиши infinity loop
  550.         for (    ;    ;  Sleep( 20)  )
  551.         {
  552.             key = process_msgs();
  553.             needclr = 0;  
  554.             //-----------------------------------------------------------------
  555.             //debugflip();      //зачем то без остановки перрерисовка
  556.                                 //wmpaint каким то хреном работает ии так
  557.             //-----------------------------------------------------------------
  558.             // выход из редактирования по клику в другое место
  559.             if (mousepos)       //заменить на более осмысленное !!!!!
  560.             {
  561.                 return 0;
  562.             }
  563.             //-----------------------------------------------------------------
  564.             // выходи из цикла по нажатию клавиши
  565.             if (key)
  566.             {
  567.                 break;
  568.             }
  569.             //-----------------------------------------------------------------
  570.         }
  571.  
  572.         debugflip();
  573.         //---------------------------------------------------------------------
  574.         switch (key)
  575.         {
  576.             //=================================================================
  577.             case VK_ESCAPE:
  578.                 return 0;
  579.             //=================================================================
  580.             case VK_RETURN:
  581.                 //-------------------------------------------------------------
  582.                 for (char *ptr = str + sz - 1;    *ptr == ' ' && ptr >= str;    *ptr-- = 0);
  583.                 //-------------------------------------------------------------
  584.                 return 1;
  585.             //=================================================================
  586.             case VK_LEFT:
  587.                 //-------------------------------------------------------------
  588.                 if (cr)
  589.                     cr--;
  590.                 //-------------------------------------------------------------
  591.                 continue;
  592.             //=================================================================
  593.             case VK_BACK:
  594.                 //-------------------------------------------------------------
  595.                 if (cr)
  596.                 {
  597.                     //---------------------------------------------------------
  598.                     for (i = cr;    i < sz;    i++)
  599.                         str[ i - 1] = str[ i];
  600.                     //---------------------------------------------------------
  601.                     str[ sz - 1] = ' ';
  602.                     --cr;
  603.                 }
  604.                 //-------------------------------------------------------------
  605.                 continue;
  606.             //=================================================================
  607.             case VK_RIGHT:
  608.                 //-------------------------------------------------------------
  609.                 if (cr != sz-1)
  610.                     cr++;
  611.                 //-------------------------------------------------------------
  612.                 continue;
  613.             //=================================================================
  614.             case VK_HOME:
  615.                 cr = 0;
  616.                 continue;
  617.             //=================================================================
  618.             case VK_END:
  619.                 //-------------------------------------------------------------
  620.                 for (cr = sz - 1;    cr && (str[ cr] == ' ') && (str[ cr - 1] == ' ');    cr--);
  621.                 //-------------------------------------------------------------
  622.                 continue;       //?????????
  623.             //=================================================================
  624.             case VK_DELETE:
  625.                 //-------------------------------------------------------------
  626.                 for (i = cr;    i < sz - 1;    i++)
  627.                     str[ i] = str[ i + 1];
  628.                 //-------------------------------------------------------------
  629.                 str[ sz - 1] = ' ';
  630.                 continue;
  631.             //=================================================================
  632.             case VK_INSERT:
  633.                 //-------------------------------------------------------------
  634.                 for (i = sz - 1;    i > cr;    i--)
  635.                     str[ i] = str[ i - 1];
  636.                 //-------------------------------------------------------------
  637.                 str[ cr] = ' ';
  638.                 continue;
  639.             //=================================================================
  640.             case VK_UP:         // выход из редактирования
  641.                 //printf("VK_UP\n");
  642.                 PostThreadMessage( GetCurrentThreadId(), WM_KEYDOWN, VK_UP, 1);
  643.                 //PostThreadMessage(GetCurrentThreadId(), WM_KEYUP, input.lastkey, 1);
  644.                 return 0;       // тут еще надо шагание в эту же сторону
  645.                 break;          // но как его сделать?
  646.             //=================================================================
  647.             case VK_DOWN:       // так не работает вверх
  648.                 //printf("VK_DOWN\n");
  649.                 PostThreadMessage( GetCurrentThreadId(), WM_KEYDOWN, VK_DOWN, 1);
  650.                 return 0;
  651.                 break;
  652.             //=================================================================
  653.         }
  654.         //---------------------------------------------------------------------
  655.         u8 Kbd[ 256];
  656.         GetKeyboardState( Kbd);
  657.        
  658.         unsigned short k = 0;
  659.         //---------------------------------------------------------------------
  660.         if ( ToAscii( key, 0, Kbd, &k, 0) == 1 )
  661.         {
  662.             char m;
  663.             //-----------------------------------------------------------------
  664.             if ( CharToOemBuff( (char *) &k, &m, 1) )
  665.             {
  666.                 //-------------------------------------------------------------
  667.                 // нормальнный людской ввод
  668.                 if (!insert_mode)                       // [NS]
  669.                 {
  670.                     for (i = sz - 1;    i > cr;    i--)
  671.                         str[ i] = str[ i - 1];
  672.                 }
  673.                 //-------------------------------------------------------------
  674.                 int u = toupper(m);
  675.                 //-------------------------------------------------------------
  676.                 if (!hex || (((u >= '0') && (u <= '9')) || ((u >= 'A') && (u <= 'F'))))
  677.                 {
  678.                     str[ cr++] = char( hex  ?  u :
  679.                                                m );
  680.                 }
  681.                 //-------------------------------------------------------------
  682.             }
  683.             //-----------------------------------------------------------------
  684.         }
  685.         //---------------------------------------------------------------------
  686.         if (cr == sz)   //тут надо выход вообще
  687.         {
  688.             cr--;
  689.                 //return 1;     //так выход
  690.                 //              //НО так начинаютсо дополнительные прроблемы
  691.                 //              //особенно когда введенное невалидно
  692.                 //              // и тогда курсор перескакиивает в начало и...
  693.         }
  694.         //---------------------------------------------------------------------
  695.     } //for (;;)
  696.     //-------------------------------------------------------------------------
  697. }
  698. //=============================================================================
  699.  
  700.  
  701.  
  702. //=============================================================================
  703. int input6dec( unsigned x, unsigned y, unsigned val)    // [NS]
  704. {
  705.     sprintf(    str,
  706.                 "%06d",
  707.                 val
  708.             );
  709.     //-------------------------------------------------------------------------
  710.     if (inputhex( x, y, 6, false ))     // не ясно за 4-й параметр true/false !!!!
  711.     {                                   // тк результат тот же
  712.         sscanf(     str,
  713.                     "%d",
  714.                     &val
  715.                 );
  716.         return int( val);
  717.     }
  718.     //-------------------------------------------------------------------------
  719.     return -1;
  720. }
  721. //=============================================================================
  722. int input4( unsigned x, unsigned y, unsigned val)
  723. {
  724.     sprintf(    str,
  725.                 "%04X",
  726.                 val
  727.             );
  728.     //-------------------------------------------------------------------------
  729.     if (inputhex( x, y, 4, true ))
  730.     {
  731.         sscanf(     str,
  732.                     "%x",
  733.                     &val
  734.                 );
  735.         return int( val);
  736.     }
  737.     //-------------------------------------------------------------------------
  738.     return -1;
  739. }
  740. //=============================================================================
  741. int input2( unsigned x, unsigned y, unsigned val)
  742. {
  743.     sprintf(    str,
  744.                 "%02X",
  745.                 val
  746.             );
  747.     //-------------------------------------------------------------------------
  748.     if (inputhex( x, y, 2, true ))
  749.     {
  750.         sscanf(     str,
  751.                     "%x",
  752.                     &val
  753.                 );
  754.         return int( val);
  755.     }
  756.     //-------------------------------------------------------------------------
  757.     return -1;
  758. }
  759. //=============================================================================
  760. int input1( unsigned x, unsigned y, unsigned val)
  761. {
  762.     sprintf(    str,
  763.                 "%01X",
  764.                 val
  765.            );
  766.     //-------------------------------------------------------------------------
  767.     if (inputhex( x, y, 1, true ))
  768.     {
  769.         sscanf(     str,
  770.                     "%x",
  771.                     &val
  772.               );
  773.         return int( val);
  774.     }
  775.     //-------------------------------------------------------------------------
  776.     return -1;
  777. }
  778. //=============================================================================
  779.  
  780.  
  781.  
  782.  
  783. //=============================================================================
  784. static void format_item( char *dst, size_t width, const char *text, MENUITEM::FLAGS flags)
  785. {
  786.     memset(     dst,
  787.                 ' ',
  788.                 width + 2);
  789.     dst[ width + 2] = 0;
  790.    
  791.     size_t sz = strlen( text), left = 0;
  792.     //-------------------------------------------------------------------------
  793.     if (sz > width)
  794.         sz = width;
  795.     //-------------------------------------------------------------------------
  796.     if (flags & MENUITEM::RIGHT)
  797.         left = width - sz;
  798.     //-------------------------------------------------------------------------
  799.     else if (flags & MENUITEM::CENTER)
  800.         left = (width - sz) / 2;
  801.     //-------------------------------------------------------------------------
  802.     memcpy(     dst + left + 1,
  803.                 text,
  804.                 sz
  805.            );
  806. }
  807. //=============================================================================
  808.  
  809.  
  810. //=============================================================================
  811. // рисование некоторых менюшек
  812. static void paint_items( MENUDEF *menu)
  813. {
  814.  
  815.     char ln[ 80];
  816.     unsigned item;
  817.  
  818.     size_t maxlen = strlen( menu->title);
  819.     //-------------------------------------------------------------------------
  820.     for (item = 0;    item < menu->n_items;    item++)
  821.     {
  822.         size_t sz = strlen( menu->items[ item].text);
  823.         maxlen = max( maxlen, sz);
  824.     }
  825.     //-------------------------------------------------------------------------
  826.     unsigned menu_dx = unsigned( maxlen + 2), menu_dy = menu->n_items + 3;
  827.     //unsigned menu_x = (80 - menu_dx) / 2, menu_y = (30 - menu_dy) / 2;
  828.     unsigned menu_x = (s80 - menu_dx) / 2, menu_y = (s30 - menu_dy) / 2;
  829.     filledframe(        menu_x,
  830.                         menu_y,
  831.                         menu_dx,
  832.                         menu_dy,
  833.                         DBG_ATTR_WINDOW_TEXT    //MENU_INSIDE
  834.                 );
  835.     format_item(        ln,
  836.                         maxlen,
  837.                         menu->title,
  838.                         MENUITEM::CENTER
  839.                 );
  840.     tprint(     menu_x,
  841.                 menu_y,
  842.                 ln,
  843.                 DBG_ATTR_WINDOW_TITLE           //MENU_HEADER
  844.            );
  845.     //-------------------------------------------------------------------------
  846.     for (/*unsigned*/ item = 0;    item < menu->n_items;    item++)
  847.     {
  848.         unsigned char color = DBG_ATTR_WINDOW_TEXT;     //MENU_ITEM;
  849.         //---------------------------------------------------------------------
  850.         if (menu->items[ item].flags & MENUITEM::DISABLED)
  851.             color = DBG_ATTR_WINDOW_TEXT_GRAY;          //MENU_ITEM_DIS;        //ERROR?
  852.         //---------------------------------------------------------------------
  853.         else if (item == menu->pos)
  854.             color = DBG_ATTR_WINDOW_TEXT_CURSOR;        //MENU_CURSOR;
  855.         //---------------------------------------------------------------------
  856.         format_item(    ln,
  857.                         maxlen,
  858.                         menu->items[ item].text,
  859.                         menu->items[ item].flags
  860.                     );
  861.         tprint(         menu_x,
  862.                         menu_y + item + 2,
  863.                         ln,
  864.                         color
  865.                 );
  866.     }
  867.     //-------------------------------------------------------------------------
  868. }
  869. //=============================================================================
  870.  
  871.  
  872. //=============================================================================
  873. static void menu_move( MENUDEF *menu, int dir)
  874. {
  875.     unsigned start = menu->pos;
  876.     //-------------------------------------------------------------------------
  877.     for (    ;    ;    )
  878.     {
  879.         menu->pos = unsigned( int( menu->pos) + dir);
  880.         //---------------------------------------------------------------------
  881.         if ((int) menu->pos == -1) menu->pos = menu->n_items-1;
  882.         //---------------------------------------------------------------------
  883.         if (menu->pos >= menu->n_items) menu->pos = 0;
  884.         //---------------------------------------------------------------------
  885.         if (!(menu->items[ menu->pos].flags & MENUITEM::DISABLED)) return;
  886.         //---------------------------------------------------------------------
  887.         if (menu->pos == start) return;
  888.         //---------------------------------------------------------------------
  889.     }
  890.     //-------------------------------------------------------------------------
  891. }
  892. //=============================================================================
  893.  
  894.  
  895. //=============================================================================
  896. char handle_menu( MENUDEF *menu)
  897. {
  898.     //-------------------------------------------------------------------------
  899.     if (menu->items[ menu->pos].flags & MENUITEM::DISABLED)
  900.         menu_move( menu, 1 );
  901.     //-------------------------------------------------------------------------
  902.     for (    ;    ;    )
  903.     {
  904.         paint_items( menu);
  905.         debugflip();
  906.  
  907.         unsigned key;
  908.         //---------------------------------------------------------------------
  909.         for (    ;    ;    Sleep( 20))  //20
  910.         {
  911.             key = process_msgs();
  912.             needclr =  0;
  913.             debugflip();
  914.             //-----------------------------------------------------------------
  915.             if (mousepos)
  916.                 return 0;
  917.             //-----------------------------------------------------------------
  918.             if (key)
  919.                 break;
  920.             //-----------------------------------------------------------------
  921.         }
  922.         //---------------------------------------------------------------------
  923.         if (key == VK_ESCAPE)
  924.             return 0;
  925.         //---------------------------------------------------------------------
  926.         if (key == VK_RETURN || key == VK_SPACE)
  927.             return 1;
  928.         //---------------------------------------------------------------------
  929.         if (key == VK_UP || key == VK_LEFT)
  930.             menu_move( menu, -1);
  931.         //---------------------------------------------------------------------
  932.         if (key == VK_DOWN || key == VK_RIGHT)
  933.             menu_move( menu, 1);
  934.         //---------------------------------------------------------------------
  935.         if (key == VK_HOME || key == VK_PRIOR)
  936.         {
  937.             menu->pos = -1U;
  938.             menu_move( menu, 1);
  939.         }
  940.         //---------------------------------------------------------------------
  941.         if (key == VK_END || key == VK_NEXT)
  942.         {
  943.             menu->pos = menu->n_items;
  944.             menu_move( menu, -1);
  945.         }
  946.         //---------------------------------------------------------------------
  947.     }
  948. }
  949. //=============================================================================
  950.  
  951.