LIV2/WinUAE
1
0
Fork 0
mirror of https://github.com/LIV2/WinUAE.git synced 2025-12-06 00:12:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
WinUAE/statusline.cpp
Toni Wilen 300603a807 GDI mode statusline update.
2022-06-18 22:23:39 +03:00

562 lines
16 KiB
C++
Raw Blame History

#include "sysconfig.h"
#include "sysdeps.h"
#include <ctype.h>
#include <assert.h>
#include "options.h"
#include "uae.h"
#include "xwin.h"
#include "gui.h"
#include "custom.h"
#include "drawing.h"
#include "inputdevice.h"
#include "statusline.h"
#define STATUSLINE_MS 3000
/*
* Some code to put status information on the screen.
*/
static bool td_custom;
void statusline_getpos(int monid, int *x, int *y, int width, int height)
{
int mx = td_custom ? 1 : statusline_get_multiplier(monid) / 100;
int total_height = TD_TOTAL_HEIGHT * mx;
if (currprefs.osd_pos.x >= 20000) {
if (currprefs.osd_pos.x >= 30000)
*y = width * (currprefs.osd_pos.x - 30000) / 1000;
else
*y = width - (width * (30000 - currprefs.osd_pos.y) / 1000);
} else {
if (currprefs.osd_pos.x >= 0)
*x = currprefs.osd_pos.x;
else
*x = -currprefs.osd_pos.x + 1;
}
if (currprefs.osd_pos.y >= 20000) {
if (currprefs.osd_pos.y >= 30000)
*y = (height - total_height) * (currprefs.osd_pos.y - 30000) / 1000;
else
*y = (height - total_height) - ((height - total_height) * (30000 - currprefs.osd_pos.y) / 1000);
} else {
if (currprefs.osd_pos.y >= 0)
*y = height - total_height - currprefs.osd_pos.y;
else
*y = -currprefs.osd_pos.y + 1;
}
}
int td_numbers_pos = TD_RIGHT | TD_BOTTOM;
int td_numbers_width = TD_DEFAULT_NUM_WIDTH;
int td_numbers_height = TD_DEFAULT_NUM_HEIGHT;
int td_numbers_padx = TD_DEFAULT_PADX;
int td_numbers_pady = TD_DEFAULT_PADY;
const TCHAR *td_characters = _T("0123456789CHD%+-PNKV");
int td_led_width = TD_DEFAULT_LED_WIDTH;
static int td_led_height = TD_DEFAULT_LED_HEIGHT;
int td_width = TD_DEFAULT_WIDTH;
static const char *numbers_default = { /* ugly 0123456789CHD%+-PNKV */
"+++++++--++++-+++++++++++++++++-++++++++++++++++++++++++++++++++++++++++++++-++++++-++++----++---+--------------++++++++++-++++++++++++ +++"
"+xxxxx+--+xx+-+xxxxx++xxxxx++x+-+x++xxxxx++xxxxx++xxxxx++xxxxx++xxxxx++xxxx+-+x++x+-+xxx++-+xx+-+x---+----------+xxxxx++x+-+x++x++x++x+ +x+"
"+x+++x+--++x+-+++++x++++++x++x+++x++x++++++x++++++++++x++x+++x++x+++x++x++++-+x++x+-+x++x+--+x++x+--+x+----+++--+x---x++xx++x++x+x+++x+ +x+"
"+x+-+x+---+x+-+xxxxx++xxxxx++xxxxx++xxxxx++xxxxx+--++x+-+xxxxx++xxxxx++x+----+xxxx+-+x++x+----+x+--+xxx+--+xxx+-+xxxxx++x+x+x++xx+ +x++x+ "
"+x+++x+---+x+-+x++++++++++x++++++x++++++x++x+++x+--+x+--+x+++x++++++x++x++++-+x++x+-+x++x+---+x+x+--+x+----+++--+x++++++x+x+x++x+x++ +xx+ "
"+xxxxx+---+x+-+xxxxx++xxxxx+----+x++xxxxx++xxxxx+--+x+--+xxxxx++xxxxx++xxxx+-+x++x+-+xxx+---+x++xx--------------+x+----+x++xx++x++x+ +xx+ "
"+++++++---+++-++++++++++++++----+++++++++++++++++--+++--++++++++++++++++++++-++++++-++++------------------------+++----+++++++++++++ ++++ "
// x x x x x x x x x x x x x x x x x x x x x
};
static const char *numbers = numbers_default;
STATIC_INLINE uae_u32 ledcolor(uae_u32 c, uae_u32 *rc, uae_u32 *gc, uae_u32 *bc, uae_u32 *a)
{
uae_u32 v = rc[(c >> 16) & 0xff] | gc[(c >> 8) & 0xff] | bc[(c >> 0) & 0xff];
if (a)
v |= a[255 - ((c >> 24) & 0xff)];
return v;
}
static void write_tdnumber(uae_u8 *buf, int bpp, int x, int y, int num, uae_u32 c1, uae_u32 c2, int mult)
{
int j;
const char *numptr;
numptr = numbers + num * td_numbers_width + NUMBERS_NUM * td_numbers_width * y;
for (j = 0; j < td_numbers_width; j++) {
for (int k = 0; k < mult; k++) {
if (*numptr == 'x')
putpixel(buf, NULL, bpp, x + j * mult + k, c1);
else if (*numptr == '+')
putpixel(buf, NULL, bpp, x + j * mult + k, c2);
}
numptr++;
}
}
static uae_u32 rgbmuldiv(uae_u32 rgb, int mul, int div)
{
uae_u32 out = 0;
for (int i = 0; i < 3; i++) {
int v = (rgb >> (i * 8)) & 0xff;
v *= mul;
v /= div;
out |= v << (i * 8);
}
out |= rgb & 0xff000000;
return out;
}
static int statusline_mult[2];
void statusline_set_font(const char *newnumbers, int width, int height)
{
td_numbers_width = TD_DEFAULT_NUM_WIDTH;
td_numbers_height = TD_DEFAULT_NUM_HEIGHT;
td_numbers_padx = TD_DEFAULT_PADX;
td_numbers_pady = TD_DEFAULT_PADY;
td_led_width = TD_DEFAULT_LED_WIDTH;
td_led_height = TD_DEFAULT_LED_HEIGHT;
td_width = TD_DEFAULT_WIDTH;
td_custom = false;
numbers = numbers_default;
if (!newnumbers)
return;
numbers = newnumbers;
td_numbers_width = width;
td_numbers_height = height;
td_led_width = td_numbers_width * 3 + td_numbers_width / 2;
td_width = td_led_width + 6;
td_custom = true;
}
int statusline_set_multiplier(int monid, int width, int height)
{
struct amigadisplay *ad = &adisplays[monid];
int idx = ad->picasso_on ? 1 : 0;
int mult = currprefs.leds_on_screen_multiplier[idx];
if (mult < 1 * 100) {
mult = 1 * 100;
}
if (mult > 4 * 100) {
mult = 4 * 100;
}
statusline_mult[idx] = mult;
return mult;
}
int statusline_get_multiplier(int monid)
{
struct amigadisplay *ad = &adisplays[monid];
int idx = ad->picasso_on ? 1 : 0;
if (statusline_mult[idx] < 1 * 100)
return 1 * 100;
return statusline_mult[idx];
}
void draw_status_line_single(int monid, uae_u8 *buf, int bpp, int y, int totalwidth, uae_u32 *rc, uae_u32 *gc, uae_u32 *bc, uae_u32 *alpha)
{
struct amigadisplay *ad = &adisplays[monid];
int x_start, j, led, border;
uae_u32 c1, c2, cb;
int mult = td_custom ? 1 : statusline_mult[ad->picasso_on ? 1 : 0] / 100;
if (!mult)
return;
y /= mult;
c1 = ledcolor (0x00ffffff, rc, gc, bc, alpha);
c2 = ledcolor (0x00111111, rc, gc, bc, alpha);
if (td_numbers_pos & TD_RIGHT)
x_start = totalwidth - (td_numbers_padx + VISIBLE_LEDS * td_width) * mult;
else
x_start = td_numbers_padx * mult;
for (led = 0; led < LED_MAX; led++) {
int pos, num1 = -1, num2 = -1, num3 = -1, num4 = -1;
int x, c, on = 0, am = 2;
xcolnr on_rgb = 0, on_rgb2 = 0, off_rgb = 0, pen_rgb = 0;
int half = 0, extraborder = 0;
cb = ledcolor(TD_BORDER, rc, gc, bc, alpha);
if (!(currprefs.leds_on_screen_mask[ad->picasso_on ? 1 : 0] & (1 << led)))
continue;
pen_rgb = c1;
if (led >= LED_DF0 && led <= LED_DF3) {
int pled = led - LED_DF0;
struct floppyslot *fs = &currprefs.floppyslots[pled];
struct gui_info_drive *gid = &gui_data.drives[pled];
int track = gid->drive_track;
pos = 7 + pled;
on_rgb = 0x00cc00;
if (!gid->drive_disabled) {
num1 = -1;
num2 = track / 10;
num3 = track % 10;
on = gid->drive_motor;
if (gid->drive_writing) {
on_rgb = 0xcc0000;
}
half = gui_data.drive_side ? 1 : -1;
if (!gid->floppy_inserted) {
pen_rgb = ledcolor(0x00aaaaaa, rc, gc, bc, alpha);
} else if (gid->floppy_protected) {
cb = ledcolor(0x00cc00, rc, gc, bc, alpha);
extraborder = 1;
}
}
on_rgb &= 0xffffff;
off_rgb = rgbmuldiv(on_rgb, 2, 4);
on_rgb2 = rgbmuldiv(on_rgb, 2, 3);
} else if (led == LED_POWER) {
pos = 3;
on_rgb = ((gui_data.powerled_brightness * 10 / 16) + 0x33) << 16;
on = 1;
off_rgb = 0x330000;
} else if (led == LED_CD) {
pos = 5;
if (gui_data.cd >= 0) {
on = gui_data.cd & (LED_CD_AUDIO | LED_CD_ACTIVE);
on_rgb = (on & LED_CD_AUDIO) ? 0x00cc00 : 0x0000cc;
if ((gui_data.cd & LED_CD_ACTIVE2) && !(gui_data.cd & LED_CD_AUDIO)) {
on_rgb &= 0xfefefe;
on_rgb >>= 1;
}
off_rgb = 0x000033;
num1 = -1;
num2 = 10;
num3 = 12;
}
} else if (led == LED_HD) {
pos = 4;
if (gui_data.hd >= 0) {
on = gui_data.hd;
on_rgb = on == 2 ? 0xcc0000 : 0x0000cc;
off_rgb = 0x000033;
num1 = -1;
num2 = 11;
num3 = 12;
}
} else if (led == LED_FPS) {
pos = 2;
if (pause_emulation) {
num1 = -1;
num2 = -1;
num3 = 16;
on_rgb = 0xcccccc;
off_rgb = 0x111111;
am = 2;
} else {
int fps = (gui_data.fps + 5) / 10;
on_rgb = 0x111111;
off_rgb = gui_data.fps_color == 1 ? 0xcccc00 : (gui_data.fps_color == 2 ? 0x0000cc : 0x111111);
am = 3;
if (gui_data.fps_color >= 2) {
num1 = -1;
num2 = 15;
num3 = 15;
am = 2;
} else {
if (fps > 999) {
fps += 50;
fps /= 10;
if (fps > 999)
fps = 999;
num1 = fps / 100;
num1 %= 10;
num2 = 18;
num3 = (fps - num1 * 100) / 10;
} else {
num1 = fps / 100;
num2 = (fps - num1 * 100) / 10;
num3 = fps % 10;
num1 %= 10;
num2 %= 10;
if (num1 == 0)
am = 2;
}
}
}
} else if (led == LED_CPU) {
int idle = (gui_data.idle + 5) / 10;
pos = 1;
on_rgb = 0xcc0000;
off_rgb = 0x111111;
if (gui_data.cpu_halted) {
idle = 0;
on = 1;
if (gui_data.cpu_halted < 0) {
on_rgb = 0x111111;
num1 = 16; // PPC
num2 = 16;
num3 = 10;
am = 3;
} else {
on_rgb = 0xcccc00;
num1 = gui_data.cpu_halted >= 10 ? 11 : -1;
num2 = gui_data.cpu_halted >= 10 ? (gui_data.cpu_halted / 10) % 10 : 11;
num3 = gui_data.cpu_halted % 10;
am = 2;
}
} else {
num1 = idle / 100;
num2 = (idle - num1 * 100) / 10;
num3 = idle % 10;
num1 %= 10;
num2 %= 10;
num4 = num1 == 0 ? 13 : -1;
if (!num1 && !num2) {
num2 = -2;
}
am = 3;
}
} else if (led == LED_SND && gui_data.sndbuf_avail) {
int snd = abs(gui_data.sndbuf + 5) / 10;
if (snd > 99)
snd = 99;
pos = 0;
on = gui_data.sndbuf_status;
if (on < 3) {
num1 = gui_data.sndbuf < 0 ? 15 : 14;
num2 = snd / 10;
num3 = snd % 10;
}
on_rgb = 0x111111;
if (on < 0)
on_rgb = 0xcccc00; // underflow
else if (on == 2)
on_rgb = 0xcc0000; // really big overflow
else if (on == 1)
on_rgb = 0x0000cc; // "normal" overflow
off_rgb = 0x111111;
am = 3;
} else if (led == LED_MD) {
// DF3 reused as internal non-volatile ram led (cd32/cdtv)
if (gui_data.drives[3].drive_disabled && gui_data.md >= 0) {
pos = 7 + 3;
if (gui_data.md >= 0) {
on = gui_data.md;
on_rgb = on == 2 ? 0xcc0000 : 0x00cc00;
off_rgb = 0x003300;
}
num1 = -1;
num2 = 17;
num3 = 19;
} else {
continue;
}
} else if (led == LED_NET) {
pos = 6;
if (gui_data.net >= 0) {
on = gui_data.net;
on_rgb = 0;
if (on & 1)
on_rgb |= 0x00cc00;
if (on & 2)
on_rgb |= 0xcc0000;
off_rgb = 0x111111;
num1 = -1;
num2 = -1;
num3 = 17;
am = 1;
}
} else {
continue;
}
on_rgb |= 0x33111111;
off_rgb |= 0x33111111;
if (half > 0) {
int halfon = y >= TD_TOTAL_HEIGHT / 2;
c = ledcolor(on ? (halfon ? on_rgb2 : on_rgb) : off_rgb, rc, gc, bc, alpha);
if (!halfon && on && extraborder)
cb = rgbmuldiv(cb, 2, 3);
} else if (half < 0) {
int halfon = y < TD_TOTAL_HEIGHT / 2;
c = ledcolor(on ? (halfon ? on_rgb2 : on_rgb) : off_rgb, rc, gc, bc, alpha);
if (!halfon && on && extraborder)
cb = rgbmuldiv(cb, 2, 3);
} else {
c = ledcolor(on ? on_rgb : off_rgb, rc, gc, bc, alpha);
}
border = 0;
if (y == 0 || y == TD_TOTAL_HEIGHT - 1) {
c = cb;
border = 1;
}
x = x_start + pos * td_width * mult;
for (int xx = 0; xx < mult; xx++) {
if (!border) {
putpixel(buf, NULL, bpp, x - mult + xx, cb);
}
for (j = 0; j < td_led_width * mult; j += mult) {
putpixel(buf, NULL, bpp, x + j + xx, c);
}
if (!border) {
putpixel(buf, NULL, bpp, x + j + xx, cb);
}
}
if (y >= td_numbers_pady && y - td_numbers_pady < td_numbers_height) {
if (num3 >= 0) {
x += (td_led_width - am * td_numbers_width) * mult / 2;
if (num1 > 0) {
write_tdnumber(buf, bpp, x, y - td_numbers_pady, num1, pen_rgb, c2, mult);
x += td_numbers_width * mult;
}
if (num2 >= 0) {
write_tdnumber(buf, bpp, x, y - td_numbers_pady, num2, pen_rgb, c2, mult);
x += td_numbers_width * mult;
} else if (num2 < -1) {
x += td_numbers_width * mult;
}
write_tdnumber(buf, bpp, x, y - td_numbers_pady, num3, pen_rgb, c2, mult);
x += td_numbers_width * mult;
if (num4 > 0)
write_tdnumber(buf, bpp, x, y - td_numbers_pady, num4, pen_rgb, c2, mult);
}
}
}
}
#define MAX_STATUSLINE_QUEUE 8
struct statusline_struct
{
TCHAR *text;
int type;
};
struct statusline_struct statusline_data[MAX_STATUSLINE_QUEUE];
static TCHAR *statusline_text_active;
static int statusline_delay;
static bool statusline_had_changed;
bool has_statusline_updated(void)
{
bool v = statusline_had_changed;
statusline_had_changed = false;
return v;
}
static void statusline_update_notification(void)
{
statusline_had_changed = true;
statusline_updated(0);
}
void statusline_clear(void)
{
statusline_text_active = NULL;
statusline_delay = 0;
for (int i = 0; i < MAX_STATUSLINE_QUEUE; i++) {
xfree(statusline_data[i].text);
statusline_data[i].text = NULL;
}
statusline_update_notification();
}
const TCHAR *statusline_fetch(void)
{
return statusline_text_active;
}
void statusline_add_message(int statustype, const TCHAR *format, ...)
{
va_list parms;
TCHAR buffer[256];
if (isguiactive())
return;
va_start(parms, format);
buffer[0] = ' ';
_vsntprintf(buffer + 1, 256 - 2, format, parms);
_tcscat(buffer, _T(" "));
for (int i = 0; i < MAX_STATUSLINE_QUEUE; i++) {
if (statusline_data[i].text != NULL && statusline_data[i].type == statustype) {
xfree(statusline_data[i].text);
statusline_data[i].text = NULL;
for (int j = i + 1; j < MAX_STATUSLINE_QUEUE; j++) {
memcpy(&statusline_data[j - 1], &statusline_data[j], sizeof(struct statusline_struct));
}
statusline_data[MAX_STATUSLINE_QUEUE - 1].text = NULL;
}
}
if (statusline_data[1].text) {
for (int i = 0; i < MAX_STATUSLINE_QUEUE; i++) {
if (statusline_data[i].text && !_tcscmp(statusline_data[i].text, buffer)) {
xfree(statusline_data[i].text);
for (int j = i + 1; j < MAX_STATUSLINE_QUEUE; j++) {
memcpy(&statusline_data[j - 1], &statusline_data[j], sizeof(struct statusline_struct));
}
statusline_data[MAX_STATUSLINE_QUEUE - 1].text = NULL;
i = 0;
}
}
} else if (statusline_data[0].text) {
if (!_tcscmp(statusline_data[0].text, buffer))
return;
}
for (int i = 0; i < MAX_STATUSLINE_QUEUE; i++) {
if (statusline_data[i].text == NULL) {
statusline_data[i].text = my_strdup(buffer);
statusline_data[i].type = statustype;
if (i == 0)
statusline_delay = (int)(STATUSLINE_MS * vblank_hz / 1000.0f);
statusline_text_active = statusline_data[0].text;
statusline_update_notification();
return;
}
}
statusline_text_active = NULL;
xfree(statusline_data[0].text);
for (int i = 1; i < MAX_STATUSLINE_QUEUE; i++) {
memcpy(&statusline_data[i - 1], &statusline_data[i], sizeof(struct statusline_struct));
}
statusline_data[MAX_STATUSLINE_QUEUE - 1].text = my_strdup(buffer);
statusline_data[MAX_STATUSLINE_QUEUE - 1].type = statustype;
statusline_text_active = statusline_data[0].text;
statusline_update_notification();
va_end(parms);
}
void statusline_vsync(void)
{
if (!statusline_data[0].text)
return;
if (statusline_delay == 0)
statusline_delay = (int)(STATUSLINE_MS * vblank_hz / (1000.0f * 1.0f));
if (statusline_delay > STATUSLINE_MS * vblank_hz / (1000.0f * 1.0f))
statusline_delay = (int)(STATUSLINE_MS * vblank_hz / (1000.0f * 1.0f));
if (statusline_delay > STATUSLINE_MS * vblank_hz / (1000.0f * 3.0f) && statusline_data[1].text)
statusline_delay = (int)(STATUSLINE_MS * vblank_hz / (1000.0f * 3.0f));
statusline_delay--;
if (statusline_delay)
return;
statusline_text_active = NULL;
xfree(statusline_data[0].text);
for (int i = 1; i < MAX_STATUSLINE_QUEUE; i++) {
statusline_data[i - 1].text = statusline_data[i].text;
}
statusline_data[MAX_STATUSLINE_QUEUE - 1].text = NULL;
statusline_text_active = statusline_data[0].text;
statusline_update_notification();
}
void statusline_single_erase(int monid, uae_u8 *buf, int bpp, int y, int totalwidth)
{
memset(buf, 0, bpp * totalwidth);
}
Reference in New Issue View Git Blame Copy Permalink