Subversion Repositories pentevo

Rev

Rev 796 | 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 "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. unsigned char txtscr[80*30*2];
  14.  
  15. static struct
  16. {
  17.    unsigned char x,y,dx,dy,c;
  18. } frames[20];
  19.  
  20. unsigned nfr;
  21.  
  22. void debugflip()
  23. {
  24.    if(!active)
  25.        return;
  26.    setpal(0);
  27.  
  28.    unsigned char * const bptr = gdibuf;
  29.  
  30.    if (show_scrshot) {
  31.       memcpy(save_buf, rbuf, rb2_offs);
  32.       paint_scr((show_scrshot == 1)? 0 : 2);
  33.       unsigned char *dst = bptr + wat_y*16*640+wat_x*8;
  34.       unsigned char *src = rbuf+temp.scx/4*(temp.b_top+192/2-wat_sz*16/2);
  35.       src += temp.scx/8-37/2*2;
  36.       for (unsigned y = 0; y < wat_sz*16; y++) {
  37.          for (unsigned x = 0; x < 37; x++) {
  38.             *(unsigned*)(dst+x*8+0) = t.sctab8[0][(src[x*2] >>  4) + src[2*x+1]*16];
  39.             *(unsigned*)(dst+x*8+4) = t.sctab8[0][(src[x*2] & 0xF) + src[2*x+1]*16];
  40.          }
  41.          src += temp.scx / 4;
  42.          dst += 640;
  43.       }
  44.       memcpy(rbuf, save_buf, rb2_offs);
  45.    }
  46.  
  47.    // print text
  48.    int x,y;
  49.    unsigned char *tptr = txtscr;
  50.    for (y = 0; y < 16*30*640; y+=16*640)
  51.    {
  52.       for (x = 0; x < 80; x++, tptr++)
  53.       {
  54.          unsigned ch = *tptr, at = tptr[80*30];
  55.          if (at == 0xFF) continue; // transparent color
  56.          const unsigned char *fnt = &font16[ch*16];
  57.          at <<= 4;
  58.          for (int yy = 0; yy < 16; yy++, fnt++)
  59.          {
  60.             *(unsigned*)(bptr+y+640*yy+x*8+0) = t.sctab8[0][(*fnt >>  4) + at];
  61.             *(unsigned*)(bptr+y+640*yy+x*8+4) = t.sctab8[0][(*fnt & 0xF) + at];
  62.          }
  63.       }
  64.    }
  65.  
  66.    // show frames
  67.    for (unsigned i = 0; i < nfr; i++)
  68.    {
  69.       unsigned char a1 = (frames[i].c | 0x08) * 0x11;
  70.       y = frames[i].y*16-1;
  71.       for (x = 8*frames[i].x-1; x < (frames[i].x+frames[i].dx)*8; x++) bptr[y*640+x] = a1;
  72.       y = (frames[i].y+frames[i].dy)*16;
  73.       for (x = 8*frames[i].x-1; x < (frames[i].x+frames[i].dx)*8; x++) bptr[y*640+x] = a1;
  74.       x = frames[i].x*8-1;
  75.       for (y = 16*frames[i].y; y < (frames[i].y+frames[i].dy)*16; y++) bptr[y*640+x] = a1;
  76.       x = (frames[i].x+frames[i].dx)*8;
  77.       for (y = 16*frames[i].y; y < (frames[i].y+frames[i].dy)*16; y++) bptr[y*640+x] = a1;
  78.    }
  79.  
  80.    gdibmp.header.bmiHeader.biBitCount = 8;
  81.    if(needclr)
  82.        gdi_frame();
  83.    SetDIBitsToDevice(temp.gdidc, int(temp.gx), int(temp.gy), 640, 480, 0, 0, 0, 480, bptr, &gdibmp.header, DIB_RGB_COLORS);
  84.    gdibmp.header.bmiHeader.biBitCount = u16(temp.obpp);
  85. }
  86.  
  87. void frame(unsigned x, unsigned y, unsigned dx, unsigned dy, unsigned char attr)
  88. {
  89.    frames[nfr].x = u8(x);
  90.    frames[nfr].y = u8(y);
  91.    frames[nfr].dx = u8(dx);
  92.    frames[nfr].dy = u8(dy);
  93.    frames[nfr].c = attr;
  94.    nfr++;
  95. }
  96.  
  97. void tprint(unsigned x, unsigned y, const char *str, unsigned char attr)
  98. {
  99.    for (unsigned ptr = y*80 + x; *str; str++, ptr++) {
  100.       txtscr[ptr] = u8(*str);
  101.       txtscr[ptr+80*30] = attr;
  102.    }
  103. }
  104.  
  105. void tprint_fg(unsigned x, unsigned y, const char *str, unsigned char attr)
  106. {
  107.     for(unsigned ptr = y * 80 + x; *str; str++, ptr++)
  108.     {
  109.         txtscr[ptr] = u8(*str);
  110.         txtscr[ptr + 80 * 30] = (txtscr[ptr + 80 * 30] & 0xF0) + attr;
  111.     }
  112. }
  113.  
  114. void filledframe(unsigned x, unsigned y, unsigned dx, unsigned dy, unsigned char color)
  115. {
  116.     for(unsigned yy = y; yy < (y + dy); yy++)
  117.     {
  118.         for(unsigned xx = x; xx < (x + dx); xx++)
  119.         {
  120.             txtscr[yy * 80 + xx] = ' ';
  121.             txtscr[yy * 80 + xx + 30 * 80] = color;
  122.         }
  123.     }
  124.    nfr = 0; // delete other frames while dialog
  125.    frame(x,y,dx,dy,FFRAME_FRAME);
  126. }
  127.  
  128. void fillattr(unsigned x, unsigned y, unsigned dx, unsigned char color)
  129. {
  130.    for (unsigned xx = x; xx < (x+dx); xx++)
  131.       txtscr[y*80+xx+30*80] = color;
  132. }
  133.  
  134. char str[0x80];
  135. unsigned inputhex(unsigned x, unsigned y, unsigned sz, bool hex)
  136. {
  137.    unsigned cr = 0;
  138.    mousepos = 0;
  139.  
  140.    for (;;)
  141.    {
  142.       str[sz] = 0;
  143.  
  144.       size_t i;
  145.       for (i = strlen(str); i < sz; i++)
  146.           str[i] = ' ';
  147.       for (i = 0; i < sz; i++)
  148.       {
  149.          unsigned vl = (unsigned char)str[i];
  150.          tprint(unsigned(x+i), unsigned(y), (char*)&vl,(i==cr) ? W_INPUTCUR : W_INPUTBG);
  151.       }
  152.  
  153.       debugflip();
  154.  
  155.       unsigned key;
  156.       for (;;Sleep(20))
  157.       {
  158.          key = process_msgs();
  159.          needclr = 0;
  160.          debugflip();
  161.  
  162.          if (mousepos)
  163.              return 0;
  164.          if (key)
  165.              break;
  166.       }
  167.  
  168.       switch(key)
  169.       {
  170.       case VK_ESCAPE: return 0;
  171.       case VK_RETURN:
  172.          for (char *ptr = str+sz-1; *ptr == ' ' && ptr >= str; *ptr-- = 0);
  173.          return 1;
  174.       case VK_LEFT:
  175.           if (cr)
  176.               cr--;
  177.           continue;
  178.       case VK_BACK:
  179.           if (cr)
  180.           {
  181.               for (i = cr; i < sz; i++)
  182.                   str[i-1]=str[i];
  183.               str[sz-1] = ' ';
  184.               --cr;
  185.           }
  186.           continue;
  187.       case VK_RIGHT:
  188.           if(cr != sz-1)
  189.               cr++;
  190.           continue;
  191.       case VK_HOME:
  192.           cr=0;
  193.           continue;
  194.       case VK_END:
  195.           for (cr=sz-1; cr && str[cr]==' ' && str[cr-1] == ' '; cr--);
  196.           continue;
  197.       case VK_DELETE:
  198.           for (i = cr; i < sz-1; i++)
  199.               str[i]=str[i+1];
  200.           str[sz-1] = ' ';
  201.           continue;
  202.       case VK_INSERT:
  203.           for (i = sz-1; i > cr; i--)
  204.               str[i]=str[i-1];
  205.           str[cr] = ' ';
  206.           continue;
  207.       }
  208.  
  209.       u8 Kbd[256];
  210.       GetKeyboardState(Kbd);
  211.       unsigned short k = 0;
  212.       if (ToAscii(key, 0, Kbd, &k, 0) == 1)
  213.       {
  214.           char m;
  215.           if(CharToOemBuff((char *)&k, &m, 1))
  216.           {
  217.               int u = toupper(m);
  218.               if (!hex || ((u >= '0' && u <= '9') || (u >= 'A' && u <= 'F')))
  219.               {
  220.                   str[cr++] = char(hex ? u : m);
  221.               }
  222.           }
  223.       }
  224.       if (cr == sz)
  225.           cr--;
  226.    }
  227. }
  228.  
  229. int input4(unsigned x, unsigned y, unsigned val)
  230. {
  231.    sprintf(str, "%04X", val);
  232.    if (inputhex(x,y,4,true))
  233.    {
  234.        sscanf(str, "%x", &val);
  235.        return int(val);
  236.    }
  237.    return -1;
  238. }
  239.  
  240. int input2(unsigned x, unsigned y, unsigned val)
  241. {
  242.    sprintf(str, "%02X", val);
  243.    if (inputhex(x,y,2,true))
  244.    {
  245.        sscanf(str, "%x", &val);
  246.        return int(val);
  247.    }
  248.    return -1;
  249. }
  250.  
  251.  
  252. static void format_item(char *dst, size_t width, const char *text, MENUITEM::FLAGS flags)
  253. {
  254.    memset(dst, ' ', width+2); dst[width+2] = 0;
  255.    size_t sz = strlen(text), left = 0;
  256.    if (sz > width) sz = width;
  257.    if (flags & MENUITEM::RIGHT) left = width - sz;
  258.    else if (flags & MENUITEM::CENTER) left = (width - sz)/2;
  259.    memcpy(dst+left+1, text, sz);
  260. }
  261.  
  262. static void paint_items(MENUDEF *menu)
  263. {
  264.    char ln[80]; unsigned item;
  265.  
  266.    size_t maxlen = strlen(menu->title);
  267.    for (item = 0; item < menu->n_items; item++) {
  268.       size_t sz = strlen(menu->items[item].text);
  269.       maxlen = max(maxlen, sz);
  270.    }
  271.    unsigned menu_dx = unsigned(maxlen+2), menu_dy = menu->n_items + 3;
  272.    unsigned menu_x = (80 - menu_dx)/2, menu_y = (30 - menu_dy)/2;
  273.    filledframe(menu_x, menu_y, menu_dx, menu_dy, MENU_INSIDE);
  274.    format_item(ln, maxlen, menu->title, MENUITEM::CENTER);
  275.    tprint(menu_x, menu_y, ln, MENU_HEADER);
  276.  
  277.    for (/*unsigned*/ item = 0; item < menu->n_items; item++) {
  278.       unsigned char color = MENU_ITEM;
  279.       if (menu->items[item].flags & MENUITEM::DISABLED) color = MENU_ITEM_DIS;
  280.       else if (item == menu->pos) color = MENU_CURSOR;
  281.       format_item(ln, maxlen, menu->items[item].text, menu->items[item].flags);
  282.       tprint(menu_x, menu_y+item+2, ln, color);
  283.    }
  284. }
  285.  
  286. static void menu_move(MENUDEF *menu, int dir)
  287. {
  288.    unsigned start = menu->pos;
  289.    for (;;) {
  290.       menu->pos = unsigned(int(menu->pos) + dir);
  291.       if ((int)menu->pos == -1) menu->pos = menu->n_items-1;
  292.       if (menu->pos >= menu->n_items) menu->pos = 0;
  293.       if (!(menu->items[menu->pos].flags & MENUITEM::DISABLED)) return;
  294.       if (menu->pos == start) return;
  295.    }
  296. }
  297.  
  298. char handle_menu(MENUDEF *menu)
  299. {
  300.    if (menu->items[menu->pos].flags & MENUITEM::DISABLED)
  301.       menu_move(menu, 1);
  302.    for (;;)
  303.    {
  304.       paint_items(menu);
  305.       debugflip();
  306.  
  307.       unsigned key;
  308.       for (;;Sleep(20))
  309.       {
  310.          key = process_msgs();
  311.          needclr =  0;
  312.          debugflip();
  313.  
  314.          if (mousepos)
  315.              return 0;
  316.          if(key)
  317.              break;
  318.       }
  319.       if (key == VK_ESCAPE)
  320.           return 0;
  321.       if (key == VK_RETURN || key == VK_SPACE)
  322.           return 1;
  323.       if (key == VK_UP || key == VK_LEFT)
  324.           menu_move(menu, -1);
  325.       if (key == VK_DOWN || key == VK_RIGHT)
  326.           menu_move(menu, 1);
  327.       if (key == VK_HOME || key == VK_PRIOR)
  328.       {
  329.           menu->pos = -1U;
  330.           menu_move(menu, 1);
  331.       }
  332.       if (key == VK_END || key == VK_NEXT)
  333.       {
  334.           menu->pos = menu->n_items;
  335.           menu_move(menu, -1);
  336.       }
  337.    }
  338. }
  339.