Subversion Repositories eduke32

Rev

Rev 4890 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5 Plagman 1
// On-screen Display (ie. console)
2
// for the Build Engine
2456 hendricks2 3
// by Jonathon Fowler (jf@jonof.id.au)
5 Plagman 4
 
5
#include "build.h"
6
#include "osd.h"
7
#include "compat.h"
8
#include "baselayer.h"
821 terminx 9
#include "cache1d.h"
876 terminx 10
#include "pragmas.h"
1625 terminx 11
#include "scancodes.h"
1635 terminx 12
#include "crc32.h"
4387 terminx 13
#include "xxhash.h"
4660 terminx 14
#include "common.h"
4890 terminx 15
#include "editor.h"
5 Plagman 16
 
4213 helixhorne 17
static symbol_t *symbols = NULL;
5 Plagman 18
static symbol_t *addnewsymbol(const char *name);
19
static symbol_t *findsymbol(const char *name, symbol_t *startingat);
20
static symbol_t *findexactsymbol(const char *name);
21
 
1205 terminx 22
// static int32_t _validate_osdlines(void *);
5 Plagman 23
 
1205 terminx 24
static int32_t _internal_osdfunc_listsymbols(const osdfuncparm_t *);
25
static int32_t _internal_osdfunc_help(const osdfuncparm_t *);
26
static int32_t _internal_osdfunc_alias(const osdfuncparm_t *);
27
// static int32_t _internal_osdfunc_dumpbuildinfo(const osdfuncparm_t *);
28
// static int32_t _internal_osdfunc_setrendermode(const osdfuncparm_t *);
5 Plagman 29
 
1205 terminx 30
static int32_t white=-1;            // colour of white (used by default display routines)
31
static void _internal_drawosdchar(int32_t, int32_t, char, int32_t, int32_t);
3321 helixhorne 32
static void _internal_drawosdstr(int32_t, int32_t, const char *, int32_t, int32_t, int32_t);
1205 terminx 33
static void _internal_drawosdcursor(int32_t,int32_t,int32_t,int32_t);
34
static int32_t _internal_getcolumnwidth(int32_t);
35
static int32_t _internal_getrowheight(int32_t);
36
static void _internal_clearbackground(int32_t,int32_t);
37
static int32_t _internal_gettime(void);
38
static void _internal_onshowosd(int32_t);
5 Plagman 39
 
4536 terminx 40
osdmain_t *osd = NULL;
1625 terminx 41
 
1205 terminx 42
static int32_t  osdrowscur=-1;
43
static int32_t  osdscroll=0;
44
static int32_t  osdmaxrows=20;      // maximum number of lines which can fit on the screen
4821 hendricks2 45
BFILE *osdlog;      // log filehandle
46
const char* osdlogfn;
1205 terminx 47
static int32_t  keytime=0;
48
static int32_t osdscrtime = 0;
5 Plagman 49
 
50
 
4536 terminx 51
#define editlinewidth (osd->draw.cols-1-3)
5 Plagman 52
 
53
 
4536 terminx 54
static hashtable_t h_osd      = { OSDMAXSYMBOLS<<1, NULL };
4139 helixhorne 55
 
56
// Application callbacks: these are the currently effective ones.
1205 terminx 57
static void (*drawosdchar)(int32_t, int32_t, char, int32_t, int32_t) = _internal_drawosdchar;
3321 helixhorne 58
static void (*drawosdstr)(int32_t, int32_t, const char *, int32_t, int32_t, int32_t) = _internal_drawosdstr;
1205 terminx 59
static void (*drawosdcursor)(int32_t, int32_t, int32_t, int32_t) = _internal_drawosdcursor;
60
static int32_t (*getcolumnwidth)(int32_t) = _internal_getcolumnwidth;
61
static int32_t (*getrowheight)(int32_t) = _internal_getrowheight;
4139 helixhorne 62
 
1205 terminx 63
static void (*clearbackground)(int32_t,int32_t) = _internal_clearbackground;
64
static int32_t (*gettime)(void) = _internal_gettime;
65
static void (*onshowosd)(int32_t) = _internal_onshowosd;
5 Plagman 66
 
4139 helixhorne 67
// Application callbacks: these are the backed-up ones.
1205 terminx 68
static void (*_drawosdchar)(int32_t, int32_t, char, int32_t, int32_t) = _internal_drawosdchar;
3321 helixhorne 69
static void (*_drawosdstr)(int32_t, int32_t, const char *, int32_t, int32_t, int32_t) = _internal_drawosdstr;
1205 terminx 70
static void (*_drawosdcursor)(int32_t, int32_t, int32_t, int32_t) = _internal_drawosdcursor;
71
static int32_t (*_getcolumnwidth)(int32_t) = _internal_getcolumnwidth;
72
static int32_t (*_getrowheight)(int32_t) = _internal_getrowheight;
876 terminx 73
 
4536 terminx 74
static hashtable_t h_cvars      = { OSDMAXSYMBOLS<<1, NULL };
1649 helixhorne 75
int32_t m32_osd_tryscript=0;  // whether to try executing m32script on unkown command in the osd
76
 
1352 terminx 77
int32_t OSD_RegisterCvar(const cvar_t *cvar)
78
{
79
    const char *cp;
80
 
4536 terminx 81
    if (!osd)
1625 terminx 82
        OSD_Init();
1352 terminx 83
 
3350 terminx 84
    if (!cvar->name || !cvar->name[0] || !cvar->vptr)
1352 terminx 85
    {
1625 terminx 86
        OSD_Printf("OSD_RegisterCvar(): can't register null cvar\n");
1352 terminx 87
        return -1;
88
    }
89
 
90
    // check for illegal characters in name
91
    for (cp = cvar->name; *cp; cp++)
92
    {
93
        if ((cp == cvar->name) && (*cp >= '0') && (*cp <= '9'))
94
        {
95
            OSD_Printf("OSD_RegisterCvar(): first character of cvar name \"%s\" must not be a numeral\n", cvar->name);
96
            return -1;
97
        }
98
        if ((*cp < '0') ||
1357 terminx 99
                (*cp > '9' && *cp < 'A') ||
100
                (*cp > 'Z' && *cp < 'a' && *cp != '_') ||
101
                (*cp > 'z'))
1352 terminx 102
        {
103
            OSD_Printf("OSD_RegisterCvar(): illegal character in cvar name \"%s\"\n", cvar->name);
104
            return -1;
105
        }
106
    }
107
 
4536 terminx 108
    osd->cvars = (osdcvar_t *)Xrealloc(osd->cvars, (osd->numcvars + 1) * sizeof(osdcvar_t));
1657 terminx 109
 
4536 terminx 110
    hash_add(&h_cvars, cvar->name, osd->numcvars, 1);
1657 terminx 111
 
112
    switch (cvar->type & (CVAR_BOOL|CVAR_INT|CVAR_UINT|CVAR_FLOAT|CVAR_DOUBLE))
113
    {
114
    case CVAR_BOOL:
115
    case CVAR_INT:
4536 terminx 116
        osd->cvars[osd->numcvars].dval.i = *(int32_t *)cvar->vptr;
1657 terminx 117
        break;
118
    case CVAR_UINT:
4536 terminx 119
        osd->cvars[osd->numcvars].dval.uint = *(uint32_t *)cvar->vptr;
1657 terminx 120
        break;
121
    case CVAR_FLOAT:
4536 terminx 122
        osd->cvars[osd->numcvars].dval.f = *(float *)cvar->vptr;
1657 terminx 123
        break;
124
    case CVAR_DOUBLE:
4536 terminx 125
        osd->cvars[osd->numcvars].dval.d = *(double *)cvar->vptr;
1657 terminx 126
        break;
127
    }
1762 terminx 128
 
4536 terminx 129
    Bmemcpy(&osd->cvars[osd->numcvars++], cvar, sizeof(cvar_t));
1352 terminx 130
 
131
    return 0;
132
}
133
 
1657 terminx 134
static int32_t OSD_CvarModified(const osdcvar_t *cvar)
135
{
4536 terminx 136
    if (!osd)
1657 terminx 137
        return 0;
138
 
3350 terminx 139
    if (!cvar->c.vptr)
1657 terminx 140
    {
141
        OSD_Printf("OSD_CvarModified(): null cvar?!\n");
142
        return 0;
143
    }
144
 
3350 terminx 145
    switch (cvar->c.type & (CVAR_BOOL|CVAR_INT|CVAR_UINT|CVAR_FLOAT|CVAR_DOUBLE))
1657 terminx 146
    {
147
    case CVAR_BOOL:
148
    case CVAR_INT:
3350 terminx 149
        return (cvar->dval.i != *(int32_t *)cvar->c.vptr);
1657 terminx 150
    case CVAR_UINT:
3350 terminx 151
        return (cvar->dval.uint != *(uint32_t *)cvar->c.vptr);
1657 terminx 152
    case CVAR_FLOAT:
3350 terminx 153
        return (cvar->dval.f != *(float *)cvar->c.vptr);
1657 terminx 154
    case CVAR_DOUBLE:
3350 terminx 155
        return (cvar->dval.d != *(double *)cvar->c.vptr);
1657 terminx 156
    default:
4702 terminx 157
        EDUKE32_UNREACHABLE_SECTION(return 0);
1657 terminx 158
    }
159
}
160
 
1625 terminx 161
// color code format is as follows:
162
// ^## sets a color, where ## is the palette number
163
// ^S# sets a shade, range is 0-7 equiv to shades 0-14
164
// ^O resets formatting to defaults
165
 
1762 terminx 166
const char *OSD_StripColors(char *out, const char *in)
821 terminx 167
{
1625 terminx 168
    const char *ptr = out;
821 terminx 169
 
3727 helixhorne 170
    while (*in)
821 terminx 171
    {
929 terminx 172
        if (*in == '^' && isdigit(*(in+1)))
821 terminx 173
        {
929 terminx 174
            in += 2;
175
            if (isdigit(*in))
176
                in++;
821 terminx 177
            continue;
178
        }
929 terminx 179
        if (*in == '^' && (Btoupper(*(in+1)) == 'S') && isdigit(*(in+2)))
867 terminx 180
        {
929 terminx 181
            in += 3;
869 terminx 182
            continue;
183
        }
929 terminx 184
        if (*in == '^' && (Btoupper(*(in+1)) == 'O'))
869 terminx 185
        {
929 terminx 186
            in += 2;
867 terminx 187
            continue;
188
        }
1657 terminx 189
        *(out++) = *(in++);
1017 terminx 190
    }
1015 terminx 191
 
929 terminx 192
    *out = '\0';
3727 helixhorne 193
    return ptr;
821 terminx 194
}
195
 
1205 terminx 196
int32_t OSD_Exec(const char *szScript)
821 terminx 197
{
4660 terminx 198
    int32_t i, len, err = 0;
199
    char *buf = NULL, *cp;
821 terminx 200
 
4660 terminx 201
 
202
    if ((i = kopen4load(szScript, 0)) == -1) err = 1;
203
    if (!err && (len = kfilelength(i)) <= 0) err = 2; // blank file
204
    if (!err && (buf = (char *)Xmalloc(len + 1)) == NULL) err = 3;
205
 
4678 terminx 206
    if (!err || err == 3)
207
        OSD_Printf("Executing \"%s\"\n", szScript);
208
 
4660 terminx 209
    if (err || kread(i, buf, len) != len)
821 terminx 210
    {
4678 terminx 211
        if (!err || err == 3) // no error message for blank file
4660 terminx 212
            OSD_Printf("Error executing \"%s\"!\n", szScript);
213
        if (i != -1) kclose(i);
214
        if (buf != NULL) Bfree(buf);
215
        return 1;
216
    }
821 terminx 217
 
4660 terminx 218
    osd->execdepth++;
219
 
220
    buf[len] = 0;
221
    cp = strtok(buf, "\r\n");
222
 
223
    while (cp != NULL)
224
    {
225
        OSD_Dispatch(cp);
226
        cp = strtok(NULL, "\r\n");
821 terminx 227
    }
4660 terminx 228
 
229
    osd->execdepth--;
230
    kclose(i);
231
    Bfree(buf);
232
    return 0;
821 terminx 233
}
234
 
1205 terminx 235
int32_t OSD_ParsingScript(void)
891 terminx 236
{
4536 terminx 237
    return osd->execdepth;
891 terminx 238
}
239
 
1205 terminx 240
int32_t OSD_OSDKey(void)
891 terminx 241
{
4536 terminx 242
    return osd->keycode;
891 terminx 243
}
244
 
1205 terminx 245
int32_t OSD_GetCols(void)
987 terminx 246
{
4536 terminx 247
    return osd->draw.cols;
987 terminx 248
}
249
 
1644 helixhorne 250
int32_t OSD_IsMoving(void)
251
{
4536 terminx 252
    return (osdrowscur!=-1 && osdrowscur!=osd->draw.rows);
1644 helixhorne 253
}
254
 
1901 helixhorne 255
int32_t OSD_GetRowsCur(void)
256
{
257
    return osdrowscur;
258
}
259
 
1205 terminx 260
int32_t OSD_GetTextMode(void)
891 terminx 261
{
4536 terminx 262
    return osd->draw.mode;
891 terminx 263
}
264
 
4136 helixhorne 265
void OSD_GetShadePal(const char *ch, int32_t *shadeptr, int32_t *palptr)
266
{
4536 terminx 267
    // Use format buffer when 'ch' falls inside osd->text.buf[] bounds (well,
4136 helixhorne 268
    // almost).
269
    // TODO: when is this false?
4536 terminx 270
    if (ch > osd->text.buf && ch < osd->text.buf + OSDBUFFERSIZE)
4136 helixhorne 271
    {
4536 terminx 272
        *shadeptr = (osd->text.fmt[ch-osd->text.buf] & ~0x1F) >> 4;
273
        *palptr = osd->text.fmt[ch-osd->text.buf] & ~0xE0;
4136 helixhorne 274
    }
275
}
276
 
4139 helixhorne 277
// XXX: well, converting function pointers to "data pointers" (void *) is
278
// undefined behavior. See
279
//  http://blog.frama-c.com/index.php?post/2013/08/24/Function-pointers-in-C
280
// Then again, my GCC just crashed (any kept on crashing until after a reboot!)
281
// when I tried to rewrite this into something different.
3321 helixhorne 282
static inline void swapptr(void *a, void *b)
283
{
284
        intptr_t t = *(intptr_t*)a;
285
        *(intptr_t*)a = *(intptr_t*)b;
286
        *(intptr_t*)b = t;
287
}
288
 
4536 terminx 289
static inline void swaposdptrs(void)
290
{
291
    swapptr(&_drawosdchar, &drawosdchar);
292
    swapptr(&_drawosdstr, &drawosdstr);
293
    swapptr(&_drawosdcursor, &drawosdcursor);
294
    swapptr(&_getcolumnwidth, &getcolumnwidth);
295
    swapptr(&_getrowheight, &getrowheight);
296
}
297
 
1205 terminx 298
void OSD_SetTextMode(int32_t mode)
891 terminx 299
{
4536 terminx 300
    osd->draw.mode = (mode != 0);
3823 helixhorne 301
 
4536 terminx 302
    if (osd->draw.mode && drawosdchar != _internal_drawosdchar)
303
            swaposdptrs();
304
    else if (!osd->draw.mode && drawosdchar == _internal_drawosdchar)
305
        swaposdptrs();
3823 helixhorne 306
 
307
    if (in3dmode())
891 terminx 308
        OSD_ResizeDisplay(xdim, ydim);
309
}
310
 
1205 terminx 311
static int32_t _internal_osdfunc_exec(const osdfuncparm_t *parm)
821 terminx 312
{
313
    char fn[BMAX_PATH];
314
 
315
    if (parm->numparms != 1) return OSDCMD_SHOWHELP;
316
    Bstrcpy(fn,parm->parms[0]);
317
 
318
    if (OSD_Exec(fn))
319
    {
909 terminx 320
        OSD_Printf(OSD_ERROR "exec: file \"%s\" not found.\n", fn);
821 terminx 321
        return OSDCMD_OK;
322
    }
323
    return OSDCMD_OK;
324
}
325
 
1635 terminx 326
static int32_t _internal_osdfunc_echo(const osdfuncparm_t *parm)
327
{
4660 terminx 328
    OSD_Printf("%s\n", parm->raw + 5);
1635 terminx 329
 
330
    return OSDCMD_OK;
331
}
332
 
333
static int32_t _internal_osdfunc_fileinfo(const osdfuncparm_t *parm)
334
{
4638 terminx 335
    uint32_t crc = 0, length;
1635 terminx 336
    int32_t i,j;
337
    char buf[256];
4387 terminx 338
    void *xxh;
339
    uint32_t xxhash;
340
    int32_t crctime, xxhtime;
1635 terminx 341
 
342
    if (parm->numparms != 1) return OSDCMD_SHOWHELP;
343
 
344
    if ((i = kopen4load((char *)parm->parms[0],0)) < 0)
345
    {
346
        OSD_Printf("fileinfo: File \"%s\" not found.\n", parm->parms[0]);
347
        return OSDCMD_OK;
348
    }
349
 
350
    length = kfilelength(i);
351
 
4387 terminx 352
    crctime = getticks();
1635 terminx 353
    do
354
    {
355
        j = kread(i,buf,256);
4642 terminx 356
        crc = Bcrc32((uint8_t *)buf,j,crc);
1635 terminx 357
    }
358
    while (j == 256);
4387 terminx 359
    crctime = getticks() - crctime;
1635 terminx 360
 
4387 terminx 361
    klseek(i, 0, BSEEK_SET);
362
 
363
    xxhtime = getticks();
364
    xxh = XXH32_init(0x1337);
365
    do
366
    {
367
        j = kread(i, buf, 256);
368
        XXH32_update(xxh, (uint8_t *) buf, j);
369
    }
370
    while (j == 256);
371
    xxhash = XXH32_digest(xxh);
372
    xxhtime = getticks() - xxhtime;
373
 
1635 terminx 374
    kclose(i);
375
 
376
    OSD_Printf("fileinfo: %s\n"
1762 terminx 377
               "  File size: %d\n"
4387 terminx 378
               "  CRC-32:    %08X (%g sec)\n"
379
               "  xxHash:    %08X (%g sec)\n",
380
               parm->parms[0], length,
381
               crc, (double)crctime/gettimerfreq(),
382
               xxhash, (double)xxhtime/gettimerfreq());
1635 terminx 383
 
384
    return OSDCMD_OK;
385
}
386
 
1205 terminx 387
static void _internal_drawosdchar(int32_t x, int32_t y, char ch, int32_t shade, int32_t pal)
5 Plagman 388
{
109 terminx 389
    char st[2] = { 0,0 };
5 Plagman 390
 
655 terminx 391
    UNREFERENCED_PARAMETER(shade);
392
    UNREFERENCED_PARAMETER(pal);
393
 
109 terminx 394
    st[0] = ch;
5 Plagman 395
 
109 terminx 396
    printext256(4+(x<<3),4+(y<<3), white, -1, st, 0);
5 Plagman 397
}
398
 
3321 helixhorne 399
static void _internal_drawosdstr(int32_t x, int32_t y, const char *ch, int32_t len, int32_t shade, int32_t pal)
5 Plagman 400
{
109 terminx 401
    char st[1024];
5 Plagman 402
 
655 terminx 403
    UNREFERENCED_PARAMETER(shade);
404
 
109 terminx 405
    if (len>1023) len=1023;
1425 terminx 406
    Bmemcpy(st,ch,len);
109 terminx 407
    st[len]=0;
5 Plagman 408
 
4137 helixhorne 409
    OSD_GetShadePal(ch, &shade, &pal);
410
 
411
    {
412
        int32_t colidx = white >= 0 ? palookup[(uint8_t)pal][white] : white;
413
        printext256(4+(x<<3),4+(y<<3), colidx, -1, st, 0);
414
    }
5 Plagman 415
}
416
 
1205 terminx 417
static void _internal_drawosdcursor(int32_t x, int32_t y, int32_t type, int32_t lastkeypress)
5 Plagman 418
{
109 terminx 419
    char st[2] = { '_',0 };
5 Plagman 420
 
655 terminx 421
    UNREFERENCED_PARAMETER(lastkeypress);
422
 
109 terminx 423
    if (type) st[0] = '#';
5 Plagman 424
 
1625 terminx 425
    if (white > -1)
584 terminx 426
    {
1625 terminx 427
        printext256(4+(x<<3),4+(y<<3)+2, white, -1, st, 0);
428
        return;
429
    }
430
 
431
    {
4137 helixhorne 432
        int32_t i, k;
433
        // Find the palette index closest to Duke3D's brightest blue
434
        // "foreground" color.  (Index 79, or the last column of the 5th row,
435
        // if the palette is laid out in a 16x16 pattern.)
436
        k = INT32_MAX;
1229 terminx 437
        for (i=0; i<256; i++)
109 terminx 438
        {
4137 helixhorne 439
            int32_t j =
440
                klabs(curpalette[i].r - 4*47) +
441
                klabs(curpalette[i].g - 4*55) +
442
                klabs(curpalette[i].b - 4*63);
443
            if (j < k) { k = j; white = i; }
109 terminx 444
        }
445
    }
5 Plagman 446
 
447
}
448
 
1205 terminx 449
static int32_t _internal_getcolumnwidth(int32_t w)
5 Plagman 450
{
109 terminx 451
    return w/8 - 1;
5 Plagman 452
}
453
 
1205 terminx 454
static int32_t _internal_getrowheight(int32_t w)
5 Plagman 455
{
109 terminx 456
    return w/8;
5 Plagman 457
}
458
 
1205 terminx 459
static void _internal_clearbackground(int32_t cols, int32_t rows)
5 Plagman 460
{
655 terminx 461
    UNREFERENCED_PARAMETER(cols);
462
    UNREFERENCED_PARAMETER(rows);
5 Plagman 463
}
464
 
1205 terminx 465
static int32_t _internal_gettime(void)
5 Plagman 466
{
109 terminx 467
    return 0;
5 Plagman 468
}
469
 
1205 terminx 470
static void _internal_onshowosd(int32_t a)
5 Plagman 471
{
655 terminx 472
    UNREFERENCED_PARAMETER(a);
5 Plagman 473
}
474
 
475
////////////////////////////
476
 
1205 terminx 477
static int32_t _internal_osdfunc_alias(const osdfuncparm_t *parm)
817 terminx 478
{
479
    symbol_t *i;
480
 
481
    if (parm->numparms < 1)
482
    {
1205 terminx 483
        int32_t j = 0;
817 terminx 484
        OSD_Printf("Alias listing:\n");
485
        for (i=symbols; i!=NULL; i=i->next)
1625 terminx 486
            if (i->func == OSD_ALIAS)
833 terminx 487
            {
488
                j++;
821 terminx 489
                OSD_Printf("     %s \"%s\"\n", i->name, i->help);
833 terminx 490
            }
491
        if (j == 0)
492
            OSD_Printf("No aliases found.\n");
817 terminx 493
        return OSDCMD_OK;
494
    }
495
 
818 terminx 496
    for (i=symbols; i!=NULL; i=i->next)
817 terminx 497
    {
819 terminx 498
        if (!Bstrcasecmp(parm->parms[0],i->name))
818 terminx 499
        {
819 terminx 500
            if (parm->numparms < 2)
818 terminx 501
            {
1625 terminx 502
                if (i->func == OSD_ALIAS)
818 terminx 503
                    OSD_Printf("alias %s \"%s\"\n", i->name, i->help);
504
                else OSD_Printf("%s is a function, not an alias\n",i->name);
819 terminx 505
                return OSDCMD_OK;
818 terminx 506
            }
1857 terminx 507
 
1625 terminx 508
            if (i->func != OSD_ALIAS && i->func != OSD_UNALIASED)
819 terminx 509
            {
510
                OSD_Printf("Cannot override function \"%s\" with alias\n",i->name);
511
                return OSDCMD_OK;
512
            }
818 terminx 513
        }
817 terminx 514
    }
515
 
4491 helixhorne 516
    OSD_RegisterFunction(Xstrdup(parm->parms[0]), Xstrdup(parm->parms[1]), OSD_ALIAS);
4536 terminx 517
 
518
    if (!osd->execdepth)
821 terminx 519
        OSD_Printf("%s\n",parm->raw);
4536 terminx 520
 
817 terminx 521
    return OSDCMD_OK;
522
}
523
 
1205 terminx 524
static int32_t _internal_osdfunc_unalias(const osdfuncparm_t *parm)
820 terminx 525
{
526
    symbol_t *i;
527
 
528
    if (parm->numparms < 1)
529
        return OSDCMD_SHOWHELP;
530
 
531
    for (i=symbols; i!=NULL; i=i->next)
532
    {
533
        if (!Bstrcasecmp(parm->parms[0],i->name))
534
        {
535
            if (parm->numparms < 2)
536
            {
1625 terminx 537
                if (i->func == OSD_ALIAS)
820 terminx 538
                {
821 terminx 539
                    OSD_Printf("Removed alias %s (\"%s\")\n", i->name, i->help);
1625 terminx 540
                    i->func = OSD_UNALIASED;
820 terminx 541
                }
542
                else OSD_Printf("Invalid alias %s\n",i->name);
543
                return OSDCMD_OK;
544
            }
545
        }
546
    }
547
    OSD_Printf("Invalid alias %s\n",parm->parms[0]);
548
    return OSDCMD_OK;
549
}
550
 
1205 terminx 551
static int32_t _internal_osdfunc_listsymbols(const osdfuncparm_t *parm)
5 Plagman 552
{
109 terminx 553
    symbol_t *i;
1205 terminx 554
    int32_t maxwidth = 0;
5 Plagman 555
 
3990 terminx 556
    if (parm->numparms > 1)
557
        return OSDCMD_SHOWHELP;
655 terminx 558
 
109 terminx 559
    for (i=symbols; i!=NULL; i=i->next)
1625 terminx 560
        if (i->func != OSD_UNALIASED)
821 terminx 561
            maxwidth = max((unsigned)maxwidth,Bstrlen(i->name));
109 terminx 562
 
821 terminx 563
    if (maxwidth > 0)
564
    {
1205 terminx 565
        int32_t x = 0, count = 0;
821 terminx 566
        maxwidth += 3;
3990 terminx 567
 
568
        if (parm->numparms > 0)
569
            OSD_Printf(OSDTEXT_RED "Symbol listing for %s:\n", parm->parms[0]);
570
        else
571
            OSD_Printf(OSDTEXT_RED "Symbol listing:\n");
572
 
821 terminx 573
        for (i=symbols; i!=NULL; i=i->next)
574
        {
3990 terminx 575
            if (i->func == OSD_UNALIASED || (parm->numparms == 1 && Bstrncmp(parm->parms[0], i->name, Bstrlen(parm->parms[0]))))
1857 terminx 576
                continue;
577
 
821 terminx 578
            {
1657 terminx 579
                int32_t j = hash_find(&h_cvars, i->name);
580
 
4536 terminx 581
                if (j != -1 && OSD_CvarModified(&osd->cvars[j]))
1657 terminx 582
                {
583
                    OSD_Printf(OSDTEXT_RED "*");
584
                    OSD_Printf("%-*s",maxwidth-1,i->name);
585
                }
586
                else OSD_Printf("%-*s",maxwidth,i->name);
587
 
821 terminx 588
                x += maxwidth;
922 terminx 589
                count++;
821 terminx 590
            }
1857 terminx 591
 
4536 terminx 592
            if (x > osd->draw.cols - maxwidth)
821 terminx 593
            {
594
                x = 0;
595
                OSD_Printf("\n");
596
            }
597
        }
922 terminx 598
        if (x) OSD_Printf("\n");
599
        OSD_Printf(OSDTEXT_RED "Found %d symbols\n",count);
821 terminx 600
    }
109 terminx 601
    return OSDCMD_OK;
5 Plagman 602
}
603
 
1205 terminx 604
static int32_t _internal_osdfunc_help(const osdfuncparm_t *parm)
5 Plagman 605
{
109 terminx 606
    symbol_t *symb;
5 Plagman 607
 
4536 terminx 608
    if (parm->numparms != 1)
609
        return OSDCMD_SHOWHELP;
610
 
109 terminx 611
    symb = findexactsymbol(parm->parms[0]);
4536 terminx 612
 
584 terminx 613
    if (!symb)
1762 terminx 614
        OSD_Printf("Error: no help for undefined symbol \"%s\"\n", parm->parms[0]);
584 terminx 615
    else
109 terminx 616
        OSD_Printf("%s\n", symb->help);
617
 
618
    return OSDCMD_OK;
5 Plagman 619
}
620
 
1205 terminx 621
static int32_t _internal_osdfunc_clear(const osdfuncparm_t *parm)
443 terminx 622
{
4536 terminx 623
    osdtext_t *t = &osd->text;
655 terminx 624
    UNREFERENCED_PARAMETER(parm);
4536 terminx 625
 
626
    Bmemset(t->buf, 0, OSDBUFFERSIZE);
627
    Bmemset(t->fmt, osd->draw.textpal + (osd->draw.textshade<<5), OSDBUFFERSIZE);
628
    t->lines = 1;
629
 
443 terminx 630
    return OSDCMD_OK;
631
}
5 Plagman 632
 
1205 terminx 633
static int32_t _internal_osdfunc_history(const osdfuncparm_t *parm)
842 terminx 634
{
1205 terminx 635
    int32_t i, j = 0;
4536 terminx 636
    osdhist_t *h = &osd->history;
842 terminx 637
    UNREFERENCED_PARAMETER(parm);
4536 terminx 638
 
989 terminx 639
    OSD_Printf(OSDTEXT_RED "Command history:\n");
4536 terminx 640
 
641
    for (i=osd->history.maxlines-1; i>=0; i--)
642
        if (h->buf[i])
643
            OSD_Printf("%4d \"%s\"\n", h->total - h->lines + (++j), h->buf[i]);
644
 
842 terminx 645
    return OSDCMD_OK;
646
}
647
 
5 Plagman 648
////////////////////////////
649
 
650
 
651
//
652
// OSD_Cleanup() -- Cleans up the on-screen display
653
//
654
void OSD_Cleanup(void)
655
{
109 terminx 656
    symbol_t *s;
4536 terminx 657
    int32_t i;
5 Plagman 658
 
1625 terminx 659
    hash_free(&h_osd);
660
    hash_free(&h_cvars);
1025 terminx 661
 
584 terminx 662
    for (; symbols; symbols=s)
663
    {
109 terminx 664
        s=symbols->next;
665
        Bfree(symbols);
666
    }
5 Plagman 667
 
4536 terminx 668
    MAYBE_FCLOSE_AND_NULL(osdlog);
669
    DO_FREE_AND_NULL(osd->cvars);
670
    DO_FREE_AND_NULL(osd->editor.buf);
671
    for (i=0; i<OSDMAXHISTORYDEPTH; i++)
672
        DO_FREE_AND_NULL(osd->history.buf[i]);
673
    DO_FREE_AND_NULL(osd->text.buf);
674
    DO_FREE_AND_NULL(osd->text.fmt);
675
    DO_FREE_AND_NULL(osd);
5 Plagman 676
}
677
 
678
 
1357 terminx 679
static int32_t osdcmd_cvar_set_osd(const osdfuncparm_t *parm)
680
{
681
    int32_t r = osdcmd_cvar_set(parm);
682
 
683
    if (r == OSDCMD_OK)
684
    {
685
        if (!Bstrcasecmp(parm->name, "osdrows"))
686
        {
4536 terminx 687
            if (osd->draw.rows > osdmaxrows) osd->draw.rows = osdmaxrows;
688
            if (osdrowscur!=-1) osdrowscur = osd->draw.rows;
1357 terminx 689
            return r;
690
        }
691
        else if (!Bstrcasecmp(parm->name, "osdtextmode"))
692
        {
4536 terminx 693
            OSD_SetTextMode(osd->draw.mode);
1357 terminx 694
            return r;
695
        }
4536 terminx 696
        else if (!Bstrcasecmp(parm->name, "osdhistorydepth"))
697
        {
698
            int32_t i;
699
 
700
            for (i=OSDMAXHISTORYDEPTH-1; i>=osd->history.maxlines; i--)
701
                DO_FREE_AND_NULL(osd->history.buf[i]);
702
 
703
            return r;
704
        }
1357 terminx 705
    }
706
    return r;
707
}
708
 
1657 terminx 709
static int32_t _internal_osdfunc_toggle(const osdfuncparm_t *parm)
710
{
711
    int32_t i;
712
 
713
    if (parm->numparms != 1) return OSDCMD_SHOWHELP;
714
 
715
    i = hash_find(&h_cvars, parm->parms[0]);
716
 
717
    if (i == -1)
4536 terminx 718
        for (i = osd->numcvars-1; i >= 0; i--)
719
            if (!Bstrcasecmp(parm->parms[0], osd->cvars[i].c.name)) break;
1657 terminx 720
 
4536 terminx 721
    if (i == -1 || (osd->cvars[i].c.type & CVAR_BOOL) != CVAR_BOOL)
1657 terminx 722
    {
723
        OSD_Printf("Bad cvar name or cvar not boolean\n");
724
        return OSDCMD_OK;
725
    }
726
 
4536 terminx 727
    *(int32_t *)osd->cvars[i].c.vptr = 1 - *(int32_t *)osd->cvars[i].c.vptr;
1657 terminx 728
    return OSDCMD_OK;
729
}
730
 
5 Plagman 731
//
627 terminx 732
// OSD_Init() -- Initializes the on-screen display
5 Plagman 733
//
734
void OSD_Init(void)
735
{
1357 terminx 736
    uint32_t i;
737
 
4536 terminx 738
    osd = (osdmain_t *)Bcalloc(1, sizeof(osdmain_t));
1658 terminx 739
 
4536 terminx 740
    mutex_init(&osd->mutex);
1025 terminx 741
 
4536 terminx 742
    if (!osd->keycode) osd->keycode = sc_Tilde;
1025 terminx 743
 
4536 terminx 744
    osd->text.buf = (char *) Bmalloc(OSDBUFFERSIZE);
745
    osd->text.fmt = (char *) Bmalloc(OSDBUFFERSIZE);
746
    osd->editor.buf = (char *) Bmalloc(OSDEDITLENGTH);
747
    osd->editor.tmp = (char *) Bmalloc(OSDEDITLENGTH);
748
 
749
    Bmemset(osd->text.buf, asc_Space, OSDBUFFERSIZE);
750
    Bmemset(osd->text.fmt, osd->draw.textpal + (osd->draw.textshade<<5), OSDBUFFERSIZE);
751
    Bmemset(osd->symbptrs, 0, sizeof(osd->symbptrs));
752
 
753
    osd->numsymbols = osd->numcvars = 0;
754
    osd->text.lines = 1;
755
    osd->text.maxlines = OSDDEFAULTMAXLINES; // overwritten later
756
    osd->draw.rows = OSDDEFAULTROWS;
757
    osd->draw.cols = OSDDEFAULTCOLS;
758
    osd->log.cutoff = OSDLOGCUTOFF;
759
    osd->history.maxlines = OSDMINHISTORYDEPTH;
760
 
1625 terminx 761
    hash_init(&h_osd);
762
    hash_init(&h_cvars);
1025 terminx 763
 
1357 terminx 764
    {
4536 terminx 765
        cvar_t cvars_osd [] =
766
        {
767
            { "osdeditpal", "sets the palette of the OSD input text", (void *) &osd->draw.editpal, CVAR_INT, 0, MAXPALOOKUPS-1 },
768
            { "osdpromptpal", "sets the palette of the OSD prompt", (void *) &osd->draw.promptpal, CVAR_INT, 0, MAXPALOOKUPS-1 },
769
            { "osdtextpal", "sets the palette of the OSD text", (void *) &osd->draw.textpal, CVAR_INT, 0, MAXPALOOKUPS-1 },
770
            { "osdeditshade", "sets the shade of the OSD input text", (void *) &osd->draw.editshade, CVAR_INT, 0, 7 },
771
            { "osdtextshade", "sets the shade of the OSD text", (void *) &osd->draw.textshade, CVAR_INT, 0, 7 },
772
            { "osdpromptshade", "sets the shade of the OSD prompt", (void *) &osd->draw.promptshade, CVAR_INT, INT8_MIN, INT8_MAX },
773
            { "osdrows", "sets the number of visible lines of the OSD", (void *) &osd->draw.rows, CVAR_INT|CVAR_FUNCPTR, 1, MAXPALOOKUPS-1 },
774
            { "osdtextmode", "set OSD text mode (0:graphical, 1:fast)", (void *) &osd->draw.mode, CVAR_BOOL|CVAR_FUNCPTR, 0, 1 },
775
            { "osdlogcutoff", "sets the maximal line count of the log file", (void *) &osd->log.cutoff, CVAR_INT, 0, 262144 },
776
            { "osdhistorydepth", "sets the history depth, in lines", (void *) &osd->history.maxlines, CVAR_INT|CVAR_FUNCPTR, OSDMINHISTORYDEPTH, OSDMAXHISTORYDEPTH },
777
        };
1625 terminx 778
 
4536 terminx 779
        for (i=0; i<ARRAY_SIZE(cvars_osd); i++)
780
        {
781
            if (OSD_RegisterCvar(&cvars_osd[i]))
782
                continue;
783
 
784
            OSD_RegisterFunction(cvars_osd[i].name, cvars_osd[i].desc,
785
                cvars_osd[i].type & CVAR_FUNCPTR ? osdcmd_cvar_set_osd : osdcmd_cvar_set);
786
        }
1357 terminx 787
    }
5 Plagman 788
 
847 terminx 789
    OSD_RegisterFunction("alias","alias: creates an alias for calling multiple commands",_internal_osdfunc_alias);
790
    OSD_RegisterFunction("clear","clear: clears the console text buffer",_internal_osdfunc_clear);
1635 terminx 791
    OSD_RegisterFunction("echo","echo [text]: echoes text to the console", _internal_osdfunc_echo);
847 terminx 792
    OSD_RegisterFunction("exec","exec <scriptfile>: executes a script", _internal_osdfunc_exec);
1635 terminx 793
    OSD_RegisterFunction("fileinfo","fileinfo <file>: gets a file's information", _internal_osdfunc_fileinfo);
847 terminx 794
    OSD_RegisterFunction("help","help: displays help for the specified cvar or command; \"listsymbols\" to show all commands",_internal_osdfunc_help);
795
    OSD_RegisterFunction("history","history: displays the console command history",_internal_osdfunc_history);
1635 terminx 796
    OSD_RegisterFunction("listsymbols","listsymbols: lists all registered functions, cvars and aliases",_internal_osdfunc_listsymbols);
1657 terminx 797
    OSD_RegisterFunction("toggle","toggle: toggles the value of a boolean cvar",_internal_osdfunc_toggle);
1625 terminx 798
    OSD_RegisterFunction("unalias","unalias: removes a command alias",_internal_osdfunc_unalias);
5 Plagman 799
 
4536 terminx 800
//    atexit(OSD_Cleanup);
5 Plagman 801
}
802
 
803
 
804
//
805
// OSD_SetLogFile() -- Sets the text file where printed text should be echoed
806
//
2796 helixhorne 807
void OSD_SetLogFile(const char *fn)
5 Plagman 808
{
4660 terminx 809
#ifdef DEBUGGINGAIDS
810
    const int bufmode = _IONBF;
811
#else
812
    const int bufmode = _IOLBF;
813
#endif
814
 
4718 terminx 815
    MAYBE_FCLOSE_AND_NULL(osdlog);
4821 hendricks2 816
    osdlogfn = NULL;
1762 terminx 817
 
4718 terminx 818
    if (!fn)
819
        return;
4660 terminx 820
 
4718 terminx 821
    osdlog = Bfopen(fn, "w");
822
 
4660 terminx 823
    if (osdlog)
4821 hendricks2 824
    {
4718 terminx 825
        setvbuf(osdlog, (char *)NULL, bufmode, BUFSIZ);
4821 hendricks2 826
        osdlogfn = fn;
827
    }
5 Plagman 828
}
829
 
830
 
831
//
832
// OSD_SetFunctions() -- Sets some callbacks which the OSD uses to understand its world
833
//
834
void OSD_SetFunctions(
1205 terminx 835
    void (*drawchar)(int32_t,int32_t,char,int32_t,int32_t),
3321 helixhorne 836
    void (*drawstr)(int32_t,int32_t,const char *,int32_t,int32_t,int32_t),
1205 terminx 837
    void (*drawcursor)(int32_t,int32_t,int32_t,int32_t),
838
    int32_t (*colwidth)(int32_t),
839
    int32_t (*rowheight)(int32_t),
840
    void (*clearbg)(int32_t,int32_t),
841
    int32_t (*gtime)(void),
842
    void (*showosd)(int32_t)
109 terminx 843
)
5 Plagman 844
{
4536 terminx 845
    drawosdchar = drawchar ? drawchar : _internal_drawosdchar;
846
    drawosdstr = drawstr ? drawstr : _internal_drawosdstr;
847
    drawosdcursor = drawcursor ? drawcursor : _internal_drawosdcursor;
848
    getcolumnwidth = colwidth ? colwidth : _internal_getcolumnwidth;
849
    getrowheight = rowheight ? rowheight : _internal_getrowheight;
850
    clearbackground = clearbg ? clearbg : _internal_clearbackground;
851
    gettime = gtime ? gtime : _internal_gettime;
852
    onshowosd = showosd ? showosd : _internal_onshowosd;
5 Plagman 853
}
854
 
855
 
856
//
857
// OSD_SetParameters() -- Sets the parameters for presenting the text
858
//
859
void OSD_SetParameters(
1205 terminx 860
    int32_t promptshade, int32_t promptpal,
861
    int32_t editshade, int32_t editpal,
862
    int32_t textshade, int32_t textpal
109 terminx 863
)
5 Plagman 864
{
4536 terminx 865
    osd->draw.promptshade = promptshade;
866
    osd->draw.promptpal   = promptpal;
867
    osd->draw.editshade   = editshade;
868
    osd->draw.editpal     = editpal;
869
    osd->draw.textshade   = textshade;
870
    osd->draw.textpal     = textpal;
5 Plagman 871
}
872
 
873
 
874
//
875
// OSD_CaptureKey() -- Sets the scancode for the key which activates the onscreen display
876
//
1205 terminx 877
void OSD_CaptureKey(int32_t sc)
5 Plagman 878
{
4536 terminx 879
    osd->keycode = sc;
5 Plagman 880
}
881
 
882
//
828 terminx 883
// OSD_FindDiffPoint() -- Finds the length of the longest common prefix of 2 strings, stolen from ZDoom
884
//
1205 terminx 885
static int32_t OSD_FindDiffPoint(const char *str1, const char *str2)
830 terminx 886
{
1205 terminx 887
    int32_t i;
830 terminx 888
 
889
    for (i = 0; Btolower(str1[i]) == Btolower(str2[i]); i++)
890
        if (str1[i] == 0 || str2[i] == 0)
891
            break;
892
 
893
    return i;
894
}
895
 
845 terminx 896
static void OSD_HistoryPrev(void)
897
{
4536 terminx 898
    if (osd->history.pos >= osd->history.lines-1) return;
847 terminx 899
 
4536 terminx 900
    Bmemcpy(osd->editor.buf, osd->history.buf[++osd->history.pos], OSDEDITLENGTH);
1625 terminx 901
 
4536 terminx 902
    osd->editor.pos = 0;
903
    while (osd->editor.buf[osd->editor.pos]) osd->editor.pos++;
904
    osd->editor.len = osd->editor.pos;
1625 terminx 905
 
4536 terminx 906
    if (osd->editor.pos<osd->editor.start)
845 terminx 907
    {
4536 terminx 908
        osd->editor.end = osd->editor.pos;
909
        osd->editor.start = osd->editor.end-editlinewidth;
845 terminx 910
 
4536 terminx 911
        if (osd->editor.start<0)
1625 terminx 912
        {
4536 terminx 913
            osd->editor.end-=osd->editor.start;
914
            osd->editor.start=0;
1625 terminx 915
        }
845 terminx 916
    }
4536 terminx 917
    else if (osd->editor.pos>=osd->editor.end)
1625 terminx 918
    {
4536 terminx 919
        osd->editor.start+=(osd->editor.pos-osd->editor.end);
920
        osd->editor.end+=(osd->editor.pos-osd->editor.end);
1625 terminx 921
    }
845 terminx 922
}
923
 
924
static void OSD_HistoryNext(void)
925
{
4536 terminx 926
    if (osd->history.pos < 0) return;
847 terminx 927
 
4536 terminx 928
    if (osd->history.pos == 0)
845 terminx 929
    {
4536 terminx 930
        osd->editor.len=0;
931
        osd->editor.pos=0;
932
        osd->editor.start=0;
933
        osd->editor.end=editlinewidth;
934
        osd->history.pos = -1;
847 terminx 935
        return;
936
    }
937
 
4536 terminx 938
    Bmemcpy(osd->editor.buf, osd->history.buf[--osd->history.pos], OSDEDITLENGTH);
1625 terminx 939
 
4536 terminx 940
    osd->editor.pos = 0;
941
    while (osd->editor.buf[osd->editor.pos]) osd->editor.pos++;
942
    osd->editor.len = osd->editor.pos;
1625 terminx 943
 
4536 terminx 944
    if (osd->editor.pos<osd->editor.start)
847 terminx 945
    {
4536 terminx 946
        osd->editor.end = osd->editor.pos;
947
        osd->editor.start = osd->editor.end-editlinewidth;
847 terminx 948
 
4536 terminx 949
        if (osd->editor.start<0)
1625 terminx 950
        {
4536 terminx 951
            osd->editor.end-=osd->editor.start;
952
            osd->editor.start=0;
1625 terminx 953
        }
845 terminx 954
    }
4536 terminx 955
    else if (osd->editor.pos>=osd->editor.end)
1625 terminx 956
    {
4536 terminx 957
        osd->editor.start+=(osd->editor.pos-osd->editor.end);
958
        osd->editor.end+=(osd->editor.pos-osd->editor.end);
1625 terminx 959
    }
845 terminx 960
}
961
 
1625 terminx 962
//
963
// OSD_HandleKey() -- Handles keyboard input when capturing input.
964
//  Returns 0 if the key was handled internally, or the scancode if it should
965
//  be passed on to the game.
966
//
967
 
1205 terminx 968
int32_t OSD_HandleChar(char ch)
5 Plagman 969
{
1205 terminx 970
    int32_t i,j;
109 terminx 971
    symbol_t *tabc = NULL;
972
    static symbol_t *lastmatch = NULL;
5 Plagman 973
 
4536 terminx 974
    if (!osd || (osd->flags & OSD_CAPTURE) != OSD_CAPTURE)
1625 terminx 975
        return ch;
5 Plagman 976
 
1625 terminx 977
    if (ch != 9)    // tab
978
        lastmatch = NULL;
979
 
980
    switch (ch)
584 terminx 981
    {
1625 terminx 982
    case 1:    // control a. jump to beginning of line
4536 terminx 983
        osd->editor.pos=0;
984
        osd->editor.start=0;
985
        osd->editor.end=editlinewidth;
1625 terminx 986
        return 0;
987
    case 2:   // control b, move one character left
4536 terminx 988
        if (osd->editor.pos > 0) osd->editor.pos--;
1625 terminx 989
        return 0;
990
    case 3:   // control c
4536 terminx 991
        osd->editor.buf[osd->editor.len] = 0;
992
        OSD_Printf("%s\n",osd->editor.buf);
993
        osd->editor.len=0;
994
        osd->editor.pos=0;
995
        osd->editor.start=0;
996
        osd->editor.end=editlinewidth;
997
        osd->editor.buf[0] = 0;
1625 terminx 998
        return 0;
999
    case 5:   // control e, jump to end of line
4536 terminx 1000
        osd->editor.pos = osd->editor.len;
1001
        osd->editor.end = osd->editor.pos;
1002
        osd->editor.start = osd->editor.end-editlinewidth;
1003
        if (osd->editor.start<0)
845 terminx 1004
        {
4536 terminx 1005
            osd->editor.start=0;
1006
            osd->editor.end = editlinewidth;
845 terminx 1007
        }
1625 terminx 1008
        return 0;
1009
    case 6:   // control f, move one character right
4536 terminx 1010
        if (osd->editor.pos < osd->editor.len) osd->editor.pos++;
1625 terminx 1011
        return 0;
1012
    case 8:
1905 helixhorne 1013
#ifdef __APPLE__
1014
    case 127:      // control h, backspace
1015
#endif
4536 terminx 1016
        if (!osd->editor.pos || !osd->editor.len) return 0;
1017
        if ((osd->flags & OSD_OVERTYPE) == 0)
584 terminx 1018
        {
4536 terminx 1019
            if (osd->editor.pos < osd->editor.len)
1020
                Bmemmove(osd->editor.buf+osd->editor.pos-1, osd->editor.buf+osd->editor.pos, osd->editor.len-osd->editor.pos);
1021
            osd->editor.len--;
584 terminx 1022
        }
4536 terminx 1023
        osd->editor.pos--;
1024
        if (osd->editor.pos<osd->editor.start) osd->editor.start--,osd->editor.end--;
1905 helixhorne 1025
#ifndef __APPLE__
1644 helixhorne 1026
    case 127:  // handled in OSD_HandleScanCode (delete)
1905 helixhorne 1027
#endif
1625 terminx 1028
        return 0;
1029
    case 9:   // tab
1762 terminx 1030
    {
1031
        int32_t commonsize = 512;
1032
 
1033
        if (!lastmatch)
584 terminx 1034
        {
4536 terminx 1035
            for (i=osd->editor.pos; i>0; i--) if (osd->editor.buf[i-1] == ' ') break;
4963 helixhorne 1036
            for (j=0; i < osd->editor.len && osd->editor.buf[i] != ' '; j++,i++)
4536 terminx 1037
                osd->editor.tmp[j] = osd->editor.buf[i];
1038
            osd->editor.tmp[j] = 0;
828 terminx 1039
 
1762 terminx 1040
            if (j > 0)
584 terminx 1041
            {
4536 terminx 1042
                tabc = findsymbol(osd->editor.tmp, NULL);
5 Plagman 1043
 
4536 terminx 1044
                if (tabc && tabc->next && findsymbol(osd->editor.tmp, tabc->next))
401 terminx 1045
                {
1762 terminx 1046
                    symbol_t *symb=tabc;
1047
                    int32_t maxwidth = 0, x = 0, num = 0, diffpt;
847 terminx 1048
 
1762 terminx 1049
                    while (symb && symb != lastmatch)
401 terminx 1050
                    {
1762 terminx 1051
                        num++;
401 terminx 1052
 
1762 terminx 1053
                        if (lastmatch)
847 terminx 1054
                        {
1762 terminx 1055
                            diffpt = OSD_FindDiffPoint(symb->name,lastmatch->name);
1056
                            if (diffpt < commonsize)
1057
                                commonsize = diffpt;
1058
                        }
1625 terminx 1059
 
1762 terminx 1060
                        maxwidth = max((unsigned)maxwidth,Bstrlen(symb->name));
1061
                        lastmatch = symb;
1062
                        if (!lastmatch->next) break;
4536 terminx 1063
                        symb=findsymbol(osd->editor.tmp, lastmatch->next);
1762 terminx 1064
                    }
4536 terminx 1065
                    OSD_Printf(OSDTEXT_RED "Found %d possible completions for \"%s\":\n",num,osd->editor.tmp);
1762 terminx 1066
                    maxwidth += 3;
1067
                    symb = tabc;
1068
                    OSD_Printf("  ");
1069
                    while (symb && (symb != lastmatch))
1070
                    {
1071
                        tabc = lastmatch = symb;
1072
                        OSD_Printf("%-*s",maxwidth,symb->name);
1073
                        if (!lastmatch->next) break;
4536 terminx 1074
                        symb=findsymbol(osd->editor.tmp, lastmatch->next);
1762 terminx 1075
                        x += maxwidth;
4536 terminx 1076
                        if (x > (osd->draw.cols - maxwidth))
847 terminx 1077
                        {
1762 terminx 1078
                            x = 0;
1079
                            OSD_Printf("\n");
1080
                            if (symb && (symb != lastmatch))
1081
                                OSD_Printf("  ");
847 terminx 1082
                        }
1083
                    }
1762 terminx 1084
                    if (x) OSD_Printf("\n");
1085
                    OSD_Printf(OSDTEXT_RED "Press TAB again to cycle through matches\n");
401 terminx 1086
                }
584 terminx 1087
            }
1762 terminx 1088
        }
1089
        else
1090
        {
4536 terminx 1091
            tabc = findsymbol(osd->editor.tmp, lastmatch->next);
1762 terminx 1092
            if (!tabc && lastmatch)
4536 terminx 1093
                tabc = findsymbol(osd->editor.tmp, NULL);    // wrap */
1762 terminx 1094
        }
1095
 
1096
        if (tabc)
1097
        {
4536 terminx 1098
            for (i=osd->editor.pos; i>0; i--) if (osd->editor.buf[i-1] == ' ') break;
1099
            osd->editor.len = i;
1100
            for (j=0; tabc->name[j] && osd->editor.len <= OSDEDITLENGTH-1
1101
                    && (osd->editor.len < commonsize); i++,j++,osd->editor.len++)
1102
                osd->editor.buf[i] = tabc->name[j];
1103
            osd->editor.pos = osd->editor.len;
1104
            osd->editor.end = osd->editor.pos;
1105
            osd->editor.start = osd->editor.end-editlinewidth;
1106
            if (osd->editor.start<0)
1625 terminx 1107
            {
4536 terminx 1108
                osd->editor.start=0;
1109
                osd->editor.end = editlinewidth;
1625 terminx 1110
            }
838 terminx 1111
 
1762 terminx 1112
            lastmatch = tabc;
584 terminx 1113
        }
1762 terminx 1114
    }
1115
    return 0;
1625 terminx 1116
    case 11:      // control k, delete all to end of line
4536 terminx 1117
        Bmemset(osd->editor.buf + osd->editor.pos, 0, OSDBUFFERSIZE - osd->editor.pos);
1625 terminx 1118
        return 0;
1119
    case 12:      // control l, clear screen
4536 terminx 1120
        Bmemset(osd->text.buf, 0, OSDBUFFERSIZE);
1121
        Bmemset(osd->text.fmt, osd->draw.textpal + (osd->draw.textshade<<5), OSDBUFFERSIZE);
1122
        osd->text.lines = 1;
1625 terminx 1123
        return 0;
1124
    case 13:      // control m, enter
4536 terminx 1125
        if (osd->editor.len>0)
584 terminx 1126
        {
4536 terminx 1127
            osd->editor.buf[osd->editor.len] = 0;
1128
            if (!osd->history.buf[0] || Bstrcmp(osd->history.buf[0], osd->editor.buf))
842 terminx 1129
            {
4536 terminx 1130
                DO_FREE_AND_NULL(osd->history.buf[osd->history.maxlines-1]);
1131
 
1132
                Bmemmove(&osd->history.buf[1], &osd->history.buf[0], sizeof(intptr_t) * osd->history.maxlines-1);
1133
 
4725 helixhorne 1134
                OSD_SetHistory(0, osd->editor.buf);
4536 terminx 1135
 
1136
                if (osd->history.lines < osd->history.maxlines)
1137
                    osd->history.lines++;
1138
 
1139
                osd->history.total++;
1140
 
1141
                if (osd->history.exec == osd->history.maxlines)
842 terminx 1142
                    OSD_Printf("Command Buffer Warning: Failed queueing command "
4536 terminx 1143
                               "for execution. Buffer full. Consider increasing \"osdhistorydepth\".\n");
842 terminx 1144
                else
4536 terminx 1145
                    osd->history.exec++;
842 terminx 1146
            }
838 terminx 1147
            else
842 terminx 1148
            {
4536 terminx 1149
                if (osd->history.exec == osd->history.maxlines)
842 terminx 1150
                    OSD_Printf("Command Buffer Warning: Failed queueing command "
4536 terminx 1151
                               "for execution. Buffer full. Consider increasing \"osdhistorydepth\".\n");
842 terminx 1152
                else
4536 terminx 1153
                    osd->history.exec++;
842 terminx 1154
            }
4536 terminx 1155
            osd->history.pos=-1;
584 terminx 1156
        }
838 terminx 1157
 
4536 terminx 1158
        osd->editor.len=0;
1159
        osd->editor.pos=0;
1160
        osd->editor.start=0;
1161
        osd->editor.end=editlinewidth;
1625 terminx 1162
        return 0;
1163
    case 14:      // control n, next (ie. down arrow)
845 terminx 1164
        OSD_HistoryNext();
1625 terminx 1165
        return 0;
1166
    case 16:      // control p, previous (ie. up arrow)
845 terminx 1167
        OSD_HistoryPrev();
1625 terminx 1168
        return 0;
1169
    case 21:      // control u, delete all to beginning
4536 terminx 1170
        if (osd->editor.pos>0 && osd->editor.len)
584 terminx 1171
        {
4536 terminx 1172
            if (osd->editor.pos<osd->editor.len)
1173
                Bmemmove(osd->editor.buf, osd->editor.buf+osd->editor.pos, osd->editor.len-osd->editor.pos);
1174
            osd->editor.len-=osd->editor.pos;
1175
            osd->editor.pos = 0;
1176
            osd->editor.start = 0;
1177
            osd->editor.end = editlinewidth;
584 terminx 1178
        }
1625 terminx 1179
        return 0;
1180
    case 23:      // control w, delete one word back
4536 terminx 1181
        if (osd->editor.pos>0 && osd->editor.len>0)
584 terminx 1182
        {
4536 terminx 1183
            i=osd->editor.pos;
1184
            while (i>0 && osd->editor.buf[i-1]==asc_Space) i--;
1185
            while (i>0 && osd->editor.buf[i-1]!=asc_Space) i--;
1186
            if (osd->editor.pos<osd->editor.len)
1187
                Bmemmove(osd->editor.buf+i, osd->editor.buf+osd->editor.pos, osd->editor.len-osd->editor.pos);
1188
            osd->editor.len -= (osd->editor.pos-i);
1189
            osd->editor.pos = i;
1190
            if (osd->editor.pos < osd->editor.start)
584 terminx 1191
            {
4536 terminx 1192
                osd->editor.start=osd->editor.pos;
1193
                osd->editor.end=osd->editor.start+editlinewidth;
109 terminx 1194
            }
584 terminx 1195
        }
1625 terminx 1196
        return 0;
1197
    default:
1198
        if (ch >= asc_Space)      // text char
584 terminx 1199
        {
4536 terminx 1200
            if ((osd->flags & OSD_OVERTYPE) == 0)
1625 terminx 1201
            {
4536 terminx 1202
                if (osd->editor.len == OSDEDITLENGTH) // buffer full, can't insert another char
1625 terminx 1203
                    return 0;
4536 terminx 1204
                if (osd->editor.pos < osd->editor.len)
1205
                    Bmemmove(osd->editor.buf+osd->editor.pos+1, osd->editor.buf+osd->editor.pos, osd->editor.len-osd->editor.pos);
1206
                osd->editor.len++;
1625 terminx 1207
            }
4536 terminx 1208
            else if (osd->editor.pos == osd->editor.len)
1209
                osd->editor.len++;
1625 terminx 1210
 
4536 terminx 1211
            osd->editor.buf[osd->editor.pos++] = ch;
1625 terminx 1212
 
4536 terminx 1213
            if (osd->editor.pos > osd->editor.end)
1214
                osd->editor.start++, osd->editor.end++;
109 terminx 1215
        }
1625 terminx 1216
        return 0;
109 terminx 1217
    }
831 terminx 1218
    return 0;
1219
}
109 terminx 1220
 
1205 terminx 1221
int32_t OSD_HandleScanCode(int32_t sc, int32_t press)
831 terminx 1222
{
4536 terminx 1223
    if (!osd)
4269 hendricks2 1224
        return 1;
831 terminx 1225
 
4536 terminx 1226
    if (sc == osd->keycode)
831 terminx 1227
    {
1228
        if (press)
1229
        {
1230
            osdscroll = -osdscroll;
1231
            if (osdrowscur == -1)
1232
                osdscroll = 1;
4536 terminx 1233
            else if (osdrowscur == osd->draw.rows)
831 terminx 1234
                osdscroll = -1;
1235
            osdrowscur += osdscroll;
1236
            OSD_CaptureInput(osdscroll == 1);
1237
            osdscrtime = getticks();
1238
        }
4269 hendricks2 1239
        return -1;
831 terminx 1240
    }
4536 terminx 1241
    else if ((osd->flags & OSD_CAPTURE) == 0)
4269 hendricks2 1242
        return 2;
831 terminx 1243
 
1244
    if (!press)
1245
    {
1625 terminx 1246
        if (sc == sc_LeftShift || sc == sc_RightShift)
4536 terminx 1247
            osd->flags &= ~OSD_SHIFT;
1625 terminx 1248
        if (sc == sc_LeftControl || sc == sc_RightControl)
4536 terminx 1249
            osd->flags &= ~OSD_CTRL;
1625 terminx 1250
        return 0;
831 terminx 1251
    }
1252
 
1253
    keytime = gettime();
1254
 
1625 terminx 1255
    switch (sc)
584 terminx 1256
    {
1625 terminx 1257
    case sc_Escape:
584 terminx 1258
        //        OSD_ShowDisplay(0);
1259
        osdscroll = -1;
1625 terminx 1260
        osdrowscur--;
584 terminx 1261
        OSD_CaptureInput(0);
1262
        osdscrtime = getticks();
1625 terminx 1263
        break;
1264
    case sc_PgUp:
4536 terminx 1265
        if (osd->draw.head < osd->text.lines-1)
1266
            osd->draw.head++;
1625 terminx 1267
        break;
1268
    case sc_PgDn:
4536 terminx 1269
        if (osd->draw.head > 0)
1270
            osd->draw.head--;
1625 terminx 1271
        break;
1272
    case sc_Home:
4536 terminx 1273
        if (osd->flags & OSD_CTRL)
1274
            osd->draw.head = osd->text.lines-1;
584 terminx 1275
        else
1276
        {
4536 terminx 1277
            osd->editor.pos = 0;
1278
            osd->editor.start = osd->editor.pos;
1279
            osd->editor.end = osd->editor.start+editlinewidth;
109 terminx 1280
        }
1625 terminx 1281
        break;
1282
    case sc_End:
4536 terminx 1283
        if (osd->flags & OSD_CTRL)
1284
            osd->draw.head = 0;
584 terminx 1285
        else
1286
        {
4536 terminx 1287
            osd->editor.pos = osd->editor.len;
1288
            osd->editor.end = osd->editor.pos;
1289
            osd->editor.start = osd->editor.end-editlinewidth;
1290
            if (osd->editor.start<0)
584 terminx 1291
            {
4536 terminx 1292
                osd->editor.start=0;
1293
                osd->editor.end = editlinewidth;
109 terminx 1294
            }
1295
        }
1625 terminx 1296
        break;
1297
    case sc_Insert:
4536 terminx 1298
        osd->flags = (osd->flags & ~OSD_OVERTYPE) | (-((osd->flags & OSD_OVERTYPE) == 0) & OSD_OVERTYPE);
1644 helixhorne 1299
        break;
1625 terminx 1300
    case sc_LeftArrow:
4536 terminx 1301
        if (osd->editor.pos>0)
584 terminx 1302
        {
4536 terminx 1303
            if (osd->flags & OSD_CTRL)
584 terminx 1304
            {
4536 terminx 1305
                while (osd->editor.pos>0)
584 terminx 1306
                {
4536 terminx 1307
                    if (osd->editor.buf[osd->editor.pos-1] != asc_Space)
1625 terminx 1308
                        break;
4536 terminx 1309
                    osd->editor.pos--;
109 terminx 1310
                }
4536 terminx 1311
                while (osd->editor.pos>0)
584 terminx 1312
                {
4536 terminx 1313
                    if (osd->editor.buf[osd->editor.pos-1] == asc_Space)
1625 terminx 1314
                        break;
4536 terminx 1315
                    osd->editor.pos--;
109 terminx 1316
                }
584 terminx 1317
            }
4536 terminx 1318
            else osd->editor.pos--;
109 terminx 1319
        }
4536 terminx 1320
        if (osd->editor.pos<osd->editor.start)
1625 terminx 1321
        {
4536 terminx 1322
            osd->editor.end-=(osd->editor.start-osd->editor.pos);
1323
            osd->editor.start-=(osd->editor.start-osd->editor.pos);
1625 terminx 1324
        }
1325
        break;
1326
    case sc_RightArrow:
4536 terminx 1327
        if (osd->editor.pos<osd->editor.len)
584 terminx 1328
        {
4536 terminx 1329
            if (osd->flags & OSD_CTRL)
584 terminx 1330
            {
4536 terminx 1331
                while (osd->editor.pos<osd->editor.len)
584 terminx 1332
                {
4536 terminx 1333
                    if (osd->editor.buf[osd->editor.pos] == asc_Space)
1625 terminx 1334
                        break;
4536 terminx 1335
                    osd->editor.pos++;
109 terminx 1336
                }
4536 terminx 1337
                while (osd->editor.pos<osd->editor.len)
584 terminx 1338
                {
4536 terminx 1339
                    if (osd->editor.buf[osd->editor.pos] != asc_Space)
1625 terminx 1340
                        break;
4536 terminx 1341
                    osd->editor.pos++;
109 terminx 1342
                }
584 terminx 1343
            }
4536 terminx 1344
            else osd->editor.pos++;
109 terminx 1345
        }
4536 terminx 1346
        if (osd->editor.pos>=osd->editor.end)
1625 terminx 1347
        {
4536 terminx 1348
            osd->editor.start+=(osd->editor.pos-osd->editor.end);
1349
            osd->editor.end+=(osd->editor.pos-osd->editor.end);
1625 terminx 1350
        }
1351
        break;
1352
    case sc_UpArrow:
845 terminx 1353
        OSD_HistoryPrev();
1625 terminx 1354
        break;
1355
    case sc_DownArrow:
845 terminx 1356
        OSD_HistoryNext();
1625 terminx 1357
        break;
1358
    case sc_LeftShift:
1359
    case sc_RightShift:
4536 terminx 1360
        osd->flags |= OSD_SHIFT;
1625 terminx 1361
        break;
1362
    case sc_LeftControl:
1363
    case sc_RightControl:
4536 terminx 1364
        osd->flags |= OSD_CTRL;
1625 terminx 1365
        break;
1366
    case sc_CapsLock:
4536 terminx 1367
        osd->flags = (osd->flags & ~OSD_CAPS) | (-((osd->flags & OSD_CAPS) == 0) & OSD_CAPS);
1625 terminx 1368
        break;
1369
    case sc_Delete:
4536 terminx 1370
        if (osd->editor.pos == osd->editor.len || !osd->editor.len)
1625 terminx 1371
            return 0;
4536 terminx 1372
        if (osd->editor.pos <= osd->editor.len-1)
1373
            Bmemmove(osd->editor.buf+osd->editor.pos, osd->editor.buf+osd->editor.pos+1, osd->editor.len-osd->editor.pos-1);
1374
        osd->editor.len--;
1625 terminx 1375
        break;
109 terminx 1376
    }
1377
    return 0;
5 Plagman 1378
}
1379
 
1380
 
1381
//
1382
// OSD_ResizeDisplay() -- Handles readjustment of the display when the screen resolution
1007 hnt_ts 1383
//  changes on us.
5 Plagman 1384
//
1205 terminx 1385
void OSD_ResizeDisplay(int32_t w, int32_t h)
5 Plagman 1386
{
4536 terminx 1387
    int32_t newcols, newmaxlines;
1388
    char *newtext, *newfmt;
1205 terminx 1389
    int32_t i,j,k;
5 Plagman 1390
 
109 terminx 1391
    newcols = getcolumnwidth(w);
4536 terminx 1392
    newmaxlines = OSDBUFFERSIZE / newcols;
5 Plagman 1393
 
4536 terminx 1394
    j = min(newmaxlines, osd->text.maxlines);
1395
    k = min(newcols, osd->draw.cols);
5 Plagman 1396
 
4536 terminx 1397
    newtext = (char *)Bmalloc(OSDBUFFERSIZE);
1398
    newfmt = (char *)Bmalloc(OSDBUFFERSIZE);
1399
 
1400
    Bmemset(newtext, asc_Space, OSDBUFFERSIZE);
1401
 
1229 terminx 1402
    for (i=j-1; i>=0; i--)
584 terminx 1403
    {
4536 terminx 1404
        Bmemcpy(newtext+newcols*i, osd->text.buf+osd->draw.cols*i, k);
1405
        Bmemcpy(newfmt+newcols*i, osd->text.fmt+osd->draw.cols*i, k);
109 terminx 1406
    }
5 Plagman 1407
 
4536 terminx 1408
    Bfree(osd->text.buf);
1409
    osd->text.buf = newtext;
1410
 
1411
    Bfree(osd->text.fmt);
1412
    osd->text.fmt = newfmt;
1413
 
1414
    osd->text.maxlines = newmaxlines;
1415
 
1416
    osd->draw.cols = newcols;
109 terminx 1417
    osdmaxrows = getrowheight(h)-2;
1418
 
4536 terminx 1419
    if (osd->draw.rows > osdmaxrows) osd->draw.rows = osdmaxrows;
109 terminx 1420
 
4536 terminx 1421
    osd->text.pos = 0;
1422
    osd->draw.head = 0;
1423
    osd->editor.start = 0;
1424
    osd->editor.end = editlinewidth;
109 terminx 1425
    white = -1;
5 Plagman 1426
}
1427
 
1428
 
1429
//
402 terminx 1430
// OSD_CaptureInput()
5 Plagman 1431
//
1205 terminx 1432
void OSD_CaptureInput(int32_t cap)
5 Plagman 1433
{
4536 terminx 1434
    osd->flags = (osd->flags & ~(OSD_CAPTURE|OSD_CTRL|OSD_SHIFT)) | (-cap & OSD_CAPTURE);
5 Plagman 1435
 
4738 hendricks2 1436
    grabmouse(cap == 0 ? AppMouseGrab : 0);
1625 terminx 1437
    onshowosd(cap);
1438
 
1439
    if (cap)
1440
        releaseallbuttons();
1441
 
404 terminx 1442
    bflushchars();
5 Plagman 1443
}
1444
 
1625 terminx 1445
 
402 terminx 1446
//
1447
// OSD_ShowDisplay() -- Shows or hides the onscreen display
1448
//
1205 terminx 1449
void OSD_ShowDisplay(int32_t onf)
402 terminx 1450
{
4536 terminx 1451
    osd->flags = (osd->flags & ~OSD_DRAW) | (-onf & OSD_DRAW);
1625 terminx 1452
    OSD_CaptureInput(onf);
402 terminx 1453
}
5 Plagman 1454
 
402 terminx 1455
 
5 Plagman 1456
//
1457
// OSD_Draw() -- Draw the onscreen display
1458
//
441 terminx 1459
 
5 Plagman 1460
void OSD_Draw(void)
1461
{
1399 terminx 1462
    uint32_t topoffs;
1205 terminx 1463
    int32_t row, lines, x, len;
5 Plagman 1464
 
4536 terminx 1465
    if (!osd)
1625 terminx 1466
        return;
5 Plagman 1467
 
404 terminx 1468
    if (osdrowscur == 0)
4536 terminx 1469
        OSD_ShowDisplay(osd->flags & OSD_DRAW ? 0 : 1);
401 terminx 1470
 
4536 terminx 1471
    if (osdrowscur == osd->draw.rows)
401 terminx 1472
        osdscroll = 0;
1473
    else
1474
    {
1205 terminx 1475
        int32_t j;
584 terminx 1476
 
4536 terminx 1477
        if ((osdrowscur < osd->draw.rows && osdscroll == 1) || osdrowscur < -1)
449 terminx 1478
        {
450 terminx 1479
            j = (getticks()-osdscrtime);
449 terminx 1480
            while (j > -1)
1481
            {
1482
                osdrowscur++;
4658 terminx 1483
                j -= tabledivide32_noinline(200, osd->draw.rows);
4536 terminx 1484
                if (osdrowscur > osd->draw.rows-1)
449 terminx 1485
                    break;
1486
            }
1487
        }
4536 terminx 1488
        if ((osdrowscur > -1 && osdscroll == -1) || osdrowscur > osd->draw.rows)
449 terminx 1489
        {
450 terminx 1490
            j = (getticks()-osdscrtime);
449 terminx 1491
            while (j > -1)
1492
            {
1493
                osdrowscur--;
4658 terminx 1494
                j -= tabledivide32_noinline(200, osd->draw.rows);
449 terminx 1495
                if (osdrowscur < 1)
1496
                    break;
1497
            }
1498
        }
1499
        osdscrtime = getticks();
441 terminx 1500
    }
584 terminx 1501
 
4536 terminx 1502
    if ((osd->flags & OSD_DRAW) == 0 || !osdrowscur) return;
401 terminx 1503
 
4536 terminx 1504
    topoffs = osd->draw.head * osd->draw.cols;
401 terminx 1505
    row = osdrowscur-1;
4536 terminx 1506
    lines = min(osd->text.lines-osd->draw.head, osdrowscur);
5 Plagman 1507
 
109 terminx 1508
    begindrawing();
5 Plagman 1509
 
4536 terminx 1510
    clearbackground(osd->draw.cols,osdrowscur+1);
584 terminx 1511
 
1512
    for (; lines>0; lines--, row--)
1513
    {
4210 helixhorne 1514
        // XXX: May happen, which would ensue an oob if not checked.
4536 terminx 1515
        // Last char accessed is osd->text.buf[topoffs + osd->draw.cols-1].
4210 helixhorne 1516
        // Reproducible by running test.lua with -Lopts=diag
1517
        // and scrolling to the top.
4536 terminx 1518
        if (topoffs + osd->draw.cols-1 >= OSDBUFFERSIZE)
4210 helixhorne 1519
            break;
4536 terminx 1520
        drawosdstr(0,row,osd->text.buf+topoffs,osd->draw.cols,osd->draw.textshade,osd->draw.textpal);
1521
        topoffs+=osd->draw.cols;
109 terminx 1522
    }
1523
 
1095 terminx 1524
    {
4536 terminx 1525
        int32_t offset = ((osd->flags & (OSD_CAPS|OSD_SHIFT)) == (OSD_CAPS|OSD_SHIFT) && osd->draw.head > 0);
1526
        int32_t shade = osd->draw.promptshade?osd->draw.promptshade:(sintable[(totalclock<<4)&2047]>>11);
109 terminx 1527
 
4536 terminx 1528
        if (osd->draw.head == osd->text.lines-1) drawosdchar(0,osdrowscur,'~',shade,osd->draw.promptpal);
1529
        else if (osd->draw.head > 0) drawosdchar(0,osdrowscur,'^',shade,osd->draw.promptpal);
1530
        if (osd->flags & OSD_CAPS) drawosdchar(0+(osd->draw.head > 0),osdrowscur,'C',shade,osd->draw.promptpal);
1531
        if (osd->flags & OSD_SHIFT) drawosdchar(1+(osd->flags & OSD_CAPS && osd->draw.head > 0),osdrowscur,'H',shade,osd->draw.promptpal);
109 terminx 1532
 
4536 terminx 1533
        drawosdchar(2+offset,osdrowscur,'>',shade,osd->draw.promptpal);
584 terminx 1534
 
4536 terminx 1535
        len = min(osd->draw.cols-1-3-offset, osd->editor.len-osd->editor.start);
1095 terminx 1536
        for (x=len-1; x>=0; x--)
4536 terminx 1537
            drawosdchar(3+x+offset,osdrowscur,osd->editor.buf[osd->editor.start+x],osd->draw.editshade<<1,osd->draw.editpal);
1095 terminx 1538
 
4536 terminx 1539
        offset += 3+osd->editor.pos-osd->editor.start;
1652 terminx 1540
 
4536 terminx 1541
        drawosdcursor(offset,osdrowscur,osd->flags & OSD_OVERTYPE,keytime);
1652 terminx 1542
 
4536 terminx 1543
        if (osd->verstr.buf)
1544
            drawosdstr(osd->draw.cols - osd->verstr.len, osdrowscur - (offset >= osd->draw.cols - osd->verstr.len),
1545
                       osd->verstr.buf, osd->verstr.len, (sintable[(totalclock<<4)&2047]>>11), osd->verstr.pal);
1095 terminx 1546
    }
1547
 
109 terminx 1548
    enddrawing();
5 Plagman 1549
}
1550
 
1551
 
1552
//
4555 hendricks2 1553
// OSD_Printf() -- Print a formatted string to the onscreen display
5 Plagman 1554
//   and write it to the log file
1555
//
1556
 
4555 hendricks2 1557
void OSD_Printf(const char *fmt, ...)
1558
{
1559
    static char tmpstr[8192];
1560
    va_list va;
1561
 
1562
    va_start(va, fmt);
1563
    Bvsnprintf(tmpstr, sizeof(tmpstr), fmt, va);
1564
    va_end(va);
1565
 
1566
    OSD_Puts(tmpstr);
1567
}
1568
 
1569
 
1570
//
1571
// OSD_Puts() -- Print a string to the onscreen display
1572
//   and write it to the log file
1573
//
1574
 
1625 terminx 1575
static inline void OSD_LineFeed(void)
5 Plagman 1576
{
4536 terminx 1577
    Bmemmove(osd->text.buf+osd->draw.cols, osd->text.buf, OSDBUFFERSIZE-osd->draw.cols);
1578
    Bmemset(osd->text.buf, asc_Space, osd->draw.cols);
1579
    Bmemmove(osd->text.fmt+osd->draw.cols, osd->text.fmt, OSDBUFFERSIZE-osd->draw.cols);
1580
    Bmemset(osd->text.fmt, osd->draw.textpal, osd->draw.cols);
1581
    if (osd->text.lines < osd->text.maxlines) osd->text.lines++;
5 Plagman 1582
}
4555 hendricks2 1583
 
1007 hnt_ts 1584
#define MAX_ERRORS 4096
4555 hendricks2 1585
 
1586
void OSD_Puts(const char *tmpstr)
5 Plagman 1587
{
4555 hendricks2 1588
    const char *chp;
1589
    char p=osd->draw.textpal, s=osd->draw.textshade;
5 Plagman 1590
 
4536 terminx 1591
    mutex_lock(&osd->mutex);
1658 terminx 1592
 
3318 helixhorne 1593
    if (tmpstr[0]==0)
1594
    {
4536 terminx 1595
        mutex_unlock(&osd->mutex);
3318 helixhorne 1596
        return;
1597
    }
1598
 
4536 terminx 1599
    if (tmpstr[0]=='^' && tmpstr[1]=='1' && tmpstr[2]=='0' && ++osd->log.errors > MAX_ERRORS)
1007 hnt_ts 1600
    {
4536 terminx 1601
        if (osd->log.errors == MAX_ERRORS + 1)
4555 hendricks2 1602
            tmpstr = "\nToo many errors. Logging errors stopped.\n";
1017 terminx 1603
        else
1604
        {
4536 terminx 1605
            osd->log.errors = MAX_ERRORS + 2;
1606
            mutex_unlock(&osd->mutex);
1017 terminx 1607
            return;
1608
        }
1007 hnt_ts 1609
    }
1610
 
4536 terminx 1611
    if (osd->log.lines < osd->log.cutoff)
591 plagman 1612
    {
4536 terminx 1613
        if (osdlog && (!osd->log.cutoff || osd->log.lines < osd->log.cutoff))
929 terminx 1614
        {
4555 hendricks2 1615
            char *chp2 = Xstrdup(tmpstr);
1616
            Bfputs(OSD_StripColors(chp2, tmpstr), osdlog);
1617
            Bprintf("%s", chp2);
1618
            Bfree(chp2);
929 terminx 1619
        }
591 plagman 1620
    }
4536 terminx 1621
    else if (osd->log.lines == osd->log.cutoff)
591 plagman 1622
    {
4555 hendricks2 1623
        Bfputs("\nMaximal log size reached. Logging stopped.\nSet the \"osdlogcutoff\" console variable to a higher value if you need a longer log.\n", osdlog);
4536 terminx 1624
        osd->log.lines = osd->log.cutoff + 1;
591 plagman 1625
    }
109 terminx 1626
 
1015 terminx 1627
    chp = tmpstr;
1628
    do
584 terminx 1629
    {
1015 terminx 1630
        if (*chp == '\n')
864 terminx 1631
        {
4536 terminx 1632
            osd->text.pos=0;
1633
            osd->log.lines++;
1625 terminx 1634
            OSD_LineFeed();
1015 terminx 1635
            continue;
1636
        }
1762 terminx 1637
 
1015 terminx 1638
        if (*chp == '\r')
1639
        {
4536 terminx 1640
            osd->text.pos=0;
1015 terminx 1641
            continue;
1642
        }
1762 terminx 1643
 
1015 terminx 1644
        if (*chp == '^')
1645
        {
864 terminx 1646
            if (isdigit(*(chp+1)))
1647
            {
1015 terminx 1648
                char smallbuf[4];
1019 terminx 1649
                if (!isdigit(*(++chp+1)))
1015 terminx 1650
                {
1651
                    smallbuf[0] = *(chp);
1652
                    smallbuf[1] = '\0';
2374 helixhorne 1653
                    p = Batol(smallbuf);
1019 terminx 1654
                    continue;
1015 terminx 1655
                }
1762 terminx 1656
 
1019 terminx 1657
                smallbuf[0] = *(chp++);
1658
                smallbuf[1] = *(chp);
1659
                smallbuf[2] = '\0';
2374 helixhorne 1660
                p = Batol(smallbuf);
1015 terminx 1661
                continue;
864 terminx 1662
            }
1762 terminx 1663
 
1015 terminx 1664
            if (Btoupper(*(chp+1)) == 'S')
864 terminx 1665
            {
1015 terminx 1666
                chp++;
1667
                if (isdigit(*(++chp)))
1668
                    s = *chp;
1669
                continue;
864 terminx 1670
            }
1762 terminx 1671
 
1015 terminx 1672
            if (Btoupper(*(chp+1)) == 'O')
1673
            {
1674
                chp++;
4536 terminx 1675
                p = osd->draw.textpal;
1676
                s = osd->draw.textshade;
1015 terminx 1677
                continue;
1678
            }
864 terminx 1679
        }
1762 terminx 1680
 
4536 terminx 1681
        osd->text.buf[osd->text.pos] = *chp;
1682
        osd->text.fmt[osd->text.pos++] = p+(s<<5);
1762 terminx 1683
 
4536 terminx 1684
        if (osd->text.pos == osd->draw.cols)
865 terminx 1685
        {
4536 terminx 1686
            osd->text.pos = 0;
1625 terminx 1687
            OSD_LineFeed();
584 terminx 1688
        }
1017 terminx 1689
    }
1690
    while (*(++chp));
1658 terminx 1691
 
4536 terminx 1692
    mutex_unlock(&osd->mutex);
5 Plagman 1693
}
1694
 
1695
 
1696
//
1697
// OSD_DispatchQueued() -- Executes any commands queued in the buffer
1698
//
1699
void OSD_DispatchQueued(void)
1700
{
1205 terminx 1701
    int32_t cmd;
5 Plagman 1702
 
4536 terminx 1703
    if (!osd->history.exec) return;
5 Plagman 1704
 
4536 terminx 1705
    cmd=osd->history.exec-1;
1706
    osd->history.exec=0;
109 terminx 1707
 
584 terminx 1708
    for (; cmd>=0; cmd--)
4536 terminx 1709
        OSD_Dispatch((const char *)osd->history.buf[cmd]);
5 Plagman 1710
}
1711
 
1712
 
1713
//
1714
// OSD_Dispatch() -- Executes a command string
1715
//
1716
 
1205 terminx 1717
static char *strtoken(char *s, char **ptrptr, int32_t *restart)
5 Plagman 1718
{
109 terminx 1719
    char *p, *p2, *start;
1720
 
1721
    *restart = 0;
1722
    if (!ptrptr) return NULL;
1723
 
1724
    // if s != NULL, we process from the start of s, otherwise
1725
    // we just continue with where ptrptr points to
1726
    if (s) p = s;
1727
    else p = *ptrptr;
1728
 
1729
    if (!p) return NULL;
1730
 
1731
    // eat up any leading whitespace
1732
    while (*p != 0 && *p != ';' && *p == ' ') p++;
1733
 
1734
    // a semicolon is an end of statement delimiter like a \0 is, so we signal
1735
    // the caller to 'restart' for the rest of the string pointed at by *ptrptr
584 terminx 1736
    if (*p == ';')
1737
    {
109 terminx 1738
        *restart = 1;
1739
        *ptrptr = p+1;
1740
        return NULL;
1741
    }
1742
    // or if we hit the end of the input, signal all done by nulling *ptrptr
584 terminx 1743
    else if (*p == 0)
1744
    {
109 terminx 1745
        *ptrptr = NULL;
1746
        return NULL;
1747
    }
1748
 
584 terminx 1749
    if (*p == '\"')
1750
    {
109 terminx 1751
        // quoted string
1752
        start = ++p;
1753
        p2 = p;
584 terminx 1754
        while (*p != 0)
1755
        {
1756
            if (*p == '\"')
1757
            {
109 terminx 1758
                p++;
1759
                break;
584 terminx 1760
            }
1761
            else if (*p == '\\')
1762
            {
1763
                switch (*(++p))
1764
                {
331 terminx 1765
                case 'n':
1766
                    *p2 = '\n'; break;
1767
                case 'r':
1768
                    *p2 = '\r'; break;
1769
                default:
1770
                    *p2 = *p; break;
109 terminx 1771
                }
584 terminx 1772
            }
1773
            else
1774
            {
109 terminx 1775
                *p2 = *p;
1776
            }
1777
            p2++, p++;
1778
        }
1779
        *p2 = 0;
584 terminx 1780
    }
1781
    else
1782
    {
109 terminx 1783
        start = p;
1784
        while (*p != 0 && *p != ';' && *p != ' ') p++;
1785
    }
1786
 
1787
    // if we hit the end of input, signal all done by nulling *ptrptr
584 terminx 1788
    if (*p == 0)
1789
    {
109 terminx 1790
        *ptrptr = NULL;
1791
    }
1792
    // or if we came upon a semicolon, signal caller to restart with the
1793
    // string at *ptrptr
584 terminx 1794
    else if (*p == ';')
1795
    {
109 terminx 1796
        *p = 0;
1797
        *ptrptr = p+1;
1798
        *restart = 1;
1799
    }
1800
    // otherwise, clip off the token and carry on
584 terminx 1801
    else
1802
    {
109 terminx 1803
        *(p++) = 0;
1804
        *ptrptr = p;
1805
    }
1806
 
1807
    return start;
5 Plagman 1808
}
1809
 
1810
#define MAXPARMS 512
1205 terminx 1811
int32_t OSD_Dispatch(const char *cmd)
5 Plagman 1812
{
109 terminx 1813
    char *workbuf, *wp, *wtp, *state;
1634 terminx 1814
    int32_t restart = 0;
5 Plagman 1815
 
4491 helixhorne 1816
    workbuf = state = Xstrdup(cmd);
5 Plagman 1817
 
584 terminx 1818
    do
1819
    {
1634 terminx 1820
        int32_t numparms = 0;
1821
        symbol_t *symb;
1822
        osdfuncparm_t ofp;
1823
        char *parms[MAXPARMS];
1824
 
109 terminx 1825
        Bmemset(parms, 0, sizeof(parms));
1634 terminx 1826
 
1827
        if ((wp = strtoken(state, &wtp, &restart)) == NULL)
584 terminx 1828
        {
109 terminx 1829
            state = wtp;
1830
            continue;
1831
        }
1832
 
1634 terminx 1833
        if ((symb = findexactsymbol(wp)) == NULL)
814 terminx 1834
        {
1649 helixhorne 1835
            if ((wp[0] != '/' || wp[1] != '/') && !m32_osd_tryscript) // cheap hack for comments in cfgs
1836
            {
1634 terminx 1837
                OSD_Printf(OSDTEXT_RED "\"%s\" is not a valid command or cvar\n", wp);
1649 helixhorne 1838
            }
1839
            else if (m32_osd_tryscript)
1840
            {
1841
                M32RunScript(cmd);
1842
            }
1527 terminx 1843
            Bfree(workbuf);
814 terminx 1844
            return -1;
1845
        }
1846
 
109 terminx 1847
        ofp.name = wp;
584 terminx 1848
        while (wtp && !restart)
1849
        {
109 terminx 1850
            wp = strtoken(NULL, &wtp, &restart);
1851
            if (wp && numparms < MAXPARMS) parms[numparms++] = wp;
1852
        }
1853
        ofp.numparms = numparms;
1854
        ofp.parms    = (const char **)parms;
1855
        ofp.raw      = cmd;
1634 terminx 1856
 
3116 hendricks2 1857
        if ((intptr_t)symb->func == (intptr_t)OSD_ALIAS)
817 terminx 1858
            OSD_Dispatch(symb->help);
3116 hendricks2 1859
        else if ((intptr_t)symb->func != (intptr_t)OSD_UNALIASED)
818 terminx 1860
            switch (symb->func(&ofp))
1861
            {
1862
            case OSDCMD_OK:
1863
                break;
1864
            case OSDCMD_SHOWHELP:
1865
                OSD_Printf("%s\n", symb->help);
1866
                break;
1867
            }
109 terminx 1868
 
1869
        state = wtp;
584 terminx 1870
    }
1871
    while (wtp && restart);
109 terminx 1872
 
1527 terminx 1873
    Bfree(workbuf);
109 terminx 1874
 
1875
    return 0;
5 Plagman 1876
}
1877
 
1878
 
1879
//
1880
// OSD_RegisterFunction() -- Registers a new function
1881
//
1762 terminx 1882
int32_t OSD_RegisterFunction(const char *name, const char *help, int32_t (*func)(const osdfuncparm_t *))
5 Plagman 1883
{
109 terminx 1884
    symbol_t *symb;
1885
    const char *cp;
5 Plagman 1886
 
4536 terminx 1887
    if (!osd)
1625 terminx 1888
        OSD_Init();
5 Plagman 1889
 
1632 terminx 1890
    if (!name || !name[0])
584 terminx 1891
    {
1632 terminx 1892
        OSD_Printf("OSD_RegisterFunction(): can't register function with null name\n");
109 terminx 1893
        return -1;
1894
    }
1632 terminx 1895
 
1896
    if (!func)
584 terminx 1897
    {
1632 terminx 1898
        OSD_Printf("OSD_RegisterFunction(): can't register null function\n");
109 terminx 1899
        return -1;
1900
    }
5 Plagman 1901
 
109 terminx 1902
    // check for illegal characters in name
584 terminx 1903
    for (cp = name; *cp; cp++)
1904
    {
1905
        if ((cp == name) && (*cp >= '0') && (*cp <= '9'))
1906
        {
817 terminx 1907
            OSD_Printf("OSD_RegisterFunction(): first character of function name \"%s\" must not be a numeral\n", name);
109 terminx 1908
            return -1;
1909
        }
1910
        if ((*cp < '0') ||
1911
                (*cp > '9' && *cp < 'A') ||
1912
                (*cp > 'Z' && *cp < 'a' && *cp != '_') ||
584 terminx 1913
                (*cp > 'z'))
1914
        {
817 terminx 1915
            OSD_Printf("OSD_RegisterFunction(): illegal character in function name \"%s\"\n", name);
109 terminx 1916
            return -1;
1917
        }
1918
    }
5 Plagman 1919
 
109 terminx 1920
    if (!help) help = "(no description for this function)";
5 Plagman 1921
 
109 terminx 1922
    symb = findexactsymbol(name);
1632 terminx 1923
 
817 terminx 1924
    if (symb) // allow this now for reusing an alias name
584 terminx 1925
    {
1762 terminx 1926
        /*
1927
                if (symb->func != OSD_ALIAS && symb->func != OSD_UNALIASED)
1928
                {
1929
                    OSD_Printf("OSD_RegisterFunction(): \"%s\" is already defined\n", name);
1930
                    return -1;
1931
                }
1932
        */
1666 terminx 1933
//        Bfree((char *)symb->help);
817 terminx 1934
        symb->help = help;
820 terminx 1935
        symb->func = func;
819 terminx 1936
        return 0;
109 terminx 1937
    }
5 Plagman 1938
 
109 terminx 1939
    symb = addnewsymbol(name);
1632 terminx 1940
 
584 terminx 1941
    if (!symb)
1942
    {
817 terminx 1943
        OSD_Printf("OSD_RegisterFunction(): Failed registering function \"%s\"\n", name);
109 terminx 1944
        return -1;
1945
    }
5 Plagman 1946
 
109 terminx 1947
    symb->name = name;
1948
    symb->help = help;
1949
    symb->func = func;
1950
 
1951
    return 0;
5 Plagman 1952
}
1953
 
403 terminx 1954
//
1955
// OSD_SetVersionString()
1956
//
1625 terminx 1957
void OSD_SetVersion(const char *version, int32_t shade, int32_t pal)
403 terminx 1958
{
4536 terminx 1959
    osdstr_t *v = &osd->verstr;
1960
    DO_FREE_AND_NULL(v->buf);
1961
    v->buf = Bstrdup(version);
1962
    v->len = Bstrlen(version);
1963
    v->shade = shade;
1964
    v->pal = pal;
403 terminx 1965
}
1966
 
5 Plagman 1967
//
1968
// addnewsymbol() -- Allocates space for a new symbol and attaches it
1969
//   appropriately to the lists, sorted.
1970
//
1025 terminx 1971
 
5 Plagman 1972
static symbol_t *addnewsymbol(const char *name)
1973
{
109 terminx 1974
    symbol_t *newsymb, *s, *t;
5 Plagman 1975
 
4536 terminx 1976
    if (osd->numsymbols >= OSDMAXSYMBOLS) return NULL;
4491 helixhorne 1977
    newsymb = (symbol_t *)Xmalloc(sizeof(symbol_t));
109 terminx 1978
    Bmemset(newsymb, 0, sizeof(symbol_t));
5 Plagman 1979
 
109 terminx 1980
    // link it to the main chain
584 terminx 1981
    if (!symbols)
1982
    {
109 terminx 1983
        symbols = newsymb;
584 terminx 1984
    }
1985
    else
1986
    {
1987
        if (Bstrcasecmp(name, symbols->name) <= 0)
1988
        {
109 terminx 1989
            t = symbols;
1990
            symbols = newsymb;
1991
            symbols->next = t;
584 terminx 1992
        }
1993
        else
1994
        {
109 terminx 1995
            s = symbols;
584 terminx 1996
            while (s->next)
1997
            {
109 terminx 1998
                if (Bstrcasecmp(s->next->name, name) > 0) break;
1999
                s=s->next;
2000
            }
2001
            t = s->next;
2002
            s->next = newsymb;
2003
            newsymb->next = t;
2004
        }
2005
    }
4536 terminx 2006
    hash_add(&h_osd, name, osd->numsymbols, 1);
4491 helixhorne 2007
    name = Bstrtolower(Xstrdup(name));
4536 terminx 2008
    hash_add(&h_osd, name, osd->numsymbols, 1);
1625 terminx 2009
    Bfree((void *)name);
4536 terminx 2010
    osd->symbptrs[osd->numsymbols++] = newsymb;
109 terminx 2011
    return newsymb;
5 Plagman 2012
}
2013
 
2014
 
2015
//
2016
// findsymbol() -- Finds a symbol, possibly partially named
109 terminx 2017
//
5 Plagman 2018
static symbol_t *findsymbol(const char *name, symbol_t *startingat)
2019
{
109 terminx 2020
    if (!startingat) startingat = symbols;
2021
    if (!startingat) return NULL;
5 Plagman 2022
 
109 terminx 2023
    for (; startingat; startingat=startingat->next)
1625 terminx 2024
        if (startingat->func != OSD_UNALIASED && !Bstrncasecmp(name, startingat->name, Bstrlen(name))) return startingat;
5 Plagman 2025
 
109 terminx 2026
    return NULL;
5 Plagman 2027
}
2028
 
2029
//
2030
// findexactsymbol() -- Finds a symbol, complete named
109 terminx 2031
//
5 Plagman 2032
static symbol_t *findexactsymbol(const char *name)
2033
{
1205 terminx 2034
    int32_t i;
4491 helixhorne 2035
    char *lname = Xstrdup(name);
109 terminx 2036
    if (!symbols) return NULL;
5 Plagman 2037
 
1625 terminx 2038
    i = hash_find(&h_osd,lname);
1026 terminx 2039
    if (i > -1)
2040
    {
1625 terminx 2041
//        if ((symbol_t *)osdsymbptrs[i]->func == OSD_UNALIASED)
1032 terminx 2042
//            return NULL;
1101 terminx 2043
        Bfree(lname);
4536 terminx 2044
        return osd->symbptrs[i];
1026 terminx 2045
    }
1197 terminx 2046
 
2047
    // try it again
1642 terminx 2048
    Bstrtolower(lname);
1625 terminx 2049
    i = hash_find(&h_osd,lname);
1101 terminx 2050
    Bfree(lname);
1197 terminx 2051
 
2052
    if (i > -1)
4536 terminx 2053
        return osd->symbptrs[i];
109 terminx 2054
    return NULL;
5 Plagman 2055
}
2056
 
1352 terminx 2057
int32_t osdcmd_cvar_set(const osdfuncparm_t *parm)
2058
{
2059
    int32_t showval = (parm->numparms == 0);
2060
    int32_t i;
2061
 
1625 terminx 2062
    i = hash_find(&h_cvars, parm->name);
1352 terminx 2063
 
2064
    if (i < 0)
4536 terminx 2065
        for (i = osd->numcvars-1; i >= 0; i--)
2066
            if (!Bstrcasecmp(parm->name, osd->cvars[i].c.name)) break;
1352 terminx 2067
 
2068
    if (i > -1)
2069
    {
4536 terminx 2070
        if (osd->cvars[i].c.type & CVAR_LOCKED)
1352 terminx 2071
        {
2072
            // sound the alarm
4536 terminx 2073
            OSD_Printf("Cvar \"%s\" is read only.\n",osd->cvars[i].c.name);
1352 terminx 2074
            return OSDCMD_OK;
2075
        }
1358 terminx 2076
 
4536 terminx 2077
        switch (osd->cvars[i].c.type&(CVAR_FLOAT|CVAR_DOUBLE|CVAR_INT|CVAR_UINT|CVAR_BOOL|CVAR_STRING))
1358 terminx 2078
        {
2079
        case CVAR_FLOAT:
1440 terminx 2080
        {
2081
            float val;
2082
            if (showval)
1357 terminx 2083
            {
4536 terminx 2084
                OSD_Printf("\"%s\" is \"%f\"\n%s: %s\n",osd->cvars[i].c.name,*(float *)osd->cvars[i].c.vptr,osd->cvars[i].c.name,(char *)osd->cvars[i].c.desc);
1440 terminx 2085
                return OSDCMD_OK;
2086
            }
1352 terminx 2087
 
1440 terminx 2088
            sscanf(parm->parms[0], "%f", &val);
1352 terminx 2089
 
4536 terminx 2090
            if (val < osd->cvars[i].c.min || val > osd->cvars[i].c.max)
1440 terminx 2091
            {
4536 terminx 2092
                OSD_Printf("%s value out of range\n",osd->cvars[i].c.name);
1440 terminx 2093
                return OSDCMD_OK;
1357 terminx 2094
            }
4536 terminx 2095
            *(float *)osd->cvars[i].c.vptr = val;
1440 terminx 2096
            if (!OSD_ParsingScript())
4536 terminx 2097
                OSD_Printf("%s %f",osd->cvars[i].c.name,val);
1440 terminx 2098
        }
2099
        break;
1358 terminx 2100
        case CVAR_DOUBLE:
1440 terminx 2101
        {
2102
            double val;
2103
            if (showval)
1357 terminx 2104
            {
4536 terminx 2105
                OSD_Printf("\"%s\" is \"%f\"\n%s: %s\n",osd->cvars[i].c.name,*(double *)osd->cvars[i].c.vptr,osd->cvars[i].c.name,(char *)osd->cvars[i].c.desc);
1440 terminx 2106
                return OSDCMD_OK;
2107
            }
1358 terminx 2108
 
1440 terminx 2109
            sscanf(parm->parms[0], "%lf", &val);
1358 terminx 2110
 
4536 terminx 2111
            if (val < osd->cvars[i].c.min || val > osd->cvars[i].c.max)
1440 terminx 2112
            {
4536 terminx 2113
                OSD_Printf("%s value out of range\n",osd->cvars[i].c.name);
1440 terminx 2114
                return OSDCMD_OK;
1358 terminx 2115
            }
4536 terminx 2116
            *(double *)osd->cvars[i].c.vptr = val;
1440 terminx 2117
            if (!OSD_ParsingScript())
4536 terminx 2118
                OSD_Printf("%s %f",osd->cvars[i].c.name,val);
1440 terminx 2119
        }
2120
        break;
1358 terminx 2121
        case CVAR_INT:
2122
        case CVAR_UINT:
2123
        case CVAR_BOOL:
1440 terminx 2124
        {
2125
            int32_t val;
2126
            if (showval)
1358 terminx 2127
            {
4536 terminx 2128
                OSD_Printf("\"%s\" is \"%d\"\n%s: %s\n",osd->cvars[i].c.name,*(int32_t *)osd->cvars[i].c.vptr,osd->cvars[i].c.name,(char *)osd->cvars[i].c.desc);
1440 terminx 2129
                return OSDCMD_OK;
2130
            }
1352 terminx 2131
 
2374 helixhorne 2132
            val = Batoi(parm->parms[0]);
4536 terminx 2133
            if (osd->cvars[i].c.type & CVAR_BOOL) val = val != 0;
1352 terminx 2134
 
4536 terminx 2135
            if (val < osd->cvars[i].c.min || val > osd->cvars[i].c.max)
1440 terminx 2136
            {
4536 terminx 2137
                OSD_Printf("%s value out of range\n",osd->cvars[i].c.name);
1440 terminx 2138
                return OSDCMD_OK;
1357 terminx 2139
            }
4536 terminx 2140
            *(int32_t *)osd->cvars[i].c.vptr = val;
1440 terminx 2141
            if (!OSD_ParsingScript())
4536 terminx 2142
                OSD_Printf("%s %d",osd->cvars[i].c.name,val);
1440 terminx 2143
        }
2144
        break;
1358 terminx 2145
        case CVAR_STRING:
1440 terminx 2146
        {
2147
            if (showval)
1357 terminx 2148
            {
4536 terminx 2149
                OSD_Printf("\"%s\" is \"%s\"\n%s: %s\n",osd->cvars[i].c.name,(char *)osd->cvars[i].c.vptr,osd->cvars[i].c.name, (char *)osd->cvars[i].c.desc);
1440 terminx 2150
                return OSDCMD_OK;
2151
            }
1355 terminx 2152
 
4536 terminx 2153
            Bstrncpy((char *)osd->cvars[i].c.vptr, parm->parms[0], osd->cvars[i].c.max-1);
2154
            ((char *)osd->cvars[i].c.vptr)[osd->cvars[i].c.max-1] = 0;
1440 terminx 2155
            if (!OSD_ParsingScript())
4536 terminx 2156
                OSD_Printf("%s %s",osd->cvars[i].c.name,(char *)osd->cvars[i].c.vptr);
1440 terminx 2157
        }
2158
        break;
1358 terminx 2159
        default:
4702 terminx 2160
            EDUKE32_UNREACHABLE_SECTION(break);
1358 terminx 2161
        }
3757 terminx 2162
 
2163
#ifdef USE_OPENGL
2164
        if (!OSD_ParsingScript())
2165
        {
4536 terminx 2166
            switch (osd->cvars[i].c.type&(CVAR_RESTARTVID|CVAR_INVALIDATEALL|CVAR_INVALIDATEART))
3757 terminx 2167
            {
2168
            case CVAR_RESTARTVID:
2169
                osdcmd_restartvid(NULL);
2170
                break;
3758 terminx 2171
            case CVAR_INVALIDATEALL:
3765 terminx 2172
                gltexinvalidatetype(INVALIDATE_ALL);
3758 terminx 2173
            case CVAR_INVALIDATEART:
3765 terminx 2174
                gltexinvalidatetype(INVALIDATE_ART);
3757 terminx 2175
#ifdef POLYMER
2176
                if (getrendermode() == REND_POLYMER)
2177
                    polymer_texinvalidate();
2178
#endif
2179
                break;
2180
            }
2181
        }
2182
#endif
1352 terminx 2183
    }
1358 terminx 2184
 
1355 terminx 2185
    if (!OSD_ParsingScript())
2186
        OSD_Printf("\n");
1358 terminx 2187
 
1352 terminx 2188
    return OSDCMD_OK;
2189
}
2190
 
4213 helixhorne 2191
void OSD_WriteAliases(FILE *fp)
2192
{
2193
    symbol_t *symb;
2194
    for (symb=symbols; symb!=NULL; symb=symb->next)
2195
        if (symb->func == (void *)OSD_ALIAS)
2196
            Bfprintf(fp, "alias \"%s\" \"%s\"\n", symb->name, symb->help);
2197
}
2198
 
1358 terminx 2199
void OSD_WriteCvars(FILE *fp)
1355 terminx 2200
{
2201
    uint32_t i;
2202
 
1625 terminx 2203
    if (!fp)
2204
        return;
2205
 
4536 terminx 2206
    for (i=0; i<osd->numcvars; i++)
1355 terminx 2207
    {
4536 terminx 2208
        if (!(osd->cvars[i].c.type & CVAR_NOSAVE) && OSD_CvarModified(&osd->cvars[i]))
2209
            switch (osd->cvars[i].c.type&(CVAR_FLOAT|CVAR_DOUBLE|CVAR_INT|CVAR_UINT|CVAR_BOOL|CVAR_STRING))
1762 terminx 2210
            {
1625 terminx 2211
            case CVAR_FLOAT:
4536 terminx 2212
                fprintf(fp,"%s \"%f\"\n",osd->cvars[i].c.name,*(float *)osd->cvars[i].c.vptr);
1625 terminx 2213
                break;
2214
            case CVAR_DOUBLE:
4536 terminx 2215
                fprintf(fp,"%s \"%f\"\n",osd->cvars[i].c.name,*(double *)osd->cvars[i].c.vptr);
1625 terminx 2216