Subversion Repositories pentevo

#include "std.h"

#include "emul.h"

#include "vars.h"

#include "debug.h"

#include "dbgpaint.h"

#include "dx.h"

#include "draw.h"

#include "dxrframe.h"

#include "font16.h"

#include "util.h"

#include "debug_tools.h"                // [NS]

//=============================================================================

// 640x480      80x30

// 768x586      96x36,625

//unsigned char gdi_dbg_buf[ 2 * 1048576]; //2MB

const int c8 = 8;                                                               // [NS]

const int c16 = 16;

//#define SB80  84      // в dbgpaint.h

//#define SB30  30

const int s80 = 80;//84;//80;

const int s30 = 30;//32;//30;

const int s192 = 192;

const int s640 = 640;//672;//640;

const int s480 = 480;//512;//480;

//unsigned char txtscr[ 80 * 30 * 2];

unsigned char txtscr[ SB80 * SB30 * 2]; // не принимает переменные

//=============================================================================

//=============================================================================

static struct

{

    unsigned char x;

    unsigned char y;

    unsigned char dx;

    unsigned char dy;

    unsigned char c;

} frames[ 20];

//=============================================================================

unsigned nfr;

//=============================================================================

void debugflip()

{

// printf("debugflip()\n");

// printf("temp.scx %d\n",temp.scx);

    //-------------------------------------------------------------------------

    // обновление debug tools-ов при активном дебагере

    for (int cnt = 0;    cnt < DEBUG_TOOLS_MAX_COUNT;    cnt++)

    {

        //---------------------------------------------------------------------

        // обновляем только открытые окна

        if (debug_tool_exist[ cnt])

        {

            InvalidateRect( debug_tool_hwnd[ cnt], NULL, FALSE); // не стирать фон

            UpdateWindow(   debug_tool_hwnd[ cnt]);              // [NS] test

        }

        //---------------------------------------------------------------------

    }

    //-------------------------------------------------------------------------

    /*

    if (!active)                        // [NS] неясно зачем пропускать отрисовку когдаа она нада?

    {                                   // может пушо этим занималсо WM_PAINT из dx.cpp

        printf("debugflip() skip\n");   // который обычно отрисовывал всяйик шлак

        return;                         // заскриншоченный 5 минут нназад

    }

    */

    setpal( 0);

//  unsigned char * const bptr = gdibuf;

    unsigned char * const bptr = gdi_dbg_buf;   // рисуем в свой отдельный буфер [NS]

    //-------------------------------------------------------------------------

    // отрисовка маленького превиева

    //          должна быть ИМЕННО ТУТ!!!

    //          пушо превиев может перекрыватсо всплывающими "окнами"

    //-------------------------------------------------------------------------

    if (show_scrshot)

    {

        //---------------------------------------------------------------------

        // для raypainted

        memcpy( save_buf,

                rbuf,

                rb2_offs

                );             

        //---------------------------------------------------------------------

        switch (show_scrshot)

        {

            case 1:     paint_scr( 0);  break;                  // [NS]

            case 2:     paint_scr( 1);  break;

            case 3:     paint_scr( 2);  break;

        }

        //---------------------------------------------------------------------

        unsigned char *dst = bptr + (wat_y * c16 * s640) + (wat_x * c8);

//      unsigned char *src = rbuf + (temp.scx / 4) * (temp.b_top +  (192 / 2) - (wat_sz *  16 / 2));

        unsigned char *src = rbuf + (temp.scx / 4) * (temp.b_top + (s192 / 2) - (wat_sz * c16 / 2));

        src += (temp.scx /  8) - (37 / 2 * 2);

//      src += (temp.scx / c8) - (37 / 2 * 2);

//      unsigned char *ray_pos = raypointer();  // [NS}

        // перекидывание zx экрана в экран дебагера

        //---------------------------------------------------------------------

        for (unsigned y = 0;    y < wat_sz * 16;    y++)        // wat_sz = 13 (Y размер знакомест в дебагере)

        {

            //-----------------------------------------------------------------

            // 1 байт на пиксель !!!!

            for (unsigned x = 0;    x < 37;    x++)             //37 знакомест

            {

                // НО все равно просто так не вырватсо из мерзского hardware multicolor-а [NS]

                //-------------------------------------------------------------

                // отрисованные пиксели

                //if (reinterpret_cast<int>(src+(2*x)) < reinterpret_cast<int>(ray_pos))

                //{

                //левые 4 пикселя

                *(unsigned*) (dst + x * 8 + 0) = t.sctab8[ 0][( src[ x * 2] >>  4) + src[ 2 * x + 1] * 16];    

                //правые 4 пикселя

                *(unsigned*) (dst + x * 8 + 4) = t.sctab8[ 0][( src[ x * 2] & 0xF) + src[ 2 * x + 1] * 16];

                //}

                //-------------------------------------------------------------

                // пиксели с предыдущего кадра

                //else

                //{

                ////левые 4 пикселя

                //*(unsigned*)(dst + x * 8 + 0) = (t.sctab8[0][(src[x * 2] >>  4) + src[2 * x + 1] * 16]);      

                ////правые 4 пикселя

                //*(unsigned*)(dst + x * 8 + 4) = (t.sctab8[0][(src[x * 2] & 0xF) + src[2 * x + 1] * 16]);

                //}

            } // x

            //-----------------------------------------------------------------

            src += temp.scx / 4;

            //dst += 640;

            dst += s640;

        } // y

        //---------------------------------------------------------------------

        // для raypainted

        memcpy( rbuf,

                save_buf,

                rb2_offs);

        //---------------------------------------------------------------------

    }

    //-------------------------------------------------------------------------

    //-------------------------------------------------------------------------

    // print text mode

    //-------------------------------------------------------------------------

    int x;

    int y;

    unsigned char *tptr = txtscr;

    //-------------------------------------------------------------------------

//  for (y = 0;    y < (16 * 30 * 640);    y += (16 * 640))

    for (y = 0;    y < (c16 * s30 * s640);    y += (c16 * s640))

    {

        //---------------------------------------------------------------------

        // for (x = 0;    x < 80;    x++, tptr++)

        for (x = 0;    x < s80;    x++, tptr++)

        {

            unsigned ch = *tptr;

            //unsigned at = tptr[ 80 * 30];

            unsigned at = tptr[ s80 * s30];

            //-----------------------------------------------------------------

            //transparent color - НЕНУЖЕН

            if (at == 0xFF)

                continue;

            //-----------------------------------------------------------------

            //const unsigned char *fnt = &font16[ ch * 16];

            const unsigned char *fnt = &font16[ ch * c16];

            at <<= 4;

            //-----------------------------------------------------------------

            //for (int yy = 0;    yy < 16;    yy++, fnt++)

            for (int yy = 0;    yy < c16;    yy++, fnt++)

            {

            //  unsigned sctab8[2][16*0x100];  //4 bits data+pc-attribute -> 4 palette pixels

                //правые 4 пикселя

                //*(unsigned*) (bptr + y + (640 * yy) + (x * 8) + 0) = t.sctab8[ 0][( *fnt >>  4) + at];

                *(unsigned*) (bptr + y + (s640 * yy) + (x * 8) + 0) = t.sctab8[ 0][( *fnt >>  4) + at];

                //левые 4 пикселя

                //*(unsigned*) (bptr + y + (640 * yy) + (x * 8) + 4) = t.sctab8[ 0][( *fnt & 0xF) + at];

                *(unsigned*) (bptr + y + (s640 * yy) + (x * 8) + 4) = t.sctab8[ 0][( *fnt & 0xF) + at];

            }

            //-----------------------------------------------------------------

        }

        //---------------------------------------------------------------------

    }

    //-------------------------------------------------------------------------

    //-------------------------------------------------------------------------

    // отрисовка "рамочек" из буфера

    // но РАМОЧКИ НЕНУЖНЫ

    /*

    for (unsigned i = 0;    i < nfr;    i++)

    {

        //unsigned char a1 = (frames[i].c | 0x08) * 0x11;

        unsigned char a1 = (frames[ i].c & 0x0F) | ((frames[ i].c & 0x0F) << 4);        //attr 256c ?

        //---------------------------------------------------------------------

        //y = frames[i].y * 16 - 1;

        y = frames[i].y * c16 - 1;

        //---------------------------------------------------------------------

        for (x = 8 * frames[ i].x - 1;    x < (frames[ i].x + frames[ i].dx) * 8;    x++)

        {

            // bptr[ y * 640 + x] = a1;

            bptr[ y * s640 + x] = a1;

        }

        //---------------------------------------------------------------------

        //y = (frames[ i].y + frames[ i].dy) * 16;

        y = (frames[ i].y + frames[ i].dy) * c16;

        //---------------------------------------------------------------------

        for (x = 8 * frames[ i].x - 1;    x < (frames[ i].x + frames[ i].dx) * 8;    x++)

        {

            // bptr[ y * 640 + x] = a1;

            bptr[ y * s640 + x] = a1;

        }

        //---------------------------------------------------------------------

        x = frames[i].x * 8 - 1;

        //---------------------------------------------------------------------

        for (y = 16 * frames[ i].y;    y < (frames[ i].y + frames[ i].dy) * 16;    y++)

        {

            // bptr[ y * 640 + x] = a1;

            bptr[ y * s640 + x] = a1;

        }

        //---------------------------------------------------------------------

        x = (frames[ i].x + frames[ i].dx) * 8;

        //---------------------------------------------------------------------

        for (y = 16 * frames[ i].y;    y < (frames[ i].y + frames[ i].dy) * 16;    y++)

        {

            //bptr[ y * 640 + x] = a1;

            bptr[ y * s640 + x] = a1;

        }

        //---------------------------------------------------------------------

    }

    */

    //-------------------------------------------------------------------------

//      //---------------------------------------------------------------------

//      //tzt

//      for (unsigned y = 0;    y < 50;    y++)         // wat_sz = 13 (Y размер знакомест в дебагере)

//      {

//              *(bptr + y + (y*s640)) = 0xFF;

//      }

//      //---------------------------------------------------------------------

//  gdibmp.header.bmiHeader.biBitCount = 8;

    gdi_dbg_bmp.header.bmiHeader.biBitCount = 8;

    //может нужно перенести выше до отррисовки?

    //-------------------------------------------------------------------------

    if (needclr)

        gdi_frame();

    //-------------------------------------------------------------------------

/*

   SetDIBitsToDevice(   temp.gdidc,             //ORIG

                        int(temp.gx),

                        int(temp.gy),

                        640,

                        480,

                        0,

                        0,

                        0,

                        480,

                        bptr,

                        &gdibmp.header,

                        DIB_RGB_COLORS

                     );

*/

                //написано без доки !!!

                //нужно уточнение всех параметров

              //для дебагера отдельный

    gdi_dbg_bmp.header.bmiHeader.biSize = sizeof( BITMAPINFOHEADER);

    gdi_dbg_bmp.header.bmiHeader.biPlanes = 1;

    gdi_dbg_bmp.header.bmiHeader.biBitCount = 8;

    gdi_dbg_bmp.header.bmiHeader.biWidth = LONG( s640);         // [NS]

    gdi_dbg_bmp.header.bmiHeader.biHeight = -LONG( s480);

    gdi_dbg_bmp.header.bmiHeader.biBitCount = WORD( temp.obpp);

//      bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

//      bmi.bmiHeader.biPlanes = 1;

//      bmi.bmiHeader.biBitCount = 32;

//      bmi.bmiHeader.biCompression = BI_RGB;

//      bmi.bmiHeader.biWidth = 320;

//      bmi.bmiHeader.biHeight = 160;

// printf("temp.gx %d temp.gy %d\n",temp.gx,temp.gy);

    RECT current_mainwnd_size;

    GetClientRect( wnd, &current_mainwnd_size);

    int new_wnd_size_x = current_mainwnd_size.right - current_mainwnd_size.left;

    int new_wnd_size_y = current_mainwnd_size.bottom - current_mainwnd_size.top;

//  сделать на upscale COLORONCOLOR или HALFTONE

//  для downscale по выбору HALFTONE COLORONCOLOR WHITEONBLACK

  //SetStretchBltMode(temp.gdidc, BLACKONWHITE);        //так ниче не видно (и по дефолту)

  //SetStretchBltMode(temp.gdidc, WHITEONBLACK);        //так жирный белый шрифт

    SetStretchBltMode( temp.gdidc, COLORONCOLOR);       //так биения и наверно бысстрей всего

  //SetStretchBltMode(temp.gdidc, HALFTONE);            //так размывает но нагрузка на проц

  //SetStretchBltMode(temp.gdidc, 5);           //WHITEONBLACK

  //SetStretchBltMode(temp.gdidc, 0);           //WHITEONBLACK

    StretchDIBits(      temp.gdidc,                             //NS

                        0,      //int(temp.gx), //= 0   //куда вмещать

                        0,      //int(temp.gy), //= 0?

                        new_wnd_size_x, //temp.ox,//320,//640,

                        new_wnd_size_y, //temp.oy,//240,//480,

                        0,      //какую часть кидить

                        0,

                        s640,   //640,

                        s480,   //480,

                        bptr,

                        &gdi_dbg_bmp.header,//&gdibmp.header,

                        DIB_RGB_COLORS,

                        SRCCOPY

                );

//  gdibmp.header.bmiHeader.biBitCount = u16(temp.obpp);

    gdi_dbg_bmp.header.bmiHeader.biBitCount = u16( temp.obpp);  // [NS]

}

//=============================================================================

//=============================================================================

void frame( unsigned x, unsigned y, unsigned dx, unsigned dy, unsigned char attr)

{

// DEPRECATED

    /*

    frames[ nfr].x =  u8( x);

    frames[ nfr].y =  u8( y);

    frames[ nfr].dx = u8( dx);

    frames[ nfr].dy = u8( dy);

    frames[ nfr].c = attr;

    nfr++;

    */

}

//=============================================================================

//=============================================================================

// Отрисовка строки с указанием атрибута

void tprint( unsigned x, unsigned y, const char *str, unsigned char attr)

{

    for (unsigned ptr = y * s80 + x;    *str;    str++, ptr++)

    {

        txtscr[ ptr] = u8( *str);

        txtscr[ ptr + s80 * s30] = attr;        //запись атрибута вместо

    }

}

//=============================================================================

//=============================================================================

// Отрисовка строки с указанием атрибута только ink-а (но можно влиять на paper !)

void tprint_fg( unsigned x, unsigned y, const char *str, unsigned char attr)

{

    for (unsigned ptr = y * s80 + x;    *str;    str++, ptr++)

    {

        txtscr[ ptr] = u8( *str);

        txtscr[ ptr + s80 * s30] = (txtscr[ ptr + s80 * s30] & 0xF0) + attr;

    }

}

//=============================================================================

// Новые цвета для дебагера [NS]

#define DBG_ATTR_BCKGRND                0x00    //0     0

#define DBG_ATTR_BCKGRND_ACTIVE         0x10    //blue

#define DBG_ATTR_WINDOW_FRAME           0x02    //

#define DBG_ATTR_INPUT_HIGHLIGHT        0xC0    //br+GREEN      0

#define DBG_ATTR_INPUT_CURSOR           0xE0    //br+YELLOW     9

#define DBG_ATTR_WINDOW_TITLE           0xF0//0x1F      //blue  br+WHITE

#define DBG_ATTR_WINDOW_BACK_COLOR      0x70//0x70//white       0

#define DBG_ATTR_WINDOW_TEXT            0x70

#define DBG_ATTR_WINDOW_TEXT_GRAY       0x7A            //почемуто юзаеттссо как error

#define DBG_ATTR_WINDOW_TEXT_ERROR      0x72            //white red

#define DBG_ATTR_WINDOW_TEXT_CURSOR     0xE0            //white red

//=============================================================================

// рисовалка текстовых окошек

void filledframe( unsigned x, unsigned y, unsigned dx, unsigned dy, unsigned char color)

{

    //-------------------------------------------------------------------------

    for (unsigned yy = y;    yy < (y + dy);    yy++)

    {

        for (unsigned xx = x;    xx < (x + dx);    xx++)

        {

            txtscr[ yy * s80 + xx] = ' ';

            txtscr[ yy * s80 + xx + s30 * s80] = color;

        }

    }

    //-------------------------------------------------------------------------

    nfr = 0; // delete other frames while dialog

    frame(      x,

                y,

                dx,

                dy,

                DBG_ATTR_WINDOW_FRAME   //FFRAME_FRAME

          );

}

//=============================================================================

//=============================================================================

void fillattr( unsigned x, unsigned y, unsigned dx, unsigned char color)

{

    for (unsigned xx = x;    xx < (x + dx);    xx++)

    {

        txtscr[ y * s80 + xx + s30 * s80] = color;

    }

}

//=============================================================================

//=============================================================================

char str[ 0x80];

//=============================================================================

unsigned inputhex( unsigned x, unsigned y, unsigned sz, bool hex, bool insert_mode)

{

// ВНЕЗАПНО ИСПОЛЬЗУЕТСО И ДЛЯ ТЕКСТА

//  insert_mode = TRUE; (by default) [NS]       для совместимости со старым вызовом без указания insert_mode

//                                              режим ввода заменой под курсором

    unsigned cr = 0;

    mousepos = 0;

    //-------------------------------------------------------------------------

    for (    ;    ;    )

    {

//      str[sz] = 0;

        str[ sz + 5] = 0;

        size_t i;

        //---------------------------------------------------------------------

        for (i = strlen( str);    i < sz;    i++)

        {

            //printf("*\n");

            str[ i] = ' ';

        }

        //---------------------------------------------------------------------

        for (i = 0;    i < sz;    i++)  //sz - количество символов для ввода

        {

            unsigned vl = (unsigned char) str[ i];

            tprint(     unsigned( x + i),

                        unsigned( y),

                        (char*) &vl,

                        (i == cr)   ?   DBG_ATTR_INPUT_CURSOR :         //W_INPUTCUR :

                                        DBG_ATTR_INPUT_HIGHLIGHT        //W_INPUTBG

                   );

        }

        //---------------------------------------------------------------------

        debugflip();

        //---------------------------------------------------------------------

        unsigned key;

        //---------------------------------------------------------------------

        // Ожидание нажатия клавиши infinity loop

        for (    ;    ;  Sleep( 20)  )

        {

            key = process_msgs();

            needclr = 0;  

            //-----------------------------------------------------------------

            //debugflip();      //зачем то без остановки перрерисовка

                                //wmpaint каким то хреном работает ии так

            //-----------------------------------------------------------------

            // выход из редактирования по клику в другое место

            if (mousepos)       //заменить на более осмысленное !!!!!

            {

                return 0;

            }

            //-----------------------------------------------------------------

            // выходи из цикла по нажатию клавиши

            if (key)

            {

                break;

            }

            //-----------------------------------------------------------------

        }

        debugflip();

        //---------------------------------------------------------------------

        switch (key)

        {

            //=================================================================

            case VK_ESCAPE:

                return 0;

            //=================================================================

            case VK_RETURN:

                //-------------------------------------------------------------

                for (char *ptr = str + sz - 1;    *ptr == ' ' && ptr >= str;    *ptr-- = 0);

                //-------------------------------------------------------------

                return 1;

            //=================================================================

            case VK_LEFT:

                //-------------------------------------------------------------

                if (cr)

                    cr--;

                //-------------------------------------------------------------

                continue;

            //=================================================================

            case VK_BACK:

                //-------------------------------------------------------------

                if (cr)

                {

                    //---------------------------------------------------------

                    for (i = cr;    i < sz;    i++)

                        str[ i - 1] = str[ i];

                    //---------------------------------------------------------

                    str[ sz - 1] = ' ';

                    --cr;

                }

                //-------------------------------------------------------------

                continue;

            //=================================================================

            case VK_RIGHT:

                //-------------------------------------------------------------

                if (cr != sz-1)

                    cr++;

                //-------------------------------------------------------------

                continue;

            //=================================================================

            case VK_HOME:

                cr = 0;

                continue;

            //=================================================================

            case VK_END:

                //-------------------------------------------------------------

                for (cr = sz - 1;    cr && (str[ cr] == ' ') && (str[ cr - 1] == ' ');    cr--);

                //-------------------------------------------------------------

                continue;       //?????????

            //=================================================================

            case VK_DELETE:

                //-------------------------------------------------------------

                for (i = cr;    i < sz - 1;    i++)

                    str[ i] = str[ i + 1];

                //-------------------------------------------------------------

                str[ sz - 1] = ' ';

                continue;

            //=================================================================

            case VK_INSERT:

                //-------------------------------------------------------------

                for (i = sz - 1;    i > cr;    i--)

                    str[ i] = str[ i - 1];

                //-------------------------------------------------------------

                str[ cr] = ' ';

                continue;

            //=================================================================

            case VK_UP:         // выход из редактирования

                //printf("VK_UP\n");

                PostThreadMessage( GetCurrentThreadId(), WM_KEYDOWN, VK_UP, 1);

                //PostThreadMessage(GetCurrentThreadId(), WM_KEYUP, input.lastkey, 1);

                return 0;       // тут еще надо шагание в эту же сторону

                break;          // но как его сделать?

            //=================================================================

            case VK_DOWN:       // так не работает вверх

                //printf("VK_DOWN\n");

                PostThreadMessage( GetCurrentThreadId(), WM_KEYDOWN, VK_DOWN, 1);

                return 0;

                break;

            //=================================================================

        }

        //---------------------------------------------------------------------

        u8 Kbd[ 256];

        GetKeyboardState( Kbd);

        unsigned short k = 0;

        //---------------------------------------------------------------------

        if ( ToAscii( key, 0, Kbd, &k, 0) == 1 )

        {

            char m;

            //-----------------------------------------------------------------

            if ( CharToOemBuff( (char *) &k, &m, 1) )

            {

                //-------------------------------------------------------------

                // нормальнный людской ввод

                if (!insert_mode)                       // [NS]

                {

                    for (i = sz - 1;    i > cr;    i--)

                        str[ i] = str[ i - 1];

                }

                //-------------------------------------------------------------

                int u = toupper(m);

                //-------------------------------------------------------------

                if (!hex || (((u >= '0') && (u <= '9')) || ((u >= 'A') && (u <= 'F'))))

                {

                    str[ cr++] = char( hex  ?  u :

                                               m );

                }

                //-------------------------------------------------------------

            }

            //-----------------------------------------------------------------

        }

        //---------------------------------------------------------------------

        if (cr == sz)   //тут надо выход вообще

        {

            cr--;

                //return 1;     //так выход

                //              //НО так начинаютсо дополнительные прроблемы

                //              //особенно когда введенное невалидно

                //              // и тогда курсор перескакиивает в начало и...

        }

        //---------------------------------------------------------------------

    } //for (;;)

    //-------------------------------------------------------------------------

}

//=============================================================================

//=============================================================================

int input6dec( unsigned x, unsigned y, unsigned val)    // [NS]

{

    sprintf(    str,

                "%06d",

                val

            );

    //-------------------------------------------------------------------------

    if (inputhex( x, y, 6, false ))     // не ясно за 4-й параметр true/false !!!!

    {                                   // тк результат тот же

        sscanf(     str,

                    "%d",

                    &val

                );

        return int( val);

    }

    //-------------------------------------------------------------------------

    return -1;

}

//=============================================================================

int input4( unsigned x, unsigned y, unsigned val)

{

    sprintf(    str,

                "%04X",

                val

            );

    //-------------------------------------------------------------------------

    if (inputhex( x, y, 4, true ))

    {

        sscanf(     str,

                    "%x",

                    &val

                );

        return int( val);

    }

    //-------------------------------------------------------------------------

    return -1;

}

//=============================================================================

int input2( unsigned x, unsigned y, unsigned val)

{

    sprintf(    str,

                "%02X",

                val

            );

    //-------------------------------------------------------------------------

    if (inputhex( x, y, 2, true ))

    {

        sscanf(     str,

                    "%x",

                    &val

                );

        return int( val);

    }

    //-------------------------------------------------------------------------

    return -1;

}

//=============================================================================

int input1( unsigned x, unsigned y, unsigned val)

{

    sprintf(    str,

                "%01X",

                val

           );

    //-------------------------------------------------------------------------

    if (inputhex( x, y, 1, true ))

    {

        sscanf(     str,

                    "%x",

                    &val

              );

        return int( val);

    }

    //-------------------------------------------------------------------------

    return -1;

}

//=============================================================================

//=============================================================================

static void format_item( char *dst, size_t width, const char *text, MENUITEM::FLAGS flags)

{

    memset(     dst,

                ' ',

                width + 2);

    dst[ width + 2] = 0;

    size_t sz = strlen( text), left = 0;

    //-------------------------------------------------------------------------

    if (sz > width)

        sz = width;

    //-------------------------------------------------------------------------

    if (flags & MENUITEM::RIGHT)

        left = width - sz;

    //-------------------------------------------------------------------------

    else if (flags & MENUITEM::CENTER)

        left = (width - sz) / 2;

    //------------------------------------------------------------------------- 

    memcpy(     dst + left + 1,

                text,

                sz

           );

}

//=============================================================================

//=============================================================================

// рисование некоторых менюшек

static void paint_items( MENUDEF *menu)

{

    char ln[ 80];

    unsigned item;

    size_t maxlen = strlen( menu->title);

    //-------------------------------------------------------------------------

    for (item = 0;    item < menu->n_items;    item++)

    {

        size_t sz = strlen( menu->items[ item].text);

        maxlen = max( maxlen, sz);

    }

    //-------------------------------------------------------------------------

    unsigned menu_dx = unsigned( maxlen + 2), menu_dy = menu->n_items + 3;

    //unsigned menu_x = (80 - menu_dx) / 2, menu_y = (30 - menu_dy) / 2;

    unsigned menu_x = (s80 - menu_dx) / 2, menu_y = (s30 - menu_dy) / 2;

    filledframe(        menu_x,

                        menu_y,

                        menu_dx,

                        menu_dy,

                        DBG_ATTR_WINDOW_TEXT    //MENU_INSIDE

                );

    format_item(        ln,

                        maxlen,

                        menu->title,

                        MENUITEM::CENTER

                );

    tprint(     menu_x,

                menu_y,

                ln,

                DBG_ATTR_WINDOW_TITLE           //MENU_HEADER

           );

    //-------------------------------------------------------------------------

    for (/*unsigned*/ item = 0;    item < menu->n_items;    item++)

    {

        unsigned char color = DBG_ATTR_WINDOW_TEXT;     //MENU_ITEM;

        //---------------------------------------------------------------------

        if (menu->items[ item].flags & MENUITEM::DISABLED)

            color = DBG_ATTR_WINDOW_TEXT_GRAY;          //MENU_ITEM_DIS;        //ERROR?

        //---------------------------------------------------------------------