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 "dx.h"
  6. #include "tape.h"
  7. #include "atm.h"
  8. #include "memory.h"
  9. #include "input.h"
  10. #include "inputpc.h"
  11.  
  12. #include "util.h"
  13.  
  14. //=============================================================================
  15. static unsigned char pastekeys[0x80-0x20] =
  16. {
  17.     // s     !     "     #     $     %     &     '     (     )     *     +     ,     -   .       /
  18.     0x71, 0xB1, 0xD1, 0xB3, 0xB4, 0xB5, 0xC5, 0xC4, 0xC3, 0xC2, 0xF5, 0xE3, 0xF4, 0xE4, 0xF3, 0x85,
  19.     // 0     1     2     3     4     5     6     7     8     9     :     ;     <     =     >     ?
  20.     0x41, 0x31, 0x32, 0x33, 0x34, 0x35, 0x45, 0x44, 0x43, 0x42, 0x82, 0xD2, 0xA4, 0xE2, 0xA5, 0x84,
  21.     // @     A     B     C     D     E     F     G     H     I     J     K     L     M     N     O
  22.     0xB2, 0x19, 0x7D, 0x0C, 0x1B, 0x2B, 0x1C, 0x1D, 0x6D, 0x5B, 0x6C, 0x6B, 0x6A, 0x7B, 0x7C, 0x5A,
  23.     // P     Q     R     S     T     U     V     W     X     Y     Z     [     \     ]     ^     _
  24.     0x59, 0x29, 0x2C, 0x1A, 0x2D, 0x5C, 0x0D, 0x2A, 0x0B, 0x5D, 0x0A, 0xD5, 0x93, 0xD4, 0xE5, 0xC1,
  25.     // `     a     b     c     d     e     f     g     h     i     j     k     l     m     n     o
  26.     0x83, 0x11, 0x75, 0x04, 0x13, 0x23, 0x14, 0x15, 0x65, 0x53, 0x64, 0x63, 0x62, 0x73, 0x74, 0x52,
  27.     // p     q     r     s     t     u     v     w     x     y     z     {     |     }     ~
  28.     0x51, 0x21, 0x24, 0x12, 0x25, 0x54, 0x05, 0x22, 0x03, 0x55, 0x02, 0x94, 0x92, 0x95, 0x91, 0xC4
  29. };  //`=0x83, 127=' - Alone Coder
  30. //=============================================================================
  31.  
  32.  
  33. //=============================================================================
  34. static unsigned char ruspastekeys[64] =
  35. {
  36.     'A','B','W','G','D','E','V','Z','I','J','K','L','M','N','O','P',
  37.     'R','S','T','U','F','H','C','^','[',']',127,'Y','X','\\',64,'Q',
  38.     'a','b','w','g','d','e','v','z','i','j','k','l','m','n','o','p',
  39.     'r','s','t','u','f','h','c','~','{','}','_','y','x','|','`','q'
  40. };  //Alone Coder
  41. //=============================================================================
  42.  
  43.  
  44. //=============================================================================
  45. void K_INPUT::clear_zx()
  46. {
  47.     size_t i;
  48.     //-------------------------------------------------------------------------
  49.     for(i = 0; i < _countof(kbd_x4); i++)
  50.         kbd_x4[i] = -1U;
  51.     //-------------------------------------------------------------------------
  52. }
  53. //=============================================================================
  54.  
  55.  
  56. //=============================================================================
  57. inline void K_INPUT::press_zx(unsigned char key)
  58. {
  59.     //-------------------------------------------------------------------------
  60.     if (key & 0x08)
  61.         kbd[0] &= ~1; // caps
  62.     //-------------------------------------------------------------------------
  63.     if (key & 0x80)
  64.         kbd[7] &= ~2; // sym
  65.     //-------------------------------------------------------------------------
  66.     if (key & 7)
  67.         kbd[(key >> 4) & 7] &= ~(1 << ((key & 7) - 1));
  68.     //-------------------------------------------------------------------------
  69. }
  70. //=============================================================================
  71.  
  72. // #include "inputpc.cpp"
  73.  
  74. //=============================================================================
  75. bool K_INPUT::process_pc_layout()
  76. {
  77.     for (unsigned i = 0; i < pc_layout_count; i++)
  78.     {
  79.         if (kbdpc[pc_layout[i].vkey] & 0x80)
  80.         {
  81.             press_zx((( kbdpc[ DIK_LSHIFT] | kbdpc[ DIK_RSHIFT]) & 0x80)  ?  pc_layout[i].shifted :
  82.                                                                            pc_layout[i].normal);
  83.             return true;
  84.         }
  85.     }
  86.     return false;
  87. }
  88. //=============================================================================
  89.  
  90.  
  91. //=============================================================================
  92. void K_INPUT::make_matrix()
  93. {
  94.     unsigned char altlock = conf.input.altlock    ?     (kbdpc[DIK_LMENU] | kbdpc[DIK_RMENU]) & 0x80 :
  95.                                                         0;
  96.     size_t i;
  97.  
  98.     kjoy = 0xFF;
  99.     fjoy = 0xFF;
  100.    
  101.     //-------------------------------------------------------------------------
  102.     switch (keymode)
  103.     {
  104.         //---------------------------------------------------------------------
  105.         case KM_DEFAULT:
  106.             //-----------------------------------------------------------------
  107.             clear_zx();
  108.             //-----------------------------------------------------------------
  109.             if (!altlock)
  110.             {
  111.                 if (!conf.input.keybpcmode || !process_pc_layout())
  112.                 {
  113.                     for (i = 0; i < VK_MAX; i++)
  114.                     {
  115.                         if (kbdpc[i] & 0x80)
  116.                         {
  117.                             *(inports[i].port1) &= inports[i].mask1;
  118.                             *(inports[i].port2) &= inports[i].mask2;
  119.                             /*
  120.                             if(kbd[6] == 0xFE)
  121.                                 __debugbreak();
  122.                             */
  123.                         }
  124.                     }
  125.                 }
  126.             }
  127.             //-----------------------------------------------------------------
  128.             if (conf.input.fire)
  129.             {
  130.                 //-------------------------------------------------------------
  131.                 if (!--firedelay)
  132.                 {
  133.                     firedelay = conf.input.firedelay;
  134.                     firestate ^= 1;
  135.                 }
  136.                 //-------------------------------------------------------------
  137.                 zxkeymap *active_zxk = conf.input.active_zxk;
  138.                 if (firestate)
  139.                     *(active_zxk->zxk[conf.input.firenum].port) &= active_zxk->zxk[conf.input.firenum].mask;
  140.                 //-------------------------------------------------------------
  141.             }
  142.             //-----------------------------------------------------------------
  143.         break;
  144.         //---------------------------------------------------------------------
  145.         case KM_KEYSTICK:
  146.             //-----------------------------------------------------------------
  147.             for (i = 0; i < _countof(kbd_x4); i++)
  148.                 kbd_x4[i] = rkbd_x4[i];
  149.             //-----------------------------------------------------------------
  150.             if (stick_delay)
  151.             {
  152.                 stick_delay--;
  153.                 altlock = 1;
  154.             }
  155.             //-----------------------------------------------------------------
  156.             if (!altlock)
  157.             {
  158.                 for (i = 0; i < VK_MAX; i++)
  159.                 {
  160.                     if (kbdpc[i] & 0x80)
  161.                     {
  162.                         *(inports[i].port1) ^= ~inports[i].mask1;
  163.                         *(inports[i].port2) ^= ~inports[i].mask2;
  164.                     }
  165.                 }
  166.             }
  167.             //-----------------------------------------------------------------
  168.             if ((kbd_x4[0] ^ rkbd_x4[0]) | (kbd_x4[1] ^ rkbd_x4[1]))
  169.                 stick_delay = 10;
  170.             //-----------------------------------------------------------------
  171.         break;
  172.         //---------------------------------------------------------------------
  173.         case KM_PASTE_HOLD:
  174.         {
  175.             clear_zx();
  176.             //-----------------------------------------------------------------
  177.             // caps
  178.             if (tdata & 0x08)
  179.                 kbd[0] &= ~1;
  180.             //-----------------------------------------------------------------
  181.             // sym
  182.             if (tdata & 0x80)
  183.                 kbd[7] &= ~2;
  184.             //-----------------------------------------------------------------
  185.             if (tdata & 7)
  186.                 kbd[(tdata >> 4) & 7] &= ~(1 << ((tdata & 7) - 1));
  187.             //-----------------------------------------------------------------
  188.             if (tdelay)
  189.             {
  190.                 tdelay--;
  191.                 break;
  192.             }
  193.             //-----------------------------------------------------------------
  194.             tdelay = conf.input.paste_release;
  195.             //-----------------------------------------------------------------
  196.             if (tdata == 0x61)
  197.                 tdelay += conf.input.paste_newline;
  198.             //-----------------------------------------------------------------
  199.             keymode = KM_PASTE_RELEASE;
  200.             //-----------------------------------------------------------------
  201.             break;
  202.         }
  203.         //---------------------------------------------------------------------
  204.         case KM_PASTE_RELEASE:
  205.         {
  206.             clear_zx();
  207.             //-----------------------------------------------------------------
  208.             if (tdelay)
  209.             {
  210.                 tdelay--;
  211.                 break;
  212.             }
  213.             //-----------------------------------------------------------------
  214.             if (textsize == textoffset)
  215.             {
  216.                 keymode = KM_DEFAULT;
  217.                 free(textbuffer);
  218.                 textbuffer = nullptr;
  219.                 break;
  220.             }
  221.             //-----------------------------------------------------------------
  222.             tdelay = conf.input.paste_hold;
  223.             unsigned char kdata = textbuffer[textoffset++];
  224.             //-----------------------------------------------------------------
  225.             if (kdata == 0x0D)
  226.             {
  227.                 //-------------------------------------------------------------
  228.                 if (textoffset < textsize && textbuffer[textoffset] == 0x0A)
  229.                     textoffset++;
  230.                 //-------------------------------------------------------------
  231.                 tdata = 0x61;
  232.             }
  233.             //-----------------------------------------------------------------
  234.             else
  235.             {
  236.                 //-------------------------------------------------------------
  237.                 if (kdata == 0xA8)
  238.                     kdata = 'E';        //Alone Coder (big YO)
  239.                 //-------------------------------------------------------------
  240.                 if ((kdata >= 0xC0)||(kdata == 0xB8)) //RUS
  241.                 {
  242.                     //pressedit=
  243.                     //0 = press edit, pressedit++, textoffset--
  244.                     //1 = press letter, pressedit++, textoffset--
  245.                     //2 = press edit, pressedit=0
  246.                     switch (pressedit)
  247.                     {
  248.                         //-----------------------------------------------------
  249.                         case 0:
  250.                         {
  251.                             tdata = 0x39;
  252.                             pressedit++;
  253.                             textoffset--;
  254.                             break;
  255.                         };
  256.                         //-----------------------------------------------------
  257.                         case 1:
  258.                         {
  259.                             if (kdata == 0xB8)
  260.                                 kdata = '&';
  261.                             else
  262.                                 kdata = ruspastekeys[kdata - 0xC0];
  263.                             tdata = pastekeys[kdata - 0x20];
  264.                             pressedit++;
  265.                             textoffset--;
  266.                             break;
  267.                         }
  268.                         //-----------------------------------------------------
  269.                         case 2:
  270.                         {
  271.                             tdata = 0x39;
  272.                             pressedit = 0;
  273.                         };
  274.                         //-----------------------------------------------------
  275.                     };
  276.                     //---------------------------------------------------------
  277.                     if (!tdata)
  278.                         break; // empty key
  279.                     //---------------------------------------------------------
  280.                 } //Alone Coder
  281.                 //-------------------------------------------------------------
  282.                 else
  283.                 {
  284.                     //---------------------------------------------------------
  285.                     if (kdata < 0x20 || kdata >= 0x80)
  286.                         break; // keep release state
  287.                     //---------------------------------------------------------
  288.                     tdata = pastekeys[kdata - 0x20];
  289.                     //---------------------------------------------------------
  290.                     if (!tdata)
  291.                         break; // empty key
  292.                     //---------------------------------------------------------
  293.                 }
  294.             }
  295.             //-----------------------------------------------------------------
  296.             keymode = KM_PASTE_HOLD;
  297.             break;
  298.         }
  299.         //---------------------------------------------------------------------
  300.     } //switch (keymode)
  301.     //-------------------------------------------------------------------------
  302.    
  303.     kjoy ^= 0xFF;
  304.    
  305.     //-------------------------------------------------------------------------
  306.     if (conf.input.joymouse)
  307.         kjoy |= mousejoy;
  308.     //-------------------------------------------------------------------------
  309.     for(i = 0; i < _countof(kbd_x4); i++)
  310.         rkbd_x4[i] = kbd_x4[i];
  311.     //-------------------------------------------------------------------------
  312.     if (!conf.input.keymatrix)
  313.         return;
  314.     //-------------------------------------------------------------------------
  315.     for (;;)
  316.     {
  317.         char done = 1;
  318.         //---------------------------------------------------------------------
  319.         for (size_t k = 0; k < _countof(kbd) - 1; k++)
  320.         {
  321.             //-----------------------------------------------------------------
  322.             for (size_t j = k+1; j < _countof(kbd); j++)
  323.             {
  324.                 if (((kbd[k] | kbd[j]) != 0xFF) && (kbd[k] != kbd[j]))
  325.                 {
  326.                     kbd[k] = kbd[j] = (kbd[k] & kbd[j]);
  327.                     done = 0;
  328.                 }
  329.             }
  330.             //---------------------------------------------------------------------
  331.         }
  332.         //---------------------------------------------------------------------
  333.         if (done)
  334.             return;
  335.         //---------------------------------------------------------------------
  336.     }
  337. }
  338. //=============================================================================
  339.  
  340.  
  341. //=============================================================================
  342.  
  343. __inline int sign_pm( int a)
  344. {
  345.     return (a < 0)  ?  -1 :
  346.                         1;
  347. }
  348.  
  349. //=============================================================================
  350.  
  351. static u8 CapsLockState = 0;
  352.  
  353. //=============================================================================
  354. char K_INPUT::readdevices()
  355. {
  356.     //-------------------------------------------------------------------------
  357.     if (nokb) nokb--;           // NEDOREPO
  358.     //-------------------------------------------------------------------------
  359.     if (nomouse) nomouse--;
  360.     //-------------------------------------------------------------------------
  361.     kbdpc[ VK_JLEFT]  = 0;
  362.     kbdpc[ VK_JRIGHT] = 0;
  363.     kbdpc[ VK_JUP]    = 0;
  364.     kbdpc[ VK_JDOWN]  = 0;
  365.     kbdpc[ VK_JFIRE]  = 0;
  366.     //-------------------------------------------------------------------------
  367.     int i;
  368.     //-------------------------------------------------------------------------
  369.     for (i = 0;    i < 32;    i++)
  370.         kbdpc[ VK_JB0 + i] = 0;
  371.     //-------------------------------------------------------------------------
  372.     if (active && dijoyst)
  373.     {
  374.         dijoyst->Poll();
  375.         DIJOYSTATE js;
  376.         readdevice( &js, sizeof js, (LPDIRECTINPUTDEVICE) dijoyst);
  377.         //---------------------------------------------------------------------
  378.         if ((signed short)js.lX < 0) kbdpc[ VK_JLEFT]  = 0x80;
  379.         if ((signed short)js.lX > 0) kbdpc[ VK_JRIGHT] = 0x80;
  380.         if ((signed short)js.lY < 0) kbdpc[ VK_JUP]    = 0x80;
  381.         if ((signed short)js.lY > 0) kbdpc[ VK_JDOWN]  = 0x80;
  382.         //---------------------------------------------------------------------
  383.         for (i = 0;    i < 32;    i++)
  384.         {
  385.             if (js.rgbButtons[i] & 0x80)
  386.                 kbdpc[ VK_JB0 + i] = 0x80;
  387.         }
  388.         //---------------------------------------------------------------------
  389.     }
  390.     //-------------------------------------------------------------------------
  391.    
  392.     //-------------------------------------------------------------------------
  393.     mbuttons = 0xFF;
  394.     msx_prev = msx;
  395.     msy_prev = msy;
  396.     kbdpc[ VK_LMB] = 0;
  397.     kbdpc[ VK_RMB] = 0;
  398.     kbdpc[ VK_MMB] = 0;
  399.     kbdpc[ VK_MWU] = 0;
  400.     kbdpc[ VK_MWD] = 0;
  401.     //-------------------------------------------------------------------------
  402.  
  403.     //-------------------------------------------------------------------------
  404.     // ─ы  ъюёЄ√ы  юЄ ёърърэш  ъєЁёюЁр яЁш чрїтрЄх Їюъєёр [NS] r0112
  405.     //-------------------------------------------------------------------------
  406.     //
  407.     // ёюсёЄтхээю яЁюсыхьр
  408.     //
  409.     // unreal                   ъръ эрфю
  410.     // 1                        1
  411.     // .2                       .2
  412.     // ..3                      ..3
  413.     // ...4                     ...4
  414.     // ....5                    ....5
  415.     // .....6                   .....6
  416.     //
  417.     // ╧╬╥┼╨▀ ╘╬╩╙╤└
  418.     //
  419.     // .....6                   .....6
  420.     // .....6                   .....6
  421.     // .....6 = last            .....6
  422.     //
  423.     // ┬╬╤╥└═╬┬╦┼═╚┼ ╘╬╩╙╤└
  424.     //
  425.     // ..3 = first              .....6 = new    first = 3  last = 6     cor = (last - first) = (6-3) = 3
  426.     // ...4                     ......7         new = 3 + cor
  427.     // ....5                    .......8
  428.     // .....6                   ........9
  429.     //
  430.     // фы  FPS °єЄюЁют ¤Єр урЇэю - фшъшщ рїЄєэї єсхтрЄ№ эрї!!!
  431.     //
  432.         static int cor_x = 0;
  433.         static int cor_y = 0;
  434.         static int first_new_x;
  435.         static int first_new_y;
  436.         static int last_msx;
  437.         static int last_msy;
  438.         static bool first_new_flag = TRUE;
  439.     //-------------------------------------------------------------------------
  440.  
  441.     //-------------------------------------------------------------------------
  442.     // ╩єЁёюЁ чрїтрўхэ
  443. //  if ((conf.fullscr || conf.lockmouse))               // [NS]
  444. //  if ((conf.fullscr || conf.lockmouse) && !nomouse)   // ORIG
  445. //  if (conf.lockmouse && !nomouse)                     // HZ
  446.     if ((conf.lockmouse) && !nomouse)   // [NS] r0112   // nomouse - тшфшью чрфхЁцър фю эрўрыр ттюфр ё ь√°ют
  447.     {                                                   // ЄхяхЁ№ Їєыы ёъЁшээ эх чэрўшЄ чрїтрЄ ь√°ют!!!
  448.         unsigned cl1;
  449.         unsigned cl2;
  450.         cl1 = unsigned( abs( msx - msx_prev)) * ay_reset_t / conf.frame;
  451.         cl2 = unsigned( abs( msx - msx_prev));
  452.         ay_x0 += int( cl2 - cl1) * sign_pm( msx - msx_prev);
  453.         cl1 = unsigned( abs( msy - msy_prev)) * ay_reset_t / conf.frame;
  454.         cl2 = unsigned( abs( msy - msy_prev));
  455.         ay_y0 += int( cl2 - cl1) * sign_pm( msy - msy_prev);
  456.         ay_reset_t = 0;
  457.  
  458. //      printf("%s\n", __FUNCTION__);
  459.  
  460.         //---------------------------------------------------------------------
  461.         DIMOUSESTATE md;
  462.         readmouse( &md);
  463.         //---------------------------------------------------------------------
  464.         if (conf.input.mouseswap)
  465.         {
  466.             unsigned char t = md.rgbButtons[ 0];
  467.             md.rgbButtons[ 0] = md.rgbButtons[ 1];
  468.             md.rgbButtons[ 1] = t;
  469.         }
  470.         //---------------------------------------------------------------------
  471.         msx = md.lX;
  472.         msy = -md.lY;
  473.         //---------------------------------------------------------------------
  474.         if (conf.input.mousescale >= 0)
  475.         {
  476.             msx *= (1 << conf.input.mousescale);        // ёфхырЄ№ эюЁьры№э√х ъю¤ЇшЎшхэЄ√!!!
  477.             msy *= (1 << conf.input.mousescale);
  478.         }
  479.         else
  480.         {
  481.             msx /= (1 << -conf.input.mousescale);
  482.             msy /= (1 << -conf.input.mousescale);
  483.         }
  484.  
  485.         //---------------------------------------------------------------------
  486.         // ╩╬╤╥█╦▄!!! (юЄ ёърърэш  ъєЁёюЁр яЁш чрїтрЄх Їюъєёр)          [NS] r0112
  487.         //      //-------------------------------------------------------------
  488.         //      // ыютшь ёрьюх яхЁтюх чэрўхэшх яюёых чрїтрЄр Їюъєёр
  489.                 if (first_new_flag)
  490.                 {
  491.                     first_new_x = msx;
  492.                     first_new_y = msy;
  493.                     cor_x = (last_msx - first_new_x);
  494.                     cor_y = (last_msy - first_new_y);
  495.                     first_new_flag = FALSE; // Їыру ўЄюс сюы№°°х эх ыютшЄ№
  496.                 }
  497.                 //-------------------------------------------------------------
  498.                 // ъюЁЁхъЄшЁєхь ёърърэшх
  499.                 msx += cor_x;  
  500.                 msy += cor_y;
  501.         //---------------------------------------------------------------------
  502.         if (md.rgbButtons[0])
  503.         {
  504.             mbuttons &= ~1;
  505.             kbdpc[ VK_LMB] = 0x80;
  506.         }
  507.         //---------------------------------------------------------------------
  508.         if (md.rgbButtons[1])
  509.         {
  510.             mbuttons &= ~2;
  511.             kbdpc[ VK_RMB] = 0x80;
  512.         }
  513.         //---------------------------------------------------------------------
  514.         if (md.rgbButtons[2])
  515.         {
  516.             mbuttons &= ~4;
  517.             kbdpc[ VK_MMB] = 0x80;
  518.         }
  519.         //---------------------------------------------------------------------
  520.         int wheel_delta = md.lZ - prev_wheel;
  521.         prev_wheel = md.lZ;
  522. //      if (wheel_delta < 0) kbdpc[VK_MWD] = 0x80;
  523. //      if (wheel_delta > 0) kbdpc[VK_MWU] = 0x80;
  524. //0.36.6 from 0.35b2
  525.         //---------------------------------------------------------------------
  526.         if (conf.input.mousewheel == MOUSE_WHEEL_KEYBOARD)
  527.         {
  528.             //-----------------------------------------------------------------
  529.             if (wheel_delta < 0)
  530.                 kbdpc[ VK_MWD] = 0x80;
  531.             //-----------------------------------------------------------------
  532.             if (wheel_delta > 0)
  533.                 kbdpc[ VK_MWU] = 0x80;
  534.             //-----------------------------------------------------------------
  535.         }
  536.         //---------------------------------------------------------------------
  537.         if (conf.input.mousewheel == MOUSE_WHEEL_KEMPSTON)
  538.         {
  539.             if (wheel_delta < 0)
  540.             {
  541.         //      wheel -= 0x10;                          //0.39.0
  542.                 wheel += 0x10; //24.11.2021 Alone       //NEDOREPO
  543.             }
  544.             if (wheel_delta > 0)
  545.             {
  546.         //      wheel += 0x10;                          //0.39.0
  547.                 wheel -= 0x10; //24.11.2021 Alone       //NEDOREPO
  548.             }
  549.             mbuttons = (mbuttons & 0x0F) + (wheel & 0xF0);
  550.         }
  551. //~
  552.     }   //if ((conf.fullscr || conf.lockmouse) && !nomouse)
  553.     //-------------------------------------------------------------------------
  554.     // ╩єЁёюЁ эхчрїтрўхэ
  555.     else
  556.     {
  557.             //-----------------------------------------------------------------
  558.             // ╩╙╤╬╩ ╩╬╤╥█╦▀ юЄ ёърърэш  ъєЁёюЁр яЁш чрїтрЄх Їюъєёр [NS] r0112
  559.             //-----------------------------------------------------------------
  560.             // ыютшь яюёыхфэхх чэрўхэшх
  561.             last_msx = msx;
  562.             last_msy = msy;
  563.             first_new_flag = TRUE; // тчтюфшь ыютє°ъє яхЁтюую чэрўхэш 
  564.             //-----------------------------------------------------------------
  565.     }
  566.     //-------------------------------------------------------------------------
  567.    
  568.     //-------------------------------------------------------------------------
  569. //      lastkey = process_msgs();       0.39.0
  570. //      memset(kbdpc, 0, 256);  // ╠√°№ ш фцющёЄшъ эх юўш∙рхь
  571.     //-------------------------------------------------------------------------
  572.     if (nokb)                   // NEDOREPO
  573.     {
  574.         memset( kbdpc, 0, 256); // ╠√°№ ш фцющёЄшъ эх юўш∙рхь
  575.     }
  576.     //-------------------------------------------------------------------------
  577.     else
  578.     {
  579.         //GetKeyboardState(kbdpc);
  580.  
  581.         //thims zxevo_ps/2
  582.         //static unsigned char kbdpc_prev[ VK_MAX];     //NEDOREPO
  583.         //      kbdpc_prev[] т√эхёхэ т vars.cpp [NS]
  584.         //---------------------------------------------------------------------
  585.         //if (buffer_enabled && (!dbgbreak))
  586.         if ((buffer_enabled || atm620_xt_keyb_buffer_enabled) && (!dbgbreak))   // [NS]
  587.             memcpy( kbdpc_prev, kbdpc, sizeof( kbdpc));
  588.         //---------------------------------------------------------------------
  589.         ReadKeyboard( kbdpc);
  590.  
  591. // [NS]
  592. /*
  593.         // "╚ёяЁртыхэшх" "чрышярэш " CapsLock,
  594.         // CapsLock яЁш юфэюъЁрЄэюь эрцрЄшш тючтЁр∙рхЄ тёхуфр 0x80, яюър эх сєфхЄ эрцрЄ яютЄюЁэю
  595.         //      ўю чр сЁхф?
  596.         u8 cl = kbdpc[DIK_CAPSLOCK];
  597.         kbdpc[DIK_CAPSLOCK] ^= CapsLockState;   // хёыш эрцрЄ
  598.                                                 // юэю хую ёЁрчє ёсЁюёшЄ т 0 ю_╬
  599.         CapsLockState = cl;
  600. //
  601.  
  602.  [NS] уюЇэюрыюэюЇшъё фхырхЄ їєшЄє
  603.  т шЄюух ыюу:
  604.  
  605.         caps press
  606.                 ps2_key 58 - key on
  607.  
  608.                 ps2_key F0 - key off
  609.                 ps2_key 58
  610.  
  611.         caps unpress
  612.                 ps2_key 58 - key on
  613.  
  614.                 ps2_key F0 - key off
  615.                 ps2_key 58
  616.  
  617.  ъхяё фЁюўшЄёю 2 Ёрчр яю Ўхэх 1
  618.  ъхяё эрцшьрхЄёю ш юЄцшьрхЄёю яЁш эрцрЄшш
  619.  ш х∙х Ёрч эрцшьрхЄёю ш юЄцшььрхЄёю яЁш юЄяєёърэшш
  620.  
  621.  ўЄю Єръюх рыюэютёъюх "юфэюъЁрЄэюх эрцрЄшх" т єяюЁ эхяюэ Єэю
  622.  
  623. */
  624.  
  625.         //---------------------------------------------------------------------
  626.         if (buffer_enabled && (!dbgbreak))      //DimkaM fix
  627.         {
  628.             // чрЄрыъштрэшх ёърэъюфют т сєЇхЁ
  629.             for (int i = 0;    i < sizeof( kbdpc);    i++)
  630.             {
  631.                 // ps2
  632.                 if ((kbdpc[i] & 0x80) != (kbdpc_prev[i] & 0x80) && dik_scan[i])
  633.                 {
  634.                     if (dik_scan[i] & 0x0100) input.buffer.Push( 0xE0);
  635.                     if (kbdpc_prev[i] & 0x80) input.buffer.Push( 0xF0); //key off
  636.                     input.buffer.Push( dik_scan[i] & 0x00FF);
  637.                 }
  638.             }
  639.         }       //NEDOREPO
  640.         //---------------------------------------------------------------------
  641.         if (atm620_xt_keyb_buffer_enabled && (!dbgbreak))       // [NS]
  642.         {
  643.             // чрЄрыъштрэшх ёърэъюфют т сєЇхЁ
  644.             for (int i = 0;    i < sizeof( kbdpc);    i++)
  645.             {
  646.                 // ATM 6.20 XT Keyb [NS]
  647.                 if ((kbdpc[i] & 0x80) != (kbdpc_prev[i] & 0x80) && atm620_xt_keyb_dik_scan[i])
  648.                 {
  649.                     if (atm620_xt_keyb_dik_scan[i] & 0x0100) input.atm620_xt_keyb_buffer.Push( 0xE0);
  650.                     //---------------------------------------------------------
  651.                     //key off
  652.                     if (kbdpc_prev[i] & 0x80)
  653.                     {
  654.                         input.atm620_xt_keyb_buffer.Push( (atm620_xt_keyb_dik_scan[i] & 0x00FF) | 0x01 );       //0x01 = 0x80
  655.                     }
  656.                     //---------------------------------------------------------
  657.                     //key on
  658.                     else
  659.                     {
  660.                         input.atm620_xt_keyb_buffer.Push( atm620_xt_keyb_dik_scan[i] & 0x00FF);
  661.                     }
  662.                     //---------------------------------------------------------
  663.                 }
  664.             }
  665.         }
  666.         //---------------------------------------------------------------------
  667.         /*
  668.         // р чЁ  Єєяю чръюьхэўхээю [NS]
  669.         if (lastkey)            //NEDOREPO
  670.         {
  671. //[vv]          kbdpc[ lastkey] = 0x80;         ?????? [NS]
  672.         }
  673.         */
  674.         //---------------------------------------------------------------------
  675.     }   //else (nokb)
  676.     //-------------------------------------------------------------------------
  677.     lastkey = process_msgs();   // V_KEY
  678.     //-------------------------------------------------------------------------
  679.     // Єъ фрээ√х юЄ process_msgs ьюуєЄ с√Є№ эх ёюуырёютрэ√ ё kbdpc[]    [NS]
  680.     // эєцэю чряшёрЄ№ т kbdpc[] яюыєўхээюх шч process_msgs
  681.     if (lastkey)
  682.     {
  683.         //printf("win %02X\n", lastkey);
  684.         //printf("oem %02X\n", key_down_oem_key);
  685.         //printf("kbdpc %02X\n", key_down_kbdpc_key);
  686.         kbdpc[ key_down_kbdpc_key] = 0x80;
  687.     }
  688.     //-------------------------------------------------------------------------
  689.    
  690.    
  691.     // ╨хчєы№ЄрЄ эхёютьхёЄшь ё kbdpc[] !!!!!
  692.                                 // ш эх ёюуырёютрэ
  693.                                 // т шЄюух lastkey ёююс∙р хЄ ўЄю ъэюяър эрцрЄр
  694.                                 // р т kbdpc[] эшъръющ ъэюяъш эхЄ
  695.                                 // шэюуфр хх эхЄ т 100% ёыєўрхт !!!
  696.                                 // ╥└╩╞┼
  697.                                 // фю kbdpc эхфюїюфшЄ тшЁЄєры№эр  ъыртшрЄєЁр!!!
  698.                                 // р тюЄ process_msgs фюёЄрхЄ шч юэю ъэюяъш !!!
  699.                 // ЄхяхЁ№ process_msgs тючтЁр∙рхЄ уыюсры№э√х
  700.                 // key_down_oem_key
  701.                 // key_down_v_key       - Єюцх ўЄю ш return
  702.        
  703.        
  704.         // ЄєЄ эєцхэ kbdpc[ lastkey] = 0x80;
  705.         // ═╬ lastkey эєцэю яхЁхтхёЄш т ЇюЁьрЄ kbdpc !!!
  706.         // шч тхэфютюую vk_key т xt
  707.             //-----------------------------------------------------------------
  708.             // Єръющ трЁшрэЄ ЁрсюЄрхЄ, эр тшф, їюЁю°ю
  709.             // ═╬ эхЄє ярєч√ ьхцфє эрцрЄш ьш
  710.             // р process_msgs() х∙х ш °ыхЄ тхэфют√щ ртЄюяютЄюЁ
  711.             /*
  712.             lastkey = 0;
  713.             // 0 - nil key
  714.             for (int i = 1;    i < sizeof( kbdpc);    i++)      // TZT [NS]
  715.             {
  716.                 lastkey |= kbdpc[i];
  717.             }
  718.             */
  719.             //-----------------------------------------------------------------
  720.             // ╥ръ эх ЁрсюЄрхЄ ртЄюяютЄюЁ
  721.             // ш эхтючьюцэю яюыы№чютррЄёёю ффхсрухЁЁюь шЄф
  722.             /*
  723.             lastkey = 0;
  724.             // 0 - nil key
  725.             for (int i = 1;    i < sizeof( kbdpc);    i++)      // TZT [NS]
  726.             {
  727.                 //printf("%X ",kbdpc[i]);
  728.                 if ( (kbdpc[i] & 0x80) != (kbdpc_prev[i] & 0x80))       //яю ЇръЄє шчьхэхэш 
  729.                 {
  730.                     lastkey |= kbdpc[i];
  731.                 }
  732.             }
  733.             */
  734.             // ╟└╧╬╦═┼═╚┼ kbdpc_prev ═╙╞═╬ ╧╨╚═╙─╚╥┼╦▄═╬ ┬╩╦▐╫└╥▄ !!!!!!!!
  735.             //-----------------------------------------------------------------
  736.            
  737.            
  738.             /*
  739.             // Ёрсюўшщ ёяюёюс эю эєцэр уютэюЄрсышЎр
  740.             unsigned char xt_like_lastkey = vk_key_2_xt_key_tab[ lastkey];
  741.             //-----------------------------------------------------------------
  742.             // ьхЁцшь ё х∙х юфэшь шёЄюўэшъюь ъэюяюъ
  743.             //    ЄєЄ эрфю фюсртшЄ№ х∙х ъюфр
  744.             //    ўЄюс юЄышўрЄ№ эхюЄышўрсхы№э√х ъэюяъш
  745.             //    Єъ ¤ЄюЄ шёЄюўэшъ ъэюяюъ ЁрсюЄрхЄ ё тшЁЄєры№эющ ъыртшрЄєЁющ !!!
  746.             if (xt_like_lastkey)
  747.             {
  748.                 kbdpc[ xt_like_lastkey] = 0x80;
  749.             }
  750.             //-----------------------------------------------------------------
  751.             */
  752.            
  753.  
  754.  
  755.            
  756.     //-------------------------------------------------------------------------
  757. /* [vv]
  758.    if (temp.win9x)
  759.    {
  760.       kbdpc[VK_LSHIFT] = kbdpcEX[0];
  761.       kbdpc[VK_RSHIFT] = kbdpcEX[1];
  762.       kbdpc[VK_LCONTROL] = kbdpcEX[2];
  763.       kbdpc[VK_RCONTROL] = kbdpcEX[3];
  764.       kbdpc[VK_LMENU] = kbdpcEX[4];
  765.       kbdpc[VK_RMENU] = kbdpcEX[5];
  766.    } //Dexus
  767. */
  768. //-----------------------------------------------------------------------------
  769.  
  770. //    if (lastkey)
  771. //    {
  772. //                      //printf("%x",lastkey);
  773. //                      printf("\nwin %x\n",lastkey);
  774. //                      printf("new %x\n",xt_like_lastkey);
  775. //    }
  776.     //else              printf(".");
  777.    
  778.     return lastkey  ?   1 :
  779.                         0;
  780. }
  781. //=============================================================================
  782.  
  783.  
  784. //=============================================================================
  785. void K_INPUT::aymouse_wr(unsigned char val)
  786. {
  787.     //-------------------------------------------------------------------------
  788.     // reset by edge bit6: 1->0
  789.     if (ayR14 & ~val & 0x40)
  790.     {
  791.         ay_x0 = ay_y0 = 8;
  792.         ay_reset_t = cpu.t;
  793.     }
  794.     //-------------------------------------------------------------------------
  795.     ayR14 = val;
  796. }
  797. //=============================================================================
  798.  
  799.  
  800. //=============================================================================
  801. unsigned char K_INPUT::aymouse_rd()
  802. {
  803.     unsigned coord;
  804.     if (ayR14 & 0x40)
  805.     {
  806.         unsigned cl1 = unsigned(abs(msy - msy_prev)) * ay_reset_t / conf.frame;
  807.         unsigned cl2 = unsigned(abs(msy - msy_prev)) * cpu.t / conf.frame;
  808.         coord = unsigned(ay_y0 + int(cl2-cl1)*sign_pm(msy - msy_prev));
  809.     }
  810.     else
  811.     {
  812.         unsigned cl1 = unsigned(abs(msx - msx_prev)) * ay_reset_t / conf.frame;
  813.         unsigned cl2 = unsigned(abs(msx - msx_prev)) * cpu.t / conf.frame;
  814.         coord = unsigned(ay_x0 + int(cl2-cl1)*sign_pm(msx - msx_prev));
  815.     }
  816. /*
  817.    int coord = (ayR14 & 0x40)?
  818.      ay_y0 + 0x100 * (msy - msy_prev) * (int)(cpu.t - ay_reset_t) / (int)conf.frame:
  819.      ay_x0 + 0x100 * (msx - msx_prev) * (int)(cpu.t - ay_reset_t) / (int)conf.frame;
  820. //   if ((coord & 0x0F)!=8 && !(ayR14 & 0x40)) printf("coord: %X, x0=%4d, frame_dx=%6d, dt=%d\n", (coord & 0x0F), ay_x0, msx-msx_prev, cpu.t-ay_reset_t);
  821. */
  822.    return 0xC0 | (coord & 0x0F) | u8(mbuttons << 4);
  823. }
  824. //=============================================================================
  825.  
  826.  
  827.  
  828.  
  829. //
  830. //
  831. //
  832.  
  833.  
  834. //=============================================================================
  835. unsigned char K_INPUT::kempston_mx()
  836. {
  837.     int x = ((int(cpu.t) * msx) + (int(conf.frame - cpu.t) * msx_prev)) / int(conf.frame);
  838.     //printf("x %X\n",x);
  839.     return (unsigned char)x;
  840. }
  841. //=============================================================================
  842. unsigned char K_INPUT::kempston_my()
  843. {
  844.     int y = ((int(cpu.t) * msy) + (int(conf.frame - cpu.t) * msy_prev)) / int(conf.frame);
  845.     //printf("y %X\n",y);
  846.     return (unsigned char)y;
  847. }
  848. //=============================================================================
  849.  
  850.  
  851. //=============================================================================
  852. unsigned char K_INPUT::read(unsigned char scan)
  853. {
  854.     unsigned char res = 0xBF | (tape_bit() & 0x40);
  855.     kbdled &= scan;
  856.  
  857.     //-------------------------------------------------------------------------
  858.     if (conf.atm.xt_kbd)
  859.         return input.atm51.read(scan, res);
  860.     //-------------------------------------------------------------------------
  861.     for (int i = 0; i < 8; i++)
  862.     {
  863.         if (!(scan & (1<<i)))
  864.             res &= kbd[i];
  865.     }
  866.     //-------------------------------------------------------------------------
  867.  
  868. /*
  869.    if(res != 0xFF)
  870.        __debugbreak();
  871. */
  872.  
  873.     return res;
  874. }
  875. //=============================================================================
  876.  
  877.  
  878. //=============================================================================
  879. // read quorum additional keys (port 7E)
  880. u8 K_INPUT::read_quorum(u8 scan)
  881. {
  882.     u8 res = 0xFF;
  883.     kbdled &= scan;
  884.     //-------------------------------------------------------------------------
  885.     for (int i = 0; i < 8; i++)
  886.     {
  887.         if (!(scan & (1<<i)))
  888.             res &= kbd[8+i];
  889.     }
  890.     //-------------------------------------------------------------------------
  891.     return res;
  892. }
  893. //=============================================================================
  894.  
  895.  
  896. //=============================================================================
  897. void K_INPUT::paste()
  898. {
  899.     free(textbuffer); textbuffer = nullptr;
  900.     textsize = textoffset = 0;
  901.     keymode = KM_DEFAULT;
  902.     //-------------------------------------------------------------------------
  903.     if (!OpenClipboard(wnd))
  904.         return;
  905.     //-------------------------------------------------------------------------
  906.     HANDLE hClip = GetClipboardData(CF_TEXT);
  907.     //-------------------------------------------------------------------------
  908.     if (hClip)
  909.     {
  910.         void *ptr = GlobalLock(hClip);
  911.         if (ptr)
  912.         {
  913.             keymode = KM_PASTE_RELEASE; tdelay = 1;
  914.             textsize = unsigned(strlen((char*)ptr) + 1);
  915.             memcpy(textbuffer = (unsigned char*)malloc(textsize), ptr, textsize);
  916.             GlobalUnlock(hClip);
  917.             // р уфх ъръющэшЄ№ free ?
  918.         }
  919.     }
  920.     //-------------------------------------------------------------------------
  921.     CloseClipboard();
  922. }
  923. //=============================================================================
  924.  
  925.  
  926. //=============================================================================
  927. unsigned char ATM_KBD::read(unsigned char scan, unsigned char zxdata)
  928. {
  929.     unsigned char t;
  930.  
  931.     //-------------------------------------------------------------------------
  932.     if (R7)
  933.     {
  934.         //---------------------------------------------------------------------
  935.         if (R7 == 1)
  936.             cmd = scan;
  937.         //---------------------------------------------------------------------
  938.         switch (cmd & 0x3F)
  939.         {
  940.             //-----------------------------------------------------------------
  941.             case 1:
  942.             {
  943.                 static const unsigned char ver[4] = { 6, 0, 1, 0 };
  944.                 R7 = 0;
  945.                 return ver[cmd >> 6];
  946.             }
  947.             //-----------------------------------------------------------------
  948.             case 7:
  949.                 clear();
  950.                 R7 = 0;
  951.                 return 0xFF;    // clear data buffer in mode0
  952.             //-----------------------------------------------------------------
  953.             case 8:
  954.                 //-------------------------------------------------------------
  955.                 if (R7 == 2)
  956.                 {
  957.                     mode = scan;
  958.                     kR2 = 0;
  959.                     R7 = 0;
  960.                     return 0xFF;
  961.                 }
  962.                 //-------------------------------------------------------------
  963.                 R7++;
  964.                 return 8;
  965.             //-----------------------------------------------------------------
  966.             case 9:
  967.                 //-------------------------------------------------------------
  968.                 switch (cmd & 0xC0)
  969.                 {
  970.                     //---------------------------------------------------------
  971.                     case 0x00:
  972.                         t = kR1;        //???? Єръ ш фюыцэю с√Є№??? [NS]
  973.                     //---------------------------------------------------------
  974.                     case 0x40:
  975.                         t = kR2;
  976.                     //---------------------------------------------------------
  977.                     case 0x80:
  978.                         t = kR3;
  979.                     //---------------------------------------------------------
  980.                     case 0xC0:
  981.                         t = kR4;
  982.                     //---------------------------------------------------------
  983.                 }
  984.                 //-------------------------------------------------------------
  985.                 R7 = 0;
  986.                 return t;
  987.             //-----------------------------------------------------------------
  988.             case 10:
  989.                 kR3 |= 0x80;
  990.                 R7 = 0;
  991.                 return 0xFF;
  992.             //-----------------------------------------------------------------
  993.             case 11:
  994.                 kR3 &= 0x7F;
  995.                 R7 = 0;
  996.                 return 0xFF;
  997.             //-----------------------------------------------------------------
  998. //          case 12:            ????? [NS] °ю¤Єр с√ыю?
  999. //              R7 = 0;
  1000. //              return 0xFF; // enter pause mode
  1001.             //-----------------------------------------------------------------
  1002.             case 13:
  1003.                 // reset!
  1004.                 this->reset();
  1005.                 cpu.int_flags = cpu.ir_ = cpu.pc = 0;
  1006.                 cpu.im = 0;
  1007.                 comp.p7FFD = comp.flags = 0;
  1008.                 set_atm_FF77(0,0);
  1009.                 set_banks();
  1010.                 break;
  1011.             //-----------------------------------------------------------------
  1012.             case 16:
  1013.             case 18:
  1014.             {
  1015.                 SYSTEMTIME time;
  1016.                 GetLocalTime(&time);
  1017.                 R7 = 0;
  1018.                 if (cmd == 0x10) return (BYTE)time.wSecond;
  1019.                 if (cmd == 0x40) return (BYTE)time.wMinute;
  1020.                 if (cmd == 0x80) return (BYTE)time.wHour;
  1021.                 if (cmd == 0xC0) return (BYTE)time.wDay;
  1022.                 if (cmd == 0x12) return (BYTE)time.wDay;
  1023.                 if (cmd == 0x42) return (BYTE)time.wMonth;
  1024.                 if (cmd == 0x82) return (BYTE)(time.wYear % 100);
  1025.                 if (cmd == 0xC2) return (BYTE)(time.wYear / 100);
  1026.             }
  1027.             //-----------------------------------------------------------------
  1028.             case 17: // set time
  1029.             case 19: // set date
  1030.                 //-------------------------------------------------------------
  1031.                 if (R7 == 2)
  1032.                 {
  1033.                     R7 = 0;
  1034.                 }
  1035.                 //-------------------------------------------------------------
  1036.                 else
  1037.                 {
  1038.                     R7++;
  1039.                 }
  1040.                 //-------------------------------------------------------------
  1041.                 return 0xFF;
  1042.             //-----------------------------------------------------------------
  1043.         }
  1044.         //---------------------------------------------------------------------
  1045.         R7 = 0;
  1046.         return 0xFF;
  1047.     }
  1048.     //-------------------------------------------------------------------------
  1049.     if (scan == 0x55)
  1050.     {
  1051.         R7++;
  1052.         return 0xAA;
  1053.     }
  1054.     //-------------------------------------------------------------------------
  1055.     switch (mode & 3)
  1056.     {
  1057.         //---------------------------------------------------------------------
  1058.         // 0 - Ёхцшь Spectrum KBD
  1059.         //     ┬ ¤Єюь Ёхцшьх ъюэЄЁюыыхЁ ¤ьєышЁєхЄ яюфъы■ўхэшх ъ яюЁЄє ъыртшрЄєЁ√ юс√ўэющ ьрЄЁшЎ√ 5*8 ъыртш°.
  1060.         //     ╩рцфюх эрцрЄшх ъыртш°ш яЁхюсЁрчєхЄё  т юфэю шыш фтр чрь√ърэш  т єчырї ¤Єющ ьрЄЁшЎ√.
  1061.         //     ╧Ёш ёърэшЁютрэшш яюЁЄр ъыртшрЄєЁ√ эр т√їюф т√фрхЄё  ъюф ёююЄтхЄёЄтє■∙шщ чряЁю°хээющ рфЁхёэющ ышэшш ьрЄЁшЎ√.
  1062.         //     ─юяюыэшЄхы№эю ъ ¤Єюьє ъюфє фюсрты хЄё  ъюф ёўшЄрээ√щ ё "Ёюфэюую" яюЁЄр ъыртшрЄєЁ√,
  1063.         //     ўЄю яючтюы хЄ ёўшЄрЄ№ ышэш■ тїюфр ьруэшЄюЇюээюую шэЄхЁЇхщёр ш ёшуэры√ ё фцющёЄшъют шыш ьхїрэшўхёъющ ъыртшрЄєЁ√.
  1064.         //     ─юсртър шфхЄ ъюьрэфющ OR.
  1065.         case 0:        
  1066.         {
  1067.             unsigned char res = zxdata | 0x1F;
  1068.             //-----------------------------------------------------------------
  1069.             for (unsigned i = 0;    i < 8;    i++)
  1070.                 if (!(scan & (1 << i)))
  1071.                     res &= zxkeys[i];
  1072.             //-----------------------------------------------------------------
  1073.             return res;
  1074.         }
  1075.         //---------------------------------------------------------------------
  1076.         // 1 - RD code KBD
  1077.         //     ┬ ¤Єюь Ёхцшьх, эхчртшёшью юЄ ёюёЄю эш  рфЁхёэющ ышэшш,
  1078.         //     ъюэЄЁюыыхЁ тючтЁр∙рхЄ CP/M ъюф яюёыхфэхщ эрцрЄющ ъыртш°ш.
  1079.         //     ╧Ёш ¤Єюь ЁхушёЄЁ ъюэЄЁюыыхЁр, їЁрэ ∙шщ ¤ЄюЄ ъюф ёсЁрё√трхЄё  т 0.
  1080.         case 1:
  1081.             t = kR2;
  1082.             kR2 = 0;
  1083.             return t;
  1084.         //---------------------------------------------------------------------
  1085.         // 2 - CP/M KBD
  1086.         //     ┬ ¤Єюь Ёхцшьх, т чртшёшьюёЄш юЄ ёюёЄю эш  фтєї ёЄрЁ°шї сшЄют рфЁхёр ёърэшЁютрэш ,
  1087.         //     ъюэЄЁюыыхЁ тючтЁр∙рхЄ:
  1088.         //         A15=0, A14=0 - CP/M ъюф яюёыхфэхщ эрцрЄющ ъыртш°ш.
  1089.         //             ╨хушёЄЁ яюёых ўЄхэш  ёсЁрё√трхЄё .
  1090.         //         A15=0, A14=1 - ёюёЄю эшх ЁхушёЄЁр єяЁрты ■∙шї ъыртш°;
  1091.         //             d0 - Shift (1-эрцрЄр)
  1092.         //             d1 - Ctrl (1-эрцрЄр)
  1093.         //             d2 - ALT (1-эрцрЄр)
  1094.         //             d3 - тёхуфр 0
  1095.         //             d4 - Caps Lock trigger
  1096.         //             d5 - Num Lock trigger
  1097.         //             d6 - Scroll Lock trigger
  1098.         //             d7 - RUS(1)/LAT(0)
  1099.         //         A15=1, A14=0 - ёюёЄю эшх фюяюыэшЄхы№эюую ЁхушёЄЁр
  1100.         //             d0 - Right Shift
  1101.         //             d1..d7 - тёхуфр 0
  1102.         //         A15=1, A14=1 - эх эхёхЄ яюыхчэющ шэЇюЁьрЎшш
  1103.         case 2:
  1104.             switch (scan & 0xC0)
  1105.             {
  1106.                 //-------------------------------------------------------------
  1107.                 case 0x00:
  1108.                 {
  1109.                     t = kR2;
  1110.                     kR2 = 0;
  1111.                     return t;
  1112.                 }
  1113.                 //-------------------------------------------------------------
  1114.                 case 0x40:
  1115.                     return kR3;
  1116.                 //-------------------------------------------------------------
  1117.                 case 0x80:
  1118.                     return kR4;
  1119.                 //-------------------------------------------------------------
  1120.                 case 0xC0:
  1121.                     return kR5;
  1122.                 //-------------------------------------------------------------
  1123.             }
  1124.         //---------------------------------------------------------------------
  1125.         // 3 - Direct RD
  1126.         //     ┬ ¤Єюь Ёхцшьх, эхчртшёшью юЄ ёюёЄю эш  рфЁхёэ√ї ышэшщ,
  1127.         //     ъюэЄЁюыыхЁ тючтЁр∙рхЄ ёърэ-ъюф яюёыхфэхщ эрцрЄющ ъыртш°ш ъыртшрЄєЁ√ IBM,
  1128.         //     яЁшўхь ъюф XT-ъыртшрЄєЁ√.
  1129.         case 3:
  1130.             t = lastscan;
  1131.             lastscan = 0;
  1132.             return t;
  1133.         //---------------------------------------------------------------------
  1134.     }
  1135.     //-------------------------------------------------------------------------
  1136.     __assume(0);
  1137.     return 0xFF;
  1138. }
  1139. //=============================================================================
  1140.  
  1141.  
  1142. //=============================================================================
  1143. void ATM_KBD::processzx(unsigned scancode, unsigned char pressed)
  1144. {
  1145.     static const unsigned char L_4B6[] =
  1146.     {
  1147.         0x39, 0x31, 0x32, 0x33, 0x34, 0x35, 0x45, 0x44,
  1148.         0x43, 0x42, 0x41, 0xE4, 0xE2, 0x49, 0x3B, 0x21,
  1149.         0x22, 0x23, 0x24, 0x25, 0x55, 0x54, 0x53, 0x52,
  1150.         0x51, 0xD5, 0xD4, 0x61, 0x88, 0x11, 0x12, 0x13,
  1151.         0x14, 0x15, 0x65, 0x64, 0x63, 0x62, 0xD2, 0xD1,
  1152.         0x91, 0x08, 0x92, 0x02, 0x03, 0x04, 0x05, 0x75,
  1153.         0x74, 0x73, 0xF4, 0xF3, 0x85, 0x80, 0xF5, 0x3C,
  1154.         0x71, 0x3A, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xC5,
  1155.         0xC4, 0xC3, 0xC2, 0xC1, 0x00, 0x00, 0x3C, 0x4C,
  1156.         0x3D, 0xE4, 0x3D, 0x35, 0x4B, 0xE3, 0x4A, 0x4D,
  1157.         0x4B, 0x84, 0x49, 0x00, 0x00, 0x00, 0xE5, 0x94,
  1158.         0x00, 0x00, 0x00
  1159.     };
  1160.  
  1161.     scancode = (scancode & 0xFF) - 1;
  1162.     //-------------------------------------------------------------------------
  1163.     if (scancode >= sizeof L_4B6)
  1164.         return;
  1165.     //-------------------------------------------------------------------------
  1166.     unsigned char x = L_4B6[scancode];
  1167.     if (x & 0x08)
  1168.     {
  1169.         //---------------------------------------------------------------------
  1170.         if (pressed)
  1171.         {
  1172.             zxkeys[0] &= ~1;
  1173.         }
  1174.         //---------------------------------------------------------------------
  1175.         else
  1176.         {
  1177.             zxkeys[0] |= 1;
  1178.         }
  1179.         //---------------------------------------------------------------------
  1180.     }
  1181.     //-------------------------------------------------------------------------
  1182.     if (x & 0x80)
  1183.     {
  1184.         //---------------------------------------------------------------------
  1185.         if (pressed)
  1186.         {
  1187.             zxkeys[7] &= ~2;
  1188.         }
  1189.         //---------------------------------------------------------------------
  1190.         else
  1191.         {
  1192.             zxkeys[7] |= 2;
  1193.         }
  1194.         //---------------------------------------------------------------------
  1195.     }
  1196.     //-------------------------------------------------------------------------
  1197.     if (!(x & 7))
  1198.         return;
  1199.     //-------------------------------------------------------------------------
  1200.     unsigned char data = u8(1 << ((x & 7) - 1));
  1201.     x = (x >> 4) & 7;
  1202.     //-------------------------------------------------------------------------
  1203.     if (pressed)
  1204.     {
  1205.         zxkeys[x] &= ~data;
  1206.     }
  1207.     //-------------------------------------------------------------------------
  1208.     else
  1209.     {
  1210.         zxkeys[x] |= data;
  1211.     }
  1212.     //-------------------------------------------------------------------------
  1213. }
  1214. //=============================================================================
  1215.  
  1216.  
  1217. //=============================================================================
  1218. void ATM_KBD::setkey(unsigned scancode, unsigned char pressed)
  1219. {
  1220.     //-------------------------------------------------------------------------
  1221.     if (!(mode & 3))
  1222.         processzx( scancode, pressed);
  1223.     //-------------------------------------------------------------------------
  1224.     lastscan = (unsigned char) scancode;
  1225.     //-------------------------------------------------------------------------
  1226.     if (!pressed)
  1227.     {
  1228.         lastscan |= 0x80;
  1229.         return;
  1230.     }
  1231.     //-------------------------------------------------------------------------
  1232.     kR3 &= 0x80; // keep rus/lat, clear alt,ctrl,shift, num/scroll/caps lock
  1233.     //-------------------------------------------------------------------------
  1234.     if ((kbdpc[ DIK_LSHIFT]     | kbdpc[ DIK_RSHIFT])   & 0x80) kR3 |= 1;
  1235.     if ((kbdpc[ DIK_LCONTROL]   | kbdpc[ DIK_RCONTROL]) & 0x80) kR3 |= 2;
  1236.     if ((kbdpc[ DIK_LMENU]      | kbdpc[ DIK_RMENU])    & 0x80) kR3 |= 4;
  1237.     if (kbdpc[ DIK_CAPITAL] & 1)                                        kR3 |= 0x10;
  1238.     if (kbdpc[ DIK_NUMLOCK] & 1)                                        kR3 |= 0x20;
  1239.     if (kbdpc[ DIK_SCROLL] & 1)                                 kR3 |= 0x40;
  1240.     //-------------------------------------------------------------------------
  1241.     kR4 = 0;
  1242.     if (kbdpc[ DIK_RSHIFT] & 0x80)      kR4++;
  1243.     //-------------------------------------------------------------------------
  1244.     static const unsigned char L_400[] =
  1245.     {
  1246.         0x1B, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00,
  1247.         0x38, 0x00, 0x39, 0x00, 0x30, 0x00, 0x2D, 0x00, 0x3D, 0x00, 0x08, 0x00, 0x09, 0x00, 0x51, 0x00,
  1248.         0x57, 0x00, 0x45, 0x00, 0x52, 0x00, 0x54, 0x00, 0x59, 0x00, 0x55, 0x00, 0x49, 0x00, 0x4F, 0x00,
  1249.         0x50, 0x00, 0x5B, 0x00, 0x5D, 0x00, 0x0D, 0xC0, 0x00, 0x02, 0x41, 0x00, 0x53, 0x00, 0x44, 0x00,
  1250.         0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x4A, 0x00, 0x4B, 0x00, 0x4C, 0x00, 0x3B, 0x00, 0x27, 0x00,
  1251.         0x60, 0x00, 0x00, 0x03, 0x5C, 0x00, 0x5A, 0x00, 0x58, 0x00, 0x43, 0x00, 0x56, 0x00, 0x42, 0x00,
  1252.         0x4E, 0x00, 0x4D, 0x00, 0x2C, 0x00, 0x2E, 0x00, 0x2F, 0x40, 0x00, 0x03, 0xAA, 0x00, 0x00, 0x01,
  1253.         0x20, 0x00, 0x00, 0x04, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00,
  1254.         0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x00, 0x08, 0x00, 0x0C, 0x37, 0x80, 0x38, 0x80,
  1255.         0x39, 0x80, 0x2D, 0x80, 0x34, 0x80, 0x35, 0x80, 0x36, 0x80, 0x2B, 0x80, 0x31, 0x80, 0x32, 0x80,
  1256.         0x33, 0x80, 0x30, 0x80, 0x2E, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x6B, 0x00, 0x6C, 0x00
  1257.     };
  1258.     //-------------------------------------------------------------------------
  1259.     unsigned index = ((scancode & 0xFF) - 1) * 2;
  1260.     //-------------------------------------------------------------------------
  1261.     if (index >= sizeof(L_400))
  1262.         return;
  1263.     //-------------------------------------------------------------------------
  1264.     kR1 = kR2;
  1265.     kR2 = L_400[index];
  1266.     kR5 = L_400[index+1];
  1267.     //-------------------------------------------------------------------------
  1268.     if ((kR5 & 0x30) == 0x30)
  1269.         zxdata[0] = zxdata[1] = 0xFFFFFFFF;
  1270.     //-------------------------------------------------------------------------
  1271.     static const unsigned char L_511[] =
  1272.     {
  1273.         0x76, 0x70, 0x74, 0xAD, 0x72, 0xB5, 0x73, 0xAB, 0x77, 0x71, 0x75, 0x78, 0x79
  1274.     };
  1275.     //-------------------------------------------------------------------------
  1276.     if ((scancode & 0x100) && (kR5 & 0x40))
  1277.         kR2 |= 0x80;
  1278.     //-------------------------------------------------------------------------
  1279.     if (kR5 & 0x80)
  1280.     {
  1281.         //---------------------------------------------------------------------
  1282.         if (scancode & 0x100)
  1283.         {
  1284.             kR2 = L_511[(scancode & 0xFF) - 0x47];
  1285.         }
  1286.         //---------------------------------------------------------------------
  1287.         else
  1288.         {
  1289.             kR2 |= 0x80;
  1290.         }
  1291.         //---------------------------------------------------------------------
  1292.     }
  1293.     //-------------------------------------------------------------------------
  1294.     if (kR5 & 0x0C)
  1295.         kR5 = 0;
  1296.     //-------------------------------------------------------------------------
  1297. }
  1298. //=============================================================================
  1299.  
  1300.  
  1301. //=============================================================================
  1302. void ATM_KBD::clear()
  1303. {
  1304.     zxdata[0] = zxdata[1] = 0xFFFFFFFF;
  1305. }
  1306. //=============================================================================
  1307.  
  1308.  
  1309. //=============================================================================
  1310. void ATM_KBD::reset()
  1311. {
  1312.     kR1 = kR2 = mode = lastscan = R7 = 0;
  1313.     clear();
  1314. }
  1315. //=============================================================================
  1316.  
  1317.