mirror of
https://github.com/buserror/mii_emu.git
synced 2024-11-25 20:33:52 +00:00
440 lines
12 KiB
C
440 lines
12 KiB
C
/*
|
|
* mui_mui_slots.c
|
|
*
|
|
* Copyright (C) 2023 Michel Pollet <buserror@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*/
|
|
#define _GNU_SOURCE
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <unistd.h>
|
|
|
|
#include "mui.h"
|
|
#include "mii_mui_settings.h"
|
|
|
|
|
|
typedef struct mii_ui_machine_config_t {
|
|
mui_window_t win;
|
|
|
|
mui_control_t * slot[8];
|
|
|
|
// for sub-windows
|
|
unsigned slot_id;
|
|
mii_machine_config_t * dst;
|
|
mii_machine_config_t config;
|
|
} mii_ui_machine_config_t;
|
|
|
|
static const mii_machine_config_t _default_config = {
|
|
.no_slot_clock = 1,
|
|
.titan_accelerator = 0,
|
|
.slot = {
|
|
[0] = {
|
|
// .driver = MII_SLOT_DRIVER_SUPERSERIAL,
|
|
.conf.ssc = {
|
|
.kind = 0,
|
|
.socket_port = 1969,
|
|
.device = "/dev/ttyS0",
|
|
.baud = 9600,
|
|
.bits = 8,
|
|
.parity = 0,
|
|
.stop = 1,
|
|
}
|
|
},
|
|
[1] = { .driver = 0, },
|
|
[2] = { .driver = 0, },
|
|
[3] = {
|
|
.driver = MII_SLOT_DRIVER_MOUSE,
|
|
},
|
|
[4] = { .driver = 0, },
|
|
[5] = {
|
|
.driver = MII_SLOT_DRIVER_DISK2,
|
|
},
|
|
[6] = {
|
|
.driver = MII_SLOT_DRIVER_SMARTPORT,
|
|
},
|
|
},
|
|
};
|
|
|
|
enum {
|
|
MII_SLOT_WINDOW_ID = FCC('s','l','o','t'),
|
|
MII_SLOT_SAVE = FCC('s','a','v','e'),
|
|
MII_SLOT_CANCEL = FCC('c','a','n','c'),
|
|
MII_SLOT_DEFAULT = FCC('d','e','f','a'),
|
|
// MII_SLOT_REBOOT = FCC('r','b','o','o'),
|
|
MII_SLOT_NSC = FCC('n','s','c','l'),
|
|
MII_SLOT_TITAN = FCC('t','i','t','a'),
|
|
MII_SLOT_DRIVER_POP = FCC('d','r','v','p'),
|
|
MII_SLOT_DRIVER_CONF = FCC('d','r','v','c'),
|
|
};
|
|
|
|
static const struct {
|
|
char * label;
|
|
int has_config;
|
|
} _mii_slot_drivers[] = {
|
|
[MII_SLOT_DRIVER_NONE] = { "None", 0 },
|
|
[MII_SLOT_DRIVER_SMARTPORT] = { "SmartPort", 1 },
|
|
[MII_SLOT_DRIVER_DISK2] = { "Disk II", 1 },
|
|
[MII_SLOT_DRIVER_MOUSE] = { "Mouse", 0 },
|
|
[MII_SLOT_DRIVER_SUPERSERIAL] = { "Super Serial", 1 },
|
|
[MII_SLOT_DRIVER_ROM1MB] = { "ROM 1MB", 1 },
|
|
{ NULL, 0 },
|
|
};
|
|
|
|
static void
|
|
_mii_config_win_to_conf(
|
|
mii_ui_machine_config_t * m)
|
|
{
|
|
mui_window_t * w = &m->win;
|
|
mii_machine_config_t * cf = &m->config;
|
|
|
|
// cf->reboot_on_load = !!mui_control_get_value(
|
|
// mui_control_get_by_id(w, MII_SLOT_REBOOT));
|
|
cf->titan_accelerator = !!mui_control_get_value(
|
|
mui_control_get_by_id(w, MII_SLOT_TITAN));
|
|
cf->no_slot_clock = !!mui_control_get_value(
|
|
mui_control_get_by_id(w, MII_SLOT_NSC));
|
|
|
|
for (int slot_id = 1; slot_id < 8; slot_id++) {
|
|
mui_control_t * c = mui_control_get_by_id(
|
|
w, MII_SLOT_DRIVER_POP + slot_id);
|
|
mui_menu_items_t * items = mui_popupmenu_get_items(c);
|
|
int pop_val = mui_control_get_value(c);
|
|
mui_menu_item_t * item = &items->e[pop_val];
|
|
// printf("%s popup slot %d %4.4s '%s'\n", __func__,
|
|
// slot_id,
|
|
// (char*)&item->uid, item->title);
|
|
mui_control_t * c2 = mui_control_get_by_id(w,
|
|
MII_SLOT_DRIVER_CONF + slot_id);
|
|
if (c2) {
|
|
mui_control_set_state(c2,
|
|
_mii_slot_drivers[pop_val].has_config ?
|
|
MUI_CONTROL_STATE_NORMAL :
|
|
MUI_CONTROL_STATE_DISABLED);
|
|
}
|
|
if (cf->slot[slot_id-1].driver != item->uid) {
|
|
cf->slot[slot_id-1].driver = item->uid;
|
|
memset(&cf->slot[slot_id-1].conf, 0,
|
|
sizeof(cf->slot[slot_id-1].conf));
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
_mii_config_conf_to_win(
|
|
mii_ui_machine_config_t * m)
|
|
{
|
|
mui_window_t * w = &m->win;
|
|
mii_machine_config_t * cf = &m->config;
|
|
|
|
// mui_control_set_value(mui_control_get_by_id(w, MII_SLOT_REBOOT),
|
|
// cf->reboot_on_load);
|
|
mui_control_set_value(mui_control_get_by_id(w, MII_SLOT_TITAN),
|
|
cf->titan_accelerator);
|
|
mui_control_set_value(mui_control_get_by_id(w, MII_SLOT_NSC),
|
|
cf->no_slot_clock);
|
|
|
|
for (int slot_id = 1; slot_id < 8; slot_id++) {
|
|
mui_control_t * c = mui_control_get_by_id(
|
|
w, MII_SLOT_DRIVER_POP + slot_id);
|
|
mui_control_set_value(c, cf->slot[slot_id-1].driver);
|
|
|
|
mui_control_t * c2 = mui_control_get_by_id(w,
|
|
MII_SLOT_DRIVER_CONF + slot_id);
|
|
if (c2) {
|
|
mui_control_set_state(c2,
|
|
_mii_slot_drivers[cf->slot[slot_id-1].driver].has_config ?
|
|
MUI_CONTROL_STATE_NORMAL :
|
|
MUI_CONTROL_STATE_DISABLED);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
_mii_config_sub_save_cb(
|
|
mui_window_t *win, // the sub window/dialog
|
|
void * cb_param,
|
|
uint32_t what,
|
|
void * param)
|
|
{
|
|
// mii_ui_machine_config_t * m = cb_param;
|
|
printf("%s %4.4s\n", __func__, (char*)&what);
|
|
|
|
return 0;
|
|
}
|
|
|
|
mui_window_t *
|
|
mii_mui_configure_slot(
|
|
struct mui_t *mui,
|
|
mii_machine_config_t *config,
|
|
int slot_id)
|
|
{
|
|
printf("%s config slot %d\n", __func__, slot_id);
|
|
mui_window_t * res = NULL;
|
|
switch (config->slot[slot_id].driver) {
|
|
case MII_SLOT_DRIVER_SMARTPORT: {
|
|
config->slot[slot_id].conf.smartport.slot_id = slot_id;
|
|
res = mii_mui_load_2dsk(mui,
|
|
&config->slot[slot_id].conf.smartport,
|
|
MII_2DSK_SMARTPORT);
|
|
} break;
|
|
case MII_SLOT_DRIVER_DISK2: {
|
|
config->slot[slot_id].conf.disk2.slot_id = slot_id;
|
|
res = mii_mui_load_2dsk(mui,
|
|
&config->slot[slot_id].conf.disk2,
|
|
MII_2DSK_DISKII);
|
|
} break;
|
|
case MII_SLOT_DRIVER_ROM1MB: {
|
|
config->slot[slot_id].conf.rom1mb.slot_id = slot_id;
|
|
res = mii_mui_load_1mbrom(mui,
|
|
&config->slot[slot_id].conf.rom1mb);
|
|
} break;
|
|
case MII_SLOT_DRIVER_SUPERSERIAL: {
|
|
mui_alert(mui, C2_PT(0,0),
|
|
"Not implemented yet",
|
|
"SSC is not implemented yet!\n"
|
|
"Driver is present just a placeholder, sorry.",
|
|
MUI_ALERT_FLAG_OK);
|
|
} break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
static int
|
|
_mii_config_slot_action_cb(
|
|
mui_control_t * c, // control here
|
|
void * cb_param, // mii_ui_machine_config_t
|
|
uint32_t what,
|
|
void * param) // not used
|
|
{
|
|
printf("%s %4.4s\n", __func__, (char*)&what);
|
|
mii_ui_machine_config_t * m = cb_param;
|
|
uint32_t uid = mui_control_get_uid(c);
|
|
|
|
switch (what) {
|
|
case MUI_CONTROL_ACTION_SELECT:
|
|
printf("%s control %4.4s\n", __func__, (char*)&uid);
|
|
switch (uid) {
|
|
case MII_SLOT_SAVE: {
|
|
// save the config
|
|
printf("%s save\n", __func__);
|
|
_mii_config_win_to_conf(m);
|
|
if (m->dst)
|
|
*m->dst = m->config;
|
|
mui_window_action(&m->win, MII_MUI_SLOTS_SAVE, m->dst);
|
|
mui_window_dispose(&m->win);
|
|
} break;
|
|
case MII_SLOT_CANCEL: {
|
|
// cancel the config
|
|
printf("%s cancel\n", __func__);
|
|
mui_window_dispose(&m->win);
|
|
} break;
|
|
case MII_SLOT_DEFAULT: {
|
|
// set the default config
|
|
printf("%s default\n", __func__);
|
|
m->config = _default_config;
|
|
_mii_config_conf_to_win(m);
|
|
} break;
|
|
#if 0
|
|
case MII_SLOT_REBOOT: {
|
|
// reboot the machine
|
|
printf("%s reboot\n", __func__);
|
|
m->config.reboot_on_load = !m->config.reboot_on_load;
|
|
} break;
|
|
#endif
|
|
case MII_SLOT_NSC: {
|
|
// no slot clock
|
|
printf("%s nsc\n", __func__);
|
|
m->config.no_slot_clock = !m->config.no_slot_clock;
|
|
} break;
|
|
case MII_SLOT_TITAN: {
|
|
// titan accelerator
|
|
printf("%s titan\n", __func__);
|
|
m->config.titan_accelerator = !m->config.titan_accelerator;
|
|
} break;
|
|
case MII_SLOT_DRIVER_CONF + 1 ... MII_SLOT_DRIVER_CONF + 7: {
|
|
// configure a slot
|
|
int slot_id = uid - MII_SLOT_DRIVER_CONF - 1;
|
|
printf("%s config slot %d\n", __func__, slot_id);
|
|
switch (m->config.slot[slot_id].driver) {
|
|
case MII_SLOT_DRIVER_SMARTPORT: {
|
|
m->config.slot[slot_id].conf.smartport.slot_id = slot_id;
|
|
mui_window_set_action(
|
|
mii_mui_load_2dsk(m->win.ui,
|
|
&m->config.slot[slot_id].conf.smartport,
|
|
MII_2DSK_SMARTPORT),
|
|
_mii_config_sub_save_cb, m);
|
|
} break;
|
|
case MII_SLOT_DRIVER_DISK2: {
|
|
m->config.slot[slot_id].conf.disk2.slot_id = slot_id;
|
|
mui_window_set_action(
|
|
mii_mui_load_2dsk(m->win.ui,
|
|
&m->config.slot[slot_id].conf.disk2,
|
|
MII_2DSK_DISKII),
|
|
_mii_config_sub_save_cb, m);
|
|
} break;
|
|
case MII_SLOT_DRIVER_ROM1MB: {
|
|
m->config.slot[slot_id].conf.rom1mb.slot_id = slot_id;
|
|
mui_window_set_action(
|
|
mii_mui_load_1mbrom(m->win.ui,
|
|
&m->config.slot[slot_id].conf.rom1mb),
|
|
_mii_config_sub_save_cb, m);
|
|
} break;
|
|
case MII_SLOT_DRIVER_SUPERSERIAL: {
|
|
mui_alert(m->win.ui, C2_PT(0,0),
|
|
"Not implemented yet",
|
|
"SSC is not implemented yet!\n"
|
|
"Driver is present just a placeholder, sorry.",
|
|
MUI_ALERT_FLAG_OK);
|
|
} break;
|
|
}
|
|
} break;
|
|
}
|
|
break;
|
|
case MUI_CONTROL_ACTION_VALUE_CHANGED:
|
|
// a popup menu changed
|
|
printf("%s popup %4.4s\n", __func__, (char*)&uid);
|
|
switch (uid) {
|
|
case MII_SLOT_DRIVER_POP + 1 ... MII_SLOT_DRIVER_POP + 7: {
|
|
_mii_config_win_to_conf(m);
|
|
} break;
|
|
}
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
struct mui_window_t *
|
|
mii_mui_configure_slots(
|
|
struct mui_t *mui,
|
|
mii_machine_config_t *config)
|
|
{
|
|
mui_t *ui = mui;
|
|
|
|
mui_window_t *w = mui_window_get_by_id(mui, MII_SLOT_WINDOW_ID);
|
|
if (w) {
|
|
mui_window_select(w);
|
|
return w;
|
|
}
|
|
c2_pt_t where = {};
|
|
c2_rect_t wpos = C2_RECT_WH(where.x, where.y, 520, 480);
|
|
if (where.x == 0 && where.y == 0)
|
|
c2_rect_offset(&wpos,
|
|
(ui->screen_size.x / 2) - (c2_rect_width(&wpos) / 2),
|
|
(ui->screen_size.y * 0.4) - (c2_rect_height(&wpos) / 2));
|
|
w = mui_window_create(mui,
|
|
wpos,
|
|
NULL, 0,
|
|
"Configure " MUI_GLYPH_IIE " Slots",
|
|
sizeof(mii_ui_machine_config_t));
|
|
mui_window_set_id(w, MII_SLOT_WINDOW_ID);
|
|
mii_ui_machine_config_t *m = (mii_ui_machine_config_t*)w;
|
|
|
|
mui_control_t * c = NULL;
|
|
c2_rect_t cf;
|
|
cf = C2_RECT_WH(0, 0, 120, 40);
|
|
c2_rect_left_of(&cf, c2_rect_width(&w->content), 20);
|
|
c2_rect_top_of(&cf, c2_rect_height(&w->content), 20);
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_DEFAULT,
|
|
"Reboot", MII_SLOT_SAVE);
|
|
c->key_equ = MUI_KEY_EQU(0, 13);
|
|
c2_rect_left_of(&cf, cf.l, 20);
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_NORMAL,
|
|
"Cancel", MII_SLOT_CANCEL);
|
|
c->key_equ = MUI_KEY_EQU(0, 27);
|
|
|
|
c2_rect_right_of(&cf, 0, 20);
|
|
cf.r = cf.l + 200;
|
|
#if 0
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_CHECKBOX,
|
|
"Reboot Now", MII_SLOT_REBOOT);
|
|
#endif
|
|
c2_rect_top_of(&cf, cf.t, 36);
|
|
cf.r = cf.l + 120;
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_NORMAL,
|
|
"Default", MII_SLOT_DEFAULT);
|
|
c2_rect_right_of(&cf, cf.r, 30);
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_CHECKBOX,
|
|
"No Slot Clock", MII_SLOT_NSC);
|
|
c2_rect_right_of(&cf, cf.r, 30);
|
|
cf.r = cf.l + 200;
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_CHECKBOX,
|
|
"Titan Accelerator", MII_SLOT_TITAN);
|
|
|
|
c2_rect_bottom_of(&cf, cf.b, 16);
|
|
cf.l = 60;
|
|
cf.r = c2_rect_width(&w->content) - 60;
|
|
cf.b = cf.t + 1;
|
|
c = mui_separator_new(w, cf);
|
|
|
|
c2_rect_t slot_line_rect = C2_RECT_WH(0, 0, 500, 34);
|
|
cf = slot_line_rect;
|
|
cf.r = cf.l + 50;
|
|
c = mui_textbox_new(w, cf, "Slot", NULL,
|
|
MUI_TEXT_ALIGN_RIGHT | MUI_TEXT_ALIGN_MIDDLE);
|
|
c2_rect_right_of(&cf, cf.r, 6);
|
|
cf.r = cf.l + 240;
|
|
c = mui_textbox_new(w, cf, "Driver", NULL,
|
|
MUI_TEXT_ALIGN_CENTER | MUI_TEXT_ALIGN_MIDDLE);
|
|
c2_rect_right_of(&cf, cf.r, 30);
|
|
cf.r = cf.l + 150;
|
|
c = mui_textbox_new(w, cf, "Config", NULL,
|
|
MUI_TEXT_ALIGN_CENTER | MUI_TEXT_ALIGN_MIDDLE);
|
|
|
|
c2_rect_offset(&slot_line_rect, 0, 36);
|
|
for (int i = 1; i < 8; i++) {
|
|
cf = slot_line_rect;
|
|
cf.r = cf.l + 50;
|
|
char idx[16];
|
|
sprintf(idx, "%d:", i);
|
|
c = mui_textbox_new(w, cf, idx, NULL,
|
|
MUI_TEXT_ALIGN_RIGHT | MUI_TEXT_ALIGN_MIDDLE);
|
|
c2_rect_right_of(&cf, cf.r, 6);
|
|
cf.r = cf.l + 240;
|
|
c = mui_popupmenu_new(w, cf,
|
|
"Popup", MII_SLOT_DRIVER_POP + i);
|
|
mui_menu_items_t * items = mui_popupmenu_get_items(c);
|
|
mui_menu_items_clear(items);
|
|
for (int j = 0; _mii_slot_drivers[j].label; j++) {
|
|
mui_menu_item_t i = {
|
|
.title = strdup(_mii_slot_drivers[j].label),
|
|
.uid = j,
|
|
};
|
|
mui_menu_items_push(items, i);
|
|
}
|
|
mui_menu_item_t z = {};
|
|
mui_menu_items_push(items, z);
|
|
mui_popupmenu_prepare(c);
|
|
|
|
c2_rect_right_of(&cf, cf.r, 30);
|
|
cf.r = cf.l + 150;
|
|
c = mui_button_new(w,
|
|
cf, MUI_BUTTON_STYLE_NORMAL,
|
|
"Config…", MII_SLOT_DRIVER_CONF + i);
|
|
c2_rect_offset(&slot_line_rect, 0, 38);
|
|
}
|
|
c = NULL;
|
|
TAILQ_FOREACH(c, &w->controls, self) {
|
|
if (mui_control_get_uid(c) == 0)
|
|
continue;
|
|
mui_control_set_action(c, _mii_config_slot_action_cb, m);
|
|
}
|
|
m->dst = config;
|
|
if (config) {
|
|
if (config->load_defaults)
|
|
m->config = _default_config;
|
|
else
|
|
m->config = *config;
|
|
}
|
|
_mii_config_conf_to_win(m);
|
|
return w;
|
|
}
|