Subversion Repositories pentevo

Rev

Rev 796 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. #include "std.h"
  2.  
  3. #include "emul.h"
  4. #include "vars.h"
  5. #include "font.h"
  6. #include "font16.h"
  7. #include "gs.h"
  8. #include "tape.h"
  9. #include "draw.h"
  10. #include "debug.h"
  11. #include "dbgbpx.h"
  12. #include "memory.h"
  13. #include "leds.h"
  14.  
  15. #include "util.h"
  16.  
  17. static unsigned pitch;
  18.  
  19. void text_i(unsigned char *dst, const char *text, unsigned char ink, unsigned off)
  20. {
  21.    ink &= 0x0F;
  22.    for (const u8 *x = (const u8*)text; *x; x++) {
  23.       unsigned char *d0 = dst;
  24.       for (unsigned y = 0; y < 8; y++) {
  25.          unsigned char byte = font[(*x)*8+y];
  26.          d0[0] = (byte >> off) + (d0[0] & ~(0xFC >> off));
  27.          d0[1] = (d0[1] & 0xF0) + ink;
  28.          if (off > 2) {
  29.             d0[2] = u8((byte << (8-off)) + (d0[2] & ~(0xFC << (8-off))));
  30.             d0[3] = (d0[3] & 0xF0) + ink;
  31.          }
  32.          d0 += pitch;
  33.       }
  34.       off += 6;
  35.       if(off & 8)
  36.       {
  37.           off -= 8;
  38.           dst += 2;
  39.       }
  40.    }
  41. }
  42.  
  43. static void text_16(unsigned char *dst, const char *text, unsigned char attr)
  44. {
  45.     for(; *text; text++, dst += 2)
  46.     {
  47.         for(unsigned y = 0; y < 16; y++)
  48.         {
  49.             dst[y*pitch] = font16[16 * *(const u8*)text + y];
  50.             dst[y*pitch + 1] = attr;
  51.         }
  52.     }
  53. }
  54.  
  55. static unsigned char *aypos;
  56. static void paint_led(unsigned level, unsigned char at)
  57. {
  58.    if (level) {
  59.        if(level > 15)
  60.        {
  61.            level = 15; at = 0x0E;
  62.        }
  63.       unsigned mask = (0xFFFF0000 >> level) & 0xFFFF;
  64.       aypos[0] = u8(mask >> 8);
  65.       aypos[2] = (unsigned char)mask;
  66.       aypos[1] = (aypos[1] & 0xF0) + at;
  67.       aypos[3] = (aypos[3] & 0xF0) + at;
  68.    }
  69.    aypos += pitch;
  70. }
  71.  
  72. static void ay_led()
  73. {
  74.    aypos = temp.led.ay;
  75.    unsigned char sum=0;
  76.  
  77.    int max_ay = (conf.sound.ay_scheme > AY_SCHEME_PSEUDO)? 2 : 1;
  78.    for (int n_ay = 0; n_ay < max_ay; n_ay++) {
  79.       for (unsigned i = 0; i < 3; i++) {
  80.          unsigned char r_mix = ay[n_ay].get_reg(7);
  81.          unsigned char tone = (r_mix >> i) & 1,
  82.                        noise = (r_mix >> (i+3)) & 1;
  83.          unsigned char c1 = 0, c2 = 0;
  84.          unsigned char v = ay[n_ay].get_reg(i+8);
  85.          if (!tone) c1 = c2 = 0x0F;
  86.          if (!noise) c2 = 0x0E;
  87.          if (v & 0x10) {
  88.             unsigned r_envT = ay[n_ay].get_reg(11) + 0x100*ay[n_ay].get_reg(12);
  89.             if (r_envT < 0x400) {
  90.                v = (3-(r_envT>>3)) & 0x0F;
  91.                if (!v) v = 6;
  92.             } else v = u8(ay[n_ay].get_env()/2);
  93.             c1 = 0x0C;
  94.          } else v &= 0x0F;
  95.          if (!c1) c1 = c2;
  96.          if (!c2) c2 = c1;
  97.          if (!c1) v = 0;
  98.          sum |= v;
  99.          paint_led(v, c1);
  100.          paint_led(v, c2);
  101.          paint_led(0, 0);
  102.       }
  103.    }
  104.  
  105.    const unsigned FMvols[]={4,9,15,23,35,48,70,105,140,195,243,335,452,608,761,1023};
  106.    #define _cBlue 0x09
  107.    #define _cRed 0x0a
  108.    #define _cPurp 0x0b
  109.    #define _cGreen 0x0c
  110.    #define _cCyan 0x0d
  111.    #define _cYell 0x0e
  112.    #define _cWhite 0x0f
  113.  
  114.    const u8 FMalg1[]={
  115.    _cBlue , _cPurp , _cGreen, _cWhite,
  116.    _cPurp , _cPurp , _cGreen, _cWhite,
  117.    _cGreen, _cPurp , _cGreen, _cWhite,
  118.    _cPurp , _cGreen, _cGreen, _cWhite,
  119.  
  120.    _cGreen, _cWhite, _cGreen, _cWhite,
  121.    _cPurp , _cWhite, _cWhite, _cWhite,
  122.    _cGreen, _cWhite, _cWhite, _cWhite,
  123.    _cWhite, _cWhite, _cWhite, _cWhite
  124.    };
  125.  
  126.    const u8 FMalg2[]={
  127.    _cBlue , _cPurp , _cGreen, _cYell ,
  128.    _cPurp , _cPurp , _cGreen, _cYell ,
  129.    _cGreen, _cPurp , _cGreen, _cYell ,
  130.    _cPurp , _cGreen, _cGreen, _cYell ,
  131.  
  132.    _cGreen, _cYell , _cGreen, _cYell ,
  133.    _cPurp , _cYell , _cYell , _cYell ,
  134.    _cGreen, _cYell , _cYell , _cYell ,
  135.    _cYell , _cYell , _cYell , _cYell
  136.    };
  137.  
  138.    const int FMslots[]={0,2,1,3};
  139. /*
  140.    const int FMalg1[]={
  141.    _cPurp , _cGreen, _cCyan , _cWhite,
  142.    _cPurp , _cPurp , _cGreen, _cWhite,
  143.    _cGreen, _cPurp , _cCyan , _cWhite,
  144.    _cPurp , _cCyan , _cGreen, _cWhite,
  145.  
  146.    _cPurp , _cWhite, _cGreen, _cWhite,
  147.    _cPurp , _cWhite, _cWhite, _cWhite,
  148.    _cGreen, _cWhite, _cWhite, _cWhite,
  149.    _cWhite, _cWhite, _cWhite, _cWhite
  150.    };
  151.  
  152.    const int FMalg2[]={
  153.    _cPurp , _cGreen, _cCyan , _cYell ,
  154.    _cPurp , _cPurp , _cGreen, _cYell ,
  155.    _cGreen, _cPurp , _cCyan , _cYell ,
  156.    _cPurp , _cCyan , _cGreen, _cYell ,
  157.  
  158.    _cPurp , _cYell , _cGreen, _cYell ,
  159.    _cPurp , _cYell , _cYell , _cYell ,
  160.    _cGreen, _cYell , _cYell , _cYell ,
  161.    _cYell , _cYell , _cYell , _cYell
  162.    };
  163. */
  164.    if ( conf.sound.ay_chip == SNDCHIP::CHIP_YM2203 ) {
  165.       for (int ayN = 0; ayN < max_ay; ayN++) {
  166.          for (int i = 0; i < 3; i++) {
  167.             for (int j = 0; j < 4; j++) {
  168.                unsigned v=ay[ayN].Chip2203->CH[i].SLOT[j].vol_out;
  169.                if (v>1023) v=1023;
  170.                unsigned c; //Alone Coder 0.36.7
  171.                for (/*int*/ c=0;c<16;c++)
  172.                   if (FMvols[c]>=v) break;
  173.                if ( (i == 2) && (((ay[ayN].Chip2203->OPN.ST.mode) & 0xc0) == 0x40) )
  174.                   paint_led(15-c, FMalg2[ay[ayN].Chip2203->CH[i].ALGO * 4 + FMslots[j]]);
  175.                else
  176.                   paint_led(15-c, FMalg1[ay[ayN].Chip2203->CH[i].ALGO * 4 + FMslots[j]]);
  177.             }
  178.          paint_led(0, 0);
  179.          }
  180.       }
  181.    } //Dexus
  182.  
  183.    #ifdef MOD_GS
  184.    if (sum || !conf.gs_type) return; // else show GS indicators
  185.    aypos = temp.led.ay; // reset y-pos, if nothing above
  186.    for (unsigned ch = 0; ch < 8; ch++) {
  187.       unsigned v = gsleds[ch].level, a = gsleds[ch].attrib;
  188.       paint_led(v, u8(a));
  189.       paint_led(v, u8(a));
  190.       paint_led(0, 0);
  191.    }
  192.  
  193.    #endif
  194. }
  195.  
  196. static void load_led()
  197. {
  198.     char ln[20]; unsigned char diskcolor = 0;
  199.  
  200. #ifdef GS_BASS
  201.     if(gs.loadmod)
  202.     {
  203.         text_i(temp.led.load, "", 0x0D);
  204.         gs.loadmod = 0;
  205.     }
  206.     else if(gs.loadfx)
  207.     {
  208.         sprintf(ln, "\x0D%d", gs.loadfx);
  209.         text_i(temp.led.load, ln, 0x0D);
  210.         gs.loadfx = 0;
  211.     }
  212.     else
  213. #endif
  214.         if(trdos_format)
  215.         {
  216.             diskcolor = (trdos_format < ROMLED_TIME * 3 / 4) ? 0x06 : 0x0E;
  217.             trdos_format--;
  218.         }
  219.         else if(trdos_save)
  220.         {
  221.             diskcolor = (trdos_save < ROMLED_TIME * 3 / 4) ? 0x02 : 0x0A;
  222.             trdos_save--;
  223.         }
  224.         else if(trdos_load)
  225.         {
  226.             diskcolor = (trdos_load < ROMLED_TIME * 3 / 4) ? 0x01 : 0x09;
  227.             trdos_load--;
  228.         }
  229.         else if(trdos_seek)
  230.         {
  231.             trdos_seek--;
  232.         }
  233.         else if(!comp.tape.stopped)
  234.         {
  235.             static unsigned char tapeled[11 * 2] =
  236.             {
  237.                 0x7F, 0xFE, 0x80, 0x01, 0x80, 0x01, 0x93, 0xC9, 0xAA, 0x55, 0x93, 0xC9,
  238.                 0x80, 0x01, 0x8F, 0xF1, 0x80, 0x01, 0xB5, 0xA9, 0xFF, 0xFF
  239.             };
  240.             const int tapecolor = 0x51;
  241.             for(unsigned i = 0; i < 11; i++)
  242.             {
  243.                 temp.led.load[pitch*i + 0] = tapeled[2 * i];
  244.                 temp.led.load[pitch*i + 1] = tapecolor;
  245.                 temp.led.load[pitch*i + 2] = tapeled[2 * i + 1];
  246.                 temp.led.load[pitch*i + 3] = tapecolor;
  247.             }
  248.             int time = (int)(temp.led.tape_started + tapeinfo[comp.tape.index].t_size - comp.t_states);
  249.             if(time < 0)
  250.             {
  251.                 find_tape_index(); time = 0;
  252.                 temp.led.tape_started = comp.t_states;
  253.                 unsigned char *ptr = tape_image + tapeinfo[comp.tape.index].pos;
  254.                 if(ptr == comp.tape.play_pointer && comp.tape.index)
  255.                 {
  256.                     comp.tape.index--;
  257.                     ptr = tape_image + tapeinfo[comp.tape.index].pos;
  258.                 }
  259.                 for(; ptr < comp.tape.play_pointer; ptr++)
  260.                 {
  261.                     temp.led.tape_started -= tape_pulse[*ptr];
  262.                 }
  263.             }
  264.             time /= (conf.frame * conf.intfq);
  265.             sprintf(ln, "%X:%02d", time / 60, time % 60);
  266.             text_i(temp.led.load + pitch * 12 - 2, ln, 0x0D);
  267.         }
  268.     if(diskcolor | trdos_seek)
  269.     {
  270.         if(diskcolor)
  271.         {
  272.             unsigned *ptr = (unsigned*)temp.led.load;
  273.             int i; //Alone Coder 0.36.7
  274.             for(/*int*/ i = 0; i < 7; i++, ptr = (unsigned*)((char*)ptr + pitch))
  275.             {
  276.                 *ptr = (*ptr & WORD4(0, 0xF0, 0, 0xF0)) | WORD4(0x3F, diskcolor, 0xFC, diskcolor);
  277.             }
  278.  
  279.             static unsigned char disk[] = { 0x38, 0x1C, 0x3B, 0x9C, 0x3B, 0x9C, 0x3B, 0x9C, 0x38, 0x1C };
  280.             for(i = 0; i < 5; i++, ptr = (unsigned*)((char*)ptr + pitch))
  281.             {
  282.                 *ptr = (*ptr & WORD4(0, 0xF0, 0, 0xF0)) | WORD4(disk[2 * i], diskcolor, disk[2 * i + 1], diskcolor);
  283.             }
  284.         }
  285.         if(comp.wd.seldrive->track != 0xFF)
  286.         {
  287.             sprintf(ln, "%02X", comp.wd.seldrive->track * 2 + comp.wd.side);
  288.             text_i(temp.led.load + pitch - 4, ln, 0x05 + (diskcolor & 8));
  289.         }
  290.     }
  291. }
  292.  
  293. static unsigned p_frames = 1;
  294. static u64 led_updtime, p_time;
  295. static double p_fps;
  296. __inline void update_perf_led()
  297. {
  298.    u64 now = led_updtime - p_time;
  299.    if (now >= temp.cpufq) // єёЁхфэхэшх чр ёхъєэфє
  300.    {
  301.       p_fps = (p_frames * temp.cpufq) / double(now) + 0.005;
  302.       p_frames = 0;
  303.       p_time = led_updtime;
  304.    }
  305.    p_frames++;
  306. }
  307.  
  308. static void perf_led()
  309. {
  310.    char bf[0x20]; unsigned PSZ;
  311.    if(conf.led.perf_t)
  312.    {
  313.        sprintf(bf, "%6u*%2.2f", cpu.haltpos ? cpu.haltpos : cpu.t, p_fps);
  314.        PSZ = 7;
  315.    }
  316.    else
  317.    {
  318.        sprintf(bf, "%2.2f fps", p_fps);
  319.        PSZ = 5;
  320.    }
  321.    text_i(temp.led.perf, bf, 0x0E);
  322.    if (cpu.haltpos) {
  323.       unsigned char *ptr = temp.led.perf + pitch*8;
  324.       unsigned xx; //Alone Coder 0.36.7
  325.       for (/*unsigned*/ xx = 0; xx < PSZ; xx++) *(unsigned short*)(ptr+xx*2) = 0x9A00;
  326.       unsigned mx = cpu.haltpos*PSZ*8/conf.frame;
  327.       for (xx = 1; xx < mx; xx++) ptr[(xx>>2)&0xFE] |= (0x80 >> (xx & 7));
  328.    }
  329. }
  330.  
  331. static void input_led()
  332. {
  333.    if (input.kbdled != 0xFF) {
  334.       unsigned char k0 = 0x99, k1 = 0x9F, k2 = 0x90;
  335.       if(input.keymode == K_INPUT::KM_PASTE_HOLD)
  336.       {
  337.           k0 = 0xAA; k1 = 0xAF; k2 = 0xA0;
  338.       }
  339.       if(input.keymode == K_INPUT::KM_PASTE_RELEASE)
  340.       {
  341.           k0 = 0x22; k1 = 0x2F; k2 = 0x20;
  342.       }
  343.  
  344.       unsigned i; //Alone Coder 0.36.7
  345.       for (/*int*/ i = 0; i < 5; i++)
  346.          temp.led.input[1+i*2*pitch] = temp.led.input[3+i*2*pitch] = k0;
  347.       for(i = 0; i < 4; i++)
  348.       {
  349.           temp.led.input[pitch*(2 * i + 1)] = 0x7F;
  350.           temp.led.input[pitch*(2 * i + 1) + 2] = 0xFE;
  351.       }
  352.       temp.led.input[pitch*1+1] = (input.kbdled & 0x08)? k2 : k1;
  353.       temp.led.input[pitch*3+1] = (input.kbdled & 0x04)? k2 : k1;
  354.       temp.led.input[pitch*5+1] = (input.kbdled & 0x02)? k2 : k1;
  355.       temp.led.input[pitch*7+1] = (input.kbdled & 0x01)? k2 : k1;
  356.       temp.led.input[pitch*1+3] = (input.kbdled & 0x10)? k2 : k1;
  357.       temp.led.input[pitch*3+3] = (input.kbdled & 0x20)? k2 : k1;
  358.       temp.led.input[pitch*5+3] = (input.kbdled & 0x40)? k2 : k1;
  359.       temp.led.input[pitch*7+3] = (input.kbdled & 0x80)? k2 : k1;
  360.    }
  361.    static unsigned char joy[] =   { 0x10, 0x38, 0x1C, 0x1C, 0x1C, 0x1C, 0x08, 0x00, 0x7E, 0xFF, 0x00, 0xE7 };
  362.    static unsigned char mouse[] = { 0x0C, 0x12, 0x01, 0x79, 0xB5, 0xB5, 0xB5, 0xFC, 0xFC, 0xFC, 0xFC, 0x78 };
  363.    if(input.mouse_joy_led & 2)
  364.    {
  365.        for(size_t i = 0; i < sizeof joy; i++)
  366.        {
  367.            temp.led.input[4 + pitch * i] = joy[i];
  368.            temp.led.input[4 + pitch * i + 1] = (temp.led.input[4 + pitch * i + 1] & 0xF0) + 0x0F;
  369.        }
  370.    }
  371.    if(input.mouse_joy_led & 1)
  372.    {
  373.        for(size_t i = 0; i < sizeof mouse; i++)
  374.        {
  375.            temp.led.input[6 + pitch * i] = mouse[i];
  376.            temp.led.input[6 + pitch * i + 1] = (temp.led.input[6 + pitch * i + 1] & 0xF0) + 0x0F;
  377.        }
  378.    }
  379.    input.mouse_joy_led = 0; input.kbdled = 0xFF;
  380. }
  381.  
  382. #ifdef MOD_MONITOR
  383. static void debug_led()
  384. {
  385.    unsigned char *ptr = temp.led.osw;
  386.    if (trace_rom | trace_ram) {
  387.       set_banks();
  388.       if (trace_rom) {
  389.          const unsigned char off = 0x01, on = 0x0C;
  390.          text_i(ptr + 2,           "B48", used_banks[(base_sos_rom - memory) / PAGE] ? on : off);
  391.          text_i(ptr + 8,           "DOS", used_banks[(base_dos_rom - memory) / PAGE] ? on : off);
  392.          text_i(ptr + pitch*8 + 2, "128", used_banks[(base_128_rom - memory) / PAGE] ? on : off);
  393.          text_i(ptr + pitch*8 + 8, "SYS", used_banks[(base_sys_rom - memory) / PAGE] ? on : off);
  394.          ptr += pitch*16;
  395.       }
  396.       if (trace_ram) {
  397.          unsigned num_rows = conf.ramsize/128;
  398.          unsigned j; //Alone Coder 0.36.7
  399.          for (unsigned  i = 0; i < num_rows; i++) {
  400.             char ln[9];
  401.             for (/*unsigned*/ j = 0; j < 8; j++)
  402.                ln[j] = used_banks[i*8+j]? '*' : '-';
  403.             ln[j] = 0;
  404.             text_i(ptr, ln, 0x0D);
  405.             ptr += pitch*8;
  406.          }
  407.       }
  408.       for (unsigned j = 0; j < MAX_PAGES; j++) used_banks[j] = 0;
  409.    }
  410.    for (unsigned w = 0; w < 4; w++) if (watch_enabled[w])
  411.    {
  412.       char bf[12]; sprintf(bf, "%8X", calc(&cpu, watch_script[w]));
  413.       text_i(ptr,bf,0x0F); ptr += pitch*8;
  414.    }
  415. }
  416. #endif
  417.  
  418. #ifdef MOD_MEMBAND_LED
  419. static void show_mband(unsigned char *dst, unsigned start)
  420. {
  421.    char xx[8]; sprintf(xx, "%02X", start >> 8);
  422.    text_i(dst, xx, 0x0B); dst += 4;
  423.  
  424.    Z80 &cpu = CpuMgr.Cpu();
  425.    unsigned char band[128];
  426.    unsigned i; //Alone Coder 0.36.7
  427.    for (/*unsigned*/ i = 0; i < 128; i++) {
  428.       unsigned char res = 0;
  429.       for (unsigned q = 0; q < conf.led.bandBpp; q++)
  430.          res |= cpu.membits[start++];
  431.       band[i] = res;
  432.    }
  433.  
  434.    for (unsigned p = 0; p < 16; p++, dst+=2) {
  435.       unsigned char r=0, w=0, x=0;
  436.       for (unsigned b = 0; b < 8; b++) {
  437.           r *= 2; w *= 2; x *= 2;
  438.          if (band[p*8+b] & MEMBITS_R) r |= 1;
  439.          if (band[p*8+b] & MEMBITS_W) w |= 1;
  440.          if (band[p*8+b] & MEMBITS_X) x |= 1;
  441.       }
  442.  
  443.       unsigned char t = (p && !(p & 3))? 0x7F : 0xFF;
  444.  
  445.       dst[0*pitch] = t; dst[0*pitch+1] = 0x9B;
  446.  
  447.       dst[1*pitch] = r; dst[1*pitch+1] = 0x1C;
  448.       dst[2*pitch] = r; dst[2*pitch+1] = 0x1C;
  449.       dst[3*pitch] = w; dst[3*pitch+1] = 0x1A;
  450.       dst[4*pitch] = w; dst[4*pitch+1] = 0x1A;
  451.       dst[5*pitch] = x; dst[5*pitch+1] = 0x1F;
  452.       dst[6*pitch] = x; dst[6*pitch+1] = 0x1F;
  453.  
  454.       dst[7*pitch] = t; dst[7*pitch+1] = 0x9B;
  455.    }
  456.  
  457.    sprintf(xx, "%02X", (start-1) >> 8);
  458.    text_i(dst, xx, 0x0B, 2);
  459.  
  460.    for(i = 0; i < 8; i++)
  461.    {
  462.        dst[i*pitch] |= 0x80;
  463.        dst[i*pitch - 17 * 2] |= 0x01;
  464.    }
  465. }
  466.  
  467. static void memband_led()
  468. {
  469.    unsigned char *dst = temp.led.memband;
  470.    for (unsigned start = 0x0000; start < 0x10000;) {
  471.       show_mband(dst, start);
  472.       start += conf.led.bandBpp * 128;
  473.       dst += 10*pitch;
  474.    }
  475.  
  476.    Z80 &cpu = CpuMgr.Cpu();
  477.    for (unsigned i = 0; i < 0x10000; i++)
  478.       cpu.membits[i] &= ripper | unsigned(~(MEMBITS_R | MEMBITS_W | MEMBITS_X));
  479. }
  480. #endif
  481.  
  482.  
  483. HANDLE hndKbdDev;
  484.  
  485. void init_leds()
  486. {
  487.    DefineDosDevice(DDD_RAW_TARGET_PATH, "Kbd_unreal_spec", "\\Device\\KeyboardClass0");
  488.    hndKbdDev = CreateFile("\\\\.\\Kbd_unreal_spec", GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
  489.    if(hndKbdDev == INVALID_HANDLE_VALUE)
  490.    {
  491.        hndKbdDev = nullptr;
  492.        conf.led.flash_ay_kbd = 0;
  493.    }
  494. }
  495.  
  496. void done_leds()
  497. {
  498.    if (hndKbdDev) {
  499.       DefineDosDevice(DDD_REMOVE_DEFINITION, "Kbd_unreal_spec", nullptr);
  500.       CloseHandle(hndKbdDev); hndKbdDev = nullptr;
  501.    }
  502. }
  503.  
  504. static void ay_kbd()
  505. {
  506.    static unsigned char pA, pB, pC;
  507.    static unsigned prev_keyled = -1U;
  508.  
  509.    KEYBOARD_INDICATOR_PARAMETERS InputBuffer;
  510.    InputBuffer.LedFlags = InputBuffer.UnitId = 0;
  511.  
  512.    if (ay[0].get_reg( 8) > pA) InputBuffer.LedFlags |= KEYBOARD_NUM_LOCK_ON;
  513.    if (ay[0].get_reg( 9) > pB) InputBuffer.LedFlags |= KEYBOARD_CAPS_LOCK_ON;
  514.    if (ay[0].get_reg(10) > pC) InputBuffer.LedFlags |= KEYBOARD_SCROLL_LOCK_ON;
  515.  
  516.    pA = ay[0].get_reg(8); pB = ay[0].get_reg(9); pC = ay[0].get_reg(10);
  517.  
  518.    DWORD xx;
  519.    if(prev_keyled != InputBuffer.LedFlags)
  520.    {
  521.        prev_keyled = InputBuffer.LedFlags;
  522.        DeviceIoControl(hndKbdDev, IOCTL_KEYBOARD_SET_INDICATORS, &InputBuffer, sizeof(KEYBOARD_INDICATOR_PARAMETERS),
  523.            nullptr, 0, &xx, nullptr);
  524.    }
  525. }
  526.  
  527. static void key_led()
  528. {
  529.    #define key_x 1U
  530.    #define key_y 1U
  531.    unsigned i; //Alone Coder 0.36.7
  532.    for (/*int*/ i = 0; i < 9; i++) text_16(rbuf+(key_y+i)*pitch*16+key_x*2, "                                 ", 0x40);
  533.    static char ks[] = "cZXCVASDFGQWERT1234509876POIUYeLKJHssMNB";
  534.    for (i = 0; i < 8; i++) {
  535.       for (unsigned j = 0; j < 5; j++) {
  536.          unsigned x, y, at;
  537.          if(i < 4)
  538.          {
  539.              y = 7 - 2 * i + key_y;
  540.              x = 3 * j + 2 + key_x;
  541.          }
  542.          else
  543.          {
  544.              y = 2 * (i - 4) + 1 + key_y;
  545.              x = 29 - 3 * j + key_x;
  546.          }
  547.          unsigned a = u8(ks[i*5+j])*0x100U+u8(' ');
  548.          at = (input.kbd[i] & (1<<j))? 0x07 : ((input.rkbd[i] & (1<<j)) ? 0xA0:0xD0);
  549.          text_16(rbuf + 2 * x + y * pitch * 16, (char*)&a, u8(at));
  550.       }
  551.    }
  552. }
  553.  
  554. static void time_led()
  555. {
  556.    static u64 prev_time;
  557.    static char bf[8];
  558.    if (led_updtime - prev_time > 5000) {
  559.       prev_time = led_updtime;
  560.       SYSTEMTIME st; GetLocalTime(&st);
  561.       sprintf(bf, "%2d:%02d", st.wHour, st.wMinute);
  562.    }
  563.    text_i(temp.led.time, bf, 0x0D);
  564. }
  565.  
  566. // ┬√ч√трхЄё  Ёрч т ърфЁ
  567. void showleds()
  568. {
  569.    led_updtime = rdtsc();
  570.    update_perf_led();
  571.  
  572.    if (temp.vidblock) return;
  573.  
  574.    pitch = temp.scx/4;
  575.  
  576.    if (statcnt) { statcnt--; text_i(rbuf + ((pitch/2-strlen(statusline)*6/8) & 0xFE) + (temp.scy-10)*pitch, statusline, 0x09); }
  577.  
  578.    if (!conf.led.enabled) return;
  579.  
  580.    if (temp.led.ay) ay_led();
  581.    if (temp.led.perf) perf_led();
  582.    if (temp.led.load) load_led();
  583.    if (temp.led.input) input_led();
  584.    if (temp.led.time) time_led();
  585. #ifdef MOD_MONITOR
  586.    if (temp.led.osw) debug_led();
  587. #endif
  588. #ifdef MOD_MEMBAND_LED
  589.    if (temp.led.memband) memband_led();
  590. #endif
  591.    if (conf.led.flash_ay_kbd && hndKbdDev) ay_kbd();
  592.    if (input.keymode == K_INPUT::KM_KEYSTICK) key_led();
  593. }
  594.