#else
out_message(_T("FD: %s"), floppy_disk_status[drv].path);
#endif
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ mess |= ((is_floppy_disk_protected(drv)) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
osdcall_string(EMU_MEDIA_TYPE::FLOPPY_DISK | (floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
- drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
- floppy_disk_status[drv].path);
- osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
- drv,
- EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT,
- (is_floppy_disk_protected(drv)) ? UINT64_MAX : 0);
+ drv,
+ mess,
+ floppy_disk_status[drv].path);
}
}
#endif
#else
out_message(_T("QD: %s"), quick_disk_status[drv].path);
#endif
+ // ToDo: Write Protect
osdcall_string(EMU_MEDIA_TYPE::QUICK_DISK,
drv,
EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
#else
out_message(_T("CMT: %s"), tape_status[drv].path);
#endif
+ // ToDo: Write protect.
+ EMU_MESSAGE_TYPE::type_t mess;
+ mess = (tape_status[drv].play) ? EMU_MESSAGE_TYPE::PLAY : EMU_MESSAGE_TYPE::RECORD;
+ mess |= EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
osdcall_string(EMU_MEDIA_TYPE::TAPE,
drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ mess,
(_TCHAR *)tape_status[drv].path);
}
}
#else
out_message(_T("Bubble: %s"), bubble_casette_status[drv].path);
#endif
+ // ToDo: Write protect.
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ mess |= ((is_bubble_casette_protected(drv)) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
+
osdcall_string(EMU_MEDIA_TYPE::BUBBLE_CASETTE | (bubble_casette_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ mess,
(_TCHAR *)bubble_casette_status[drv].path);
}
}
} else {
vm->open_cart(drv, cart_status[drv].path);
}
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ // ToDo: write protect
+ osdcall_string(EMU_MEDIA_TYPE::CARTRIDGE,
+ drv,
+ mess,
+ cart_status[drv].path);
+
}
}
#endif
for(int drv = 0; drv < USE_FLOPPY_DISK; drv++) {
if(floppy_disk_status[drv].path[0] != _T('\0')) {
vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ mess |= ((is_floppy_disk_protected(drv)) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
osdcall_string(EMU_MEDIA_TYPE::FLOPPY_DISK | (floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
- drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
- floppy_disk_status[drv].path);
- osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
- drv,
- EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT,
- (is_floppy_disk_protected(drv)) ? UINT64_MAX : 0);
+ drv,
+ mess,
+ floppy_disk_status[drv].path);
}
}
#endif
for(int drv = 0; drv < USE_QUICK_DISK; drv++) {
if(quick_disk_status[drv].path[0] != _T('\0')) {
vm->open_quick_disk(drv, quick_disk_status[drv].path);
+
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ // ToDo: write protect
+ osdcall_string(EMU_MEDIA_TYPE::QUICK_DISK,
+ drv,
+ mess,
+ quick_disk_status[drv].path);
}
}
#endif
for(int drv = 0; drv < USE_HARD_DISK; drv++) {
if(hard_disk_status[drv].path[0] != _T('\0')) {
vm->open_hard_disk(drv, hard_disk_status[drv].path);
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ osdcall_string(EMU_MEDIA_TYPE::HARD_DISK,
+ drv,
+ mess,
+ quick_disk_status[drv].path);
}
}
#endif
if(tape_status[drv].path[0] != _T('\0')) {
if(tape_status[drv].play) {
vm->play_tape(drv, tape_status[drv].path);
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ osdcall_string(EMU_MEDIA_TYPE::HARD_DISK,
+ drv,
+ mess,
+ tape_status[drv].path);
} else {
tape_status[drv].path[0] = _T('\0');
}
drv,
EMU_MESSAGE_TYPE::MEDIA_REMOVED,
0);
- osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
- drv,
- EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT,
- 0);
} else if(floppy_disk_status[drv].wait_count == 0) {
vm->open_floppy_disk(drv, file_path, bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
#if USE_FLOPPY_DISK > 1
#else
out_message(_T("FD: %s"), file_path);
#endif
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ mess |= ((is_floppy_disk_protected(drv)) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
osdcall_string(EMU_MEDIA_TYPE::FLOPPY_DISK | (bank & EMU_MEDIA_TYPE::MULTIPLE_SLOT_MASK),
drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ mess,
(_TCHAR *)file_path);
- osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
- drv,
- EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT,
- (is_floppy_disk_protected(drv)) ? UINT64_MAX : 0);
}
my_tcscpy_s(floppy_disk_status[drv].path, _MAX_PATH, file_path);
floppy_disk_status[drv].bank = bank;
drv,
EMU_MESSAGE_TYPE::MEDIA_REMOVED,
0);
- osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
- drv,
- EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT,
- 0);
}
}
if(drv < USE_FLOPPY_DISK) {
vm->is_floppy_disk_protected(drv, value);
}
+ EMU_MESSAGE_TYPE::type_t mess =
+ (value) ?
+ (EMU_MESSAGE_TYPE::WRITE_PROTECT | EMU_MESSAGE_TYPE::MEDIA_OTHERS)
+ : EMU_MESSAGE_TYPE::MEDIA_OTHERS;
osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
drv,
- EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT,
- (is_floppy_disk_protected(drv)) ? UINT64_MAX : 0);
+ mess,
+ 0);
}
bool EMU::is_floppy_disk_protected(int drv)
#endif
osdcall_string(EMU_MEDIA_TYPE::TAPE,
drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED | EMU_MESSAGE_TYPE::RECORD,
(_TCHAR*)file_path);
}
my_tcscpy_s(tape_status[drv].path, _MAX_PATH, file_path);
{
if(drv < USE_TAPE) {
vm->push_play(drv);
+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ EMU_MESSAGE_TYPE::TAPE_PLAY,
+ 0);
}
}
{
if(drv < USE_TAPE) {
vm->push_stop(drv);
+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ EMU_MESSAGE_TYPE::TAPE_STOP,
+ 0);
}
}
{
if(drv < USE_TAPE) {
vm->push_fast_forward(drv);
+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ EMU_MESSAGE_TYPE::TAPE_FF,
+ 0);
}
}
{
if(drv < USE_TAPE) {
vm->push_fast_rewind(drv);
+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ EMU_MESSAGE_TYPE::TAPE_REW,
+ 0);
}
}
{
if(drv < USE_TAPE) {
vm->push_apss_forward(drv);
+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ EMU_MESSAGE_TYPE::TAPE_APSS_FF,
+ 0);
}
}
{
if(drv < USE_TAPE) {
vm->push_apss_rewind(drv);
+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
+ drv,
+ EMU_MESSAGE_TYPE::TAPE_APSS_REW,
+ 0);
}
}
#endif
} else {
vm->load_binary(drv, file_path);
}
+ osdcall_string(EMU_MEDIA_TYPE::BINARY,
+ drv,
+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED | EMU_MESSAGE_TYPE::LOAD,
+ (_TCHAR*)file_path);
#if USE_BINARY_FILE > 1
out_message(_T("Load Binary%d: %s"), drv + BASE_BINARY_FILE_NUM, file_path);
#else
#else
out_message(_T("Save Binary: %s"), file_path);
#endif
+ osdcall_string(EMU_MEDIA_TYPE::BINARY,
+ drv,
+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED | EMU_MESSAGE_TYPE::SAVE,
+ (_TCHAR*)file_path);
}
}
#else
out_message(_T("Bubble: %s"), file_path);
#endif
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_MOUNTED;
+ mess |= ((is_bubble_casette_protected(drv)) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
osdcall_string(EMU_MEDIA_TYPE::BUBBLE_CASETTE | (bank & EMU_MEDIA_TYPE::MULTIPLE_SLOT_MASK),
drv,
- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
+ mess,
(_TCHAR*)file_path);
}
my_tcscpy_s(bubble_casette_status[drv].path, _MAX_PATH, file_path);
{
if(drv < USE_BUBBLE) {
vm->is_bubble_casette_protected(drv, flag);
+ EMU_MESSAGE_TYPE::type_t mess = EMU_MESSAGE_TYPE::MEDIA_OTHERS;
+ mess |= ((flag) ? EMU_MESSAGE_TYPE::WRITE_PROTECT : 0);
+ osdcall_int(EMU_MEDIA_TYPE::BUBBLE_CASETTE,
+ drv,
+ mess,
+ 0);
return;
} else {
return;
BINARY = 1 << 16,
BUBBLE_CASETTE = 2 << 16,
CARTRIDGE = 3 << 16,
- COMPACT_DISC = 4 << 16,
+ COMPACT_DISC = 4 << 16,
FLOPPY_DISK = 5 << 16,
HARD_DISK = 6 << 16,
LASER_DISC = 7 << 16,
QUICK_DISK = 8 << 16,
TAPE = 9 << 16,
-
+
AUDIO = (28 << 16),
VIDEO = (29 << 16),
ANY_MEDIA = (127 << 16),
UI_MEDIA_MASK = (127 << 16),
- UI_MESSAGE_MASK = ((0xffffffff) << 32),
EMU_SLOT_MASK = 0x7f,
MULTIPLE_SLOT_MASK = 0xff,
- END = UINT64_MAX
+ END = INT_MAX
};
const type_t MULTIPLE_SLOT_DETECT_MASK = ((~EMU_SLOT_MASK) & MULTIPLE_SLOT_MASK);
namespace EMU_MESSAGE_TYPE {
typedef uint64_t type_t ;
+
enum {
- NONE,
- MEDIA_MOUNTED,
- MEDIA_REMOVED,
- MEDIA_SUSPENDED,
- VIRT_MEDIA_SELECTED,
- MEDIA_WRITE_PROTECT,
- MESSAGE_END
+ NONE = 0,
+ PLAY = 0,
+ LOAD = 0,
+ RECORD = 1,
+ SAVE = 1,
+ STOP = 2,
+ PAUSE = (1 << 2),
+ UNPAUSE = (2 << 2),
+ FAST_FORWARD = (2 << 4),
+ FAST_REWIND = (3 << 4),
+ APSS_FORWARD = (6 << 4),
+ APSS_REWIND = (7 << 4),
+ WRITE_PROTECT = (8 << 4),
+
+ MEDIA_MOUNTED = (1 << 8),
+ MEDIA_REMOVED = (2 << 8),
+ MEDIA_OTHERS = (0 << 8),
+ VIRT_MEDIA_SELECTED = (4 << 8),
+
+ TYPE_MEDIA = (0x00 << 24),
+ TYPE_MESSAGE = (0x10 << 24),
+ TYPE_MASK = (0xff << 24),
+
+ MEDIA_MASK = 0x0000ffff,
+ MEDIA_PLAYREC_MASK = 0x01,
+ MEDIA_STOP_MASK = 0x02,
+ MEDIA_PAUSE_MASK = (3 << 2),
+ MEDIA_DIRECTION_MASK = (1 << 4),
+ MEDIA_FF_APSS_MASK = (4 << 4),
+ MEDIA_FFREW_MASK = (MEDIA_DIRECTION_MASK | MEDIA_FF_APSS_MASK),
+ MEDIA_MODE_MASK = (0xff << 8),
+
+ END = INT_MAX
};
+ const type_t MOUNT = MEDIA_MOUNTED | 0;
+ const type_t EJECT = MEDIA_REMOVED | 0;
+ const type_t MOUNT_PLAY = MEDIA_MOUNTED | PLAY;
+ const type_t MOUNT_RECORD = MEDIA_MOUNTED | RECORD;
+
+ const type_t TOGGLE_PAUSE = PAUSE | UNPAUSE;
+ const type_t TAPE_FF = MEDIA_OTHERS | FAST_FORWARD;
+ const type_t TAPE_REW = MEDIA_OTHERS | FAST_REWIND;
+ const type_t TAPE_APSS_FF = MEDIA_OTHERS | APSS_FORWARD;
+ const type_t TAPE_APSS_REW = MEDIA_OTHERS | APSS_REWIND;
+ const type_t TAPE_PLAY = MEDIA_OTHERS | PLAY;
+ const type_t TAPE_STOP = MEDIA_OTHERS | STOP;
+
+ const type_t PROTECT_ON = WRITE_PROTECT;
+ const type_t PROTECT_OFF = 0;
+
}
void Ui_MainWindowBase::do_ui_write_protect_floppy_disk(int drive, quint64 flag)
{
if(drive < 0) return;
-
+
std::shared_ptr<USING_FLAGS>p = using_flags;
if(p.get() == nullptr) return;
if(!(p->is_use_fd()) || (p->get_max_drive() <= drive)) return;
if(menu_fds[drive] != nullptr) return;
-
- if(flag != 0) {
+
+ if((flag & EMU_MESSAGE_TYPE::WRITE_PROTECT) != 0) {
menu_fds[drive]->do_set_write_protect(true);
} else {
menu_fds[drive]->do_set_write_protect(false);
}
extern const _TCHAR* DLL_PREFIX_I get_parent_dir(const _TCHAR* file);
-int Ui_MainWindowBase::set_recent_disk(int drv, int num)
+int Ui_MainWindowBase::set_recent_disk(int drv, int num)
{
QString s_path;
{
if(fname.length() <= 0) return;
if(using_flags->get_max_drive() <= drv) return;
-
+
_TCHAR path_shadow[_MAX_PATH] = {0};
strncpy(path_shadow, fname.toLocal8Bit().constData(), _MAX_PATH - 1);
if(!(FILEIO::IsFileExisting(path_shadow))) return;
UPDATE_D88_LIST(drv, listD88[drv]);
}
menu_fds[drv]->do_update_inner_media(listD88[drv], bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
-
+
}
void Ui_MainWindowBase::_open_disk(int drv, const QString fname)
if(fname.length() <= 0) return;
if(using_flags->get_max_drive() <= drv) return;
- if(!(FILEIO::IsFileExisting(fname.toLocal8Bit().constData()))) return; // File not found.
+ if(!(FILEIO::IsFileExisting(fname.toLocal8Bit().constData()))) return; // File not found.
// drv = drv & 7;
strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
emit sig_close_floppy_disk(drv);
}
}
-void Ui_MainWindowBase::do_set_write_protect_floppy_disk(int drive, bool flag)
-{
- if(drive < 0) return;
- if(menu_fds[drive] == nullptr) return;
-
- std::shared_ptr<USING_FLAGS>p = using_flags;
- if(p.get() == nullptr) return;
- if(!(p->is_use_fd()) || (p->get_max_drive() <= drive)) return;
-
- menu_fds[drive]->do_set_write_protect(flag);
-}
void Ui_MainWindowBase::do_update_d88_list(int drv, int bank)
{
namespace CSP_Ui_MainWidgets {
struct DipSwitchPair { // config.dipswitch
uint32_t data; // DipSwitch data
- uint32_t mask; // DipSwitch bit mask
+ uint32_t mask; // DipSwitch bit mask
};
struct MachineFeaturePair { // config.machine_features[devnum]
int devnum; // Index of device.
SET_ACTION_SINGLE_DIPSWITCH_NEGATIVE(__action,__dipsw_val_mask,__condval); \
connect(__action, __signal1, this, __slot1); \
}
-
+
#define SET_ACTION_ANYVALUES(__action,__vars) { \
__action = new Action_Control(this, using_flags); \
__action->setCheckable(true); \
connect(__action, SIGNAL(triggered()), this, SLOT(do_browse_document())); \
__menu->addAction(__action); \
}
-
+
#define SET_ACTION_CONTROL_ARRAY(__start,__end, \
__parent,__using_flags, \
Action_Control *actionScanLine;
Action_Control *actionGLScanLineHoriz;
Action_Control *actionGLScanLineVert;
-
+
Action_Control *actionRotate[4];
Action_Control *actionCRT_Filter;
Action_Control *actionOpenGL_Filter;
Action_Control *actionHelp_History_MR_TANAM;
Action_Control *actionHelp_License;
Action_Control *actionHelp_License_JP;
-
+
// Led: OSD.
bool flags_led[32];
bool flags_led_bak[32];
uint32_t osd_led_data;
// Inner functions
-
+
void ConfigCpuSpeed(void);
void ConfigControlMenu(void);
void connectActions_ControlMenu(void);
void CreateEmulatorMenu(void);
void ConfigEmulatorMenu(void);
-
+
void CreateFloppyMenu(int drv, int drv_base);
void CreateFloppyPulldownMenu(int drv);
void ConfigFloppyMenuSub(int drv);
virtual bool GetBubbleCasetteIsProtected(int drv) { return false; }
virtual QString GetBubbleB77FileName(int drv) { return QString::fromUtf8(""); }
virtual QString GetBubbleB77BubbleName(int drv, int num) { return QString::fromUtf8(""); }
-
+
void CreateCMTMenu(int drive, int drv_base);
void ConfigCMTMenu(void);
-
+
void ConfigQuickDiskMenu(void);
void ConfigQuickDiskMenuSub(int drv);
void CreateQuickDiskPulldownMenu(int drv);
void ConfigCDROMMenu(void);
void ConfigCDROMMenuSub(void);
void CreateCDROMPulldownMenu(void);
-
+
void CreateLaserdiscMenu(int drv, int drv_base);
void ConfigLaserdiscMenu(void);
void ConfigLaserdiscMenuSub(void);
QMainWindow *MainWindow;
QApplication *CoreApplication;
QMap<uint32_t, QString>phys_key_name_map; // VK, NAME
-
+
GLDrawClass *graphicsView;
CSP_DockDisks *driveData;
QWidget *pCentralWidget;
QTimer *statusUpdateTimer;
QTimer *ledUpdateTimer;
-
+
const float screen_multiply_table[16] = {
0.5, 1.0, 1.5, 2.0,
2.25, 2.5, 3.0, 3.5,
QStringList listBINs[8];
QStringList listFDs[16];
QStringList listHDDs[16];
-
+
QStringList listD88[16];
QStringList listBubbles[8];
QStringList listB77[8];
QMenu *menuPrintDevice;
QMenu *menuSerialDevice;
QMenu *menu_SetFixedCpu;
-
+
Action_Control *actionDeviceType[16];
Action_Control *actionKeyboardType[16];
Action_Control *actionJoystickType[16];
Action_Control *actionSerialDevice[16];
Action_Control *action_SetRenderPlatform[MAX_RENDER_PLATFORMS];
-
+
Action_Control *actionStart_Record_Movie;
Action_Control *actionStop_Record_Movie;
Action_Control *action_SetupMovie; // 15, 24, 30, 60
QMenu *menuMonitorType;
QActionGroup *actionGroup_MonitorType;
Action_Control *actionMonitorType[16];
-
- // Menus
+
+ // Menus
QMenu *menuControl;
QMenu *menuState;
QMenu *menuCopy_Paste;
QMenu *menuScreenSize;
QMenu *menuScreen_Render;
QMenu *menuScreen_Rotate;
-
+
QMenu *menuCpuType;
QMenu *menuBootMode;
QMenu *menuSound;
QMenu *menuHelp_Histories;
QMenu *menuMachineFeatures[32];
-
+
Menu_FDClass *menu_fds[16];
Menu_QDClass *menu_QDs[8];
Menu_CMTClass *menu_CMT[8];
QLabel *cdrom_StatusBar;
QString osd_str_cdrom;
-
+
QLabel *laserdisc_StatusBar;
QString osd_str_laserdisc;
QLabel *bubble_StatusBar[8];
class DrawThreadClass *hDrawEmu;
class JoyThreadClass *hRunJoy;
class MOVIE_SAVER *hSaveMovieThread;
-
+
int max_vm_nodes;
bool ui_retranslate_completed;
bool about_to_close;
GLDrawClass *getGraphicsView(void) { return graphicsView; }
QStatusBar *getStatusBar(void) { return statusbar;}
QImage *getBitmapImage(void) { return bitmapImage; }
-
+
virtual void OnMainWindowClosed(void);
// Basic Action Definition
void OnCpuPower(int mode);
virtual void rise_movie_dialog(void);
void do_set_state_saving_movie(bool state);
void set_osd_virtual_media(bool f);
-
+
virtual void OnOpenDebugger(void);
virtual void OnCloseDebugger(void);
- void doBeforeCloseMainWindow(void);
+ void doBeforeCloseMainWindow(void);
void set_gl_crt_filter(bool);
void do_set_cpu_power(void)
{
QAction *cp = qobject_cast<QAction*>(QObject::sender());
if(cp == nullptr) return;
int pw = cp->data().value<int>();
-
+
OnCpuPower(pw);
}
virtual void on_actionExit_triggered();
void do_open_cdrom(int drv, QString path);
void do_swap_cdaudio_byteorder(int drv, bool value);
- int set_recent_laserdisc(int drv, int num);
- void do_eject_laserdisc(int drv);
+ int set_recent_laserdisc(int drv, int num);
+ void do_eject_laserdisc(int drv);
void do_open_laserdisc(int drv, QString path);
void CreateBinaryMenu(int drv, int drv_base);
void _open_binary_load(int drive, const QString fname);
void _open_binary_save(int drive, const QString fname);
- int set_recent_quick_disk(int drive, int num);
+ int set_recent_quick_disk(int drive, int num);
int write_protect_Qd(int drv, bool flag);
void _open_quick_disk(int drv, const QString fname);
void eject_Qd(int drv);
void _open_cart(int drv, const QString fname);
void eject_cmt(int drv);
-
+
void do_change_boot_mode();
void do_change_cpu_type();
-
+
void do_write_protect_cmt(int drv, bool flag);
int set_recent_cmt(int drv, int num);
void set_wave_shaper(int drive, bool f);
virtual int set_recent_bubble(int drv, int num) { return 0; }
virtual void _open_bubble(int drv, const QString fname) { }
virtual void eject_bubble(int drv) { }
-
+
void _open_disk(int drv, const QString fname);
int set_recent_disk(int, int);
- void do_set_write_protect_floppy_disk(int drive, bool flag);
void _open_hard_disk(int drv, const QString fname);
void do_update_recent_hard_disk(int);
void do_set_sound_tape_signal(bool f);
void do_set_sound_tape_voice(bool f);
void do_set_host_sound_output_device(void);
- void do_set_host_sound_name(int num, QString sname);
+ void do_set_host_sound_name(int num, QString sname);
void set_monitor_type(void);
void message_status_bar(QString);
void resize_statusbar(int w, int h);
void do_set_sound_files_relay(bool f);
void do_set_conslog(bool);
void do_set_syslog(bool);
- void do_update_device_node_name(int id, const _TCHAR *name);
+ void do_update_device_node_name(int id, const _TCHAR *name);
void do_set_dev_log_to_console(bool f);
void do_set_dev_log_to_syslog(bool f);
void do_set_roma_kana(bool f);
void do_ui_write_protect_floppy_disk(int drv, quint64 flag);
void do_set_emulate_cursor_as(void);
- void do_set_logging_fdc(bool onoff);
+ void do_set_logging_fdc(bool onoff);
void do_set_separate_thread_draw(bool f);
void do_set_print_cpu_statistics(bool flag);
// ToDo: GUI
void do_set_single_dipswitch(bool f);
void do_set_single_dipswitch_negative(bool f);
void do_set_multi_dipswitch();
-
+
void do_clear_sound_output_list();
void do_update_sound_output_list();
void do_append_sound_output_list(QString _name);
int on_insert_fd(int);
int on_eject_fd(int);
int sig_open_disk(int, QString);
-
+
int closed(void);
int sig_notify_power_off(void);
int sig_quit_all(void);
int sig_resize_osd(int);
int sig_screen_multiply(double);
int sig_update_master_volume(int);
-
+
int sig_write_protect_floppy_disk(int drv, bool flag);
int sig_open_floppy_disk(int, QString, int);
int sig_close_floppy_disk(int);
int sig_set_roma_kana(bool);
int quit_debugger_thread(void);
int sig_quit_widgets(void);
-
+
int sig_emu_thread_to_fixed_cpu(int);
int sig_add_keyname_table(uint32_t, QString);
int sig_start_draw_thread(void);
int sig_emu_launched(void);
int sig_glv_set_fixed_size(int, int);
-
+
int sig_set_device_node_log(int, int, int, bool);
int sig_set_device_node_log(int, int, bool*, int, int);
int sig_set_device_node_log(int, int, int*, int, int);
return (Sint16 *)vm->create_sound(extra_frames);
}
+void OSD_BASE::osdcall_message_str(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, QString message)
+{
+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
+ uint64_t _slot = media_type & 255;
+}
+
+void OSD_BASE::osdcall_message_int(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, int64_t data)
+{
+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
+ uint64_t _slot = media_type & 255;
+}
+
+void OSD_BASE::osdcall_mount(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, QString path)
+{
+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
+ uint64_t _slot = media_type & 255;
+ switch(_type) {
+ case EMU_MEDIA_TYPE::BINARY :
+ if((message_type & EMU_MESSAGE_TYPE::MEDIA_PLAYREC_MASK) == 0)
+ {
+ emit sig_ui_binary_loading_insert_history(drive, path);
+ } else {
+ emit sig_ui_binary_saving_insert_history(drive, path);
+ }
+ break;
+ case EMU_MEDIA_TYPE::BUBBLE_CASETTE :
+ emit sig_ui_bubble_insert_history(drive,
+ path,
+ (quint64)_slot);
+ emit sig_ui_bubble_write_protect(drive,
+ (quint64)(message_type & EMU_MESSAGE_TYPE::WRITE_PROTECT));
+ break;
+ case EMU_MEDIA_TYPE::CARTRIDGE :
+ emit sig_ui_cartridge_insert_history(drive,
+ path);
+ break;
+ case EMU_MEDIA_TYPE::COMPACT_DISC :
+ emit sig_ui_compact_disc_insert_history(drive,
+ path);
+ break;
+ case EMU_MEDIA_TYPE::FLOPPY_DISK :
+ emit sig_ui_floppy_insert_history(drive,
+ path,
+ (quint64)_slot);
+ emit sig_ui_floppy_write_protect(drive,
+ (quint64)(message_type & EMU_MESSAGE_TYPE::WRITE_PROTECT));
+ break;
+ case EMU_MEDIA_TYPE::HARD_DISK :
+ emit sig_ui_hard_disk_insert_history(drive,
+ path);
+ break;
+ case EMU_MEDIA_TYPE::LASER_DISC :
+ emit sig_ui_laser_disc_insert_history(drive,
+ path);
+ break;
+ case EMU_MEDIA_TYPE::QUICK_DISK :
+ // ToDo: Write protect and bank
+ emit sig_ui_quick_disk_insert_history(drive,
+ path);
+ break;
+ case EMU_MEDIA_TYPE::TAPE :
+ if((message_type & EMU_MESSAGE_TYPE::RECORD) != 0) {
+ emit sig_ui_tape_record_insert_history(drive, path);
+ } else {
+ emit sig_ui_tape_play_insert_history(drive, path);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+void OSD_BASE::osdcall_unmount(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type)
+{
+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
+ uint64_t _slot = media_type & 255;
+ switch(_type) {
+ case EMU_MEDIA_TYPE::BINARY :
+ emit sig_ui_binary_closed(drive);
+ break;
+ case EMU_MEDIA_TYPE::BUBBLE_CASETTE :
+ emit sig_ui_binary_closed(drive);
+ break;
+ case EMU_MEDIA_TYPE::CARTRIDGE :
+ emit sig_ui_cartridge_eject(drive);
+ break;
+ case EMU_MEDIA_TYPE::COMPACT_DISC :
+ emit sig_ui_compact_disc_eject(drive);
+ break;
+ case EMU_MEDIA_TYPE::FLOPPY_DISK :
+ emit sig_ui_floppy_close(drive);
+ break;
+ case EMU_MEDIA_TYPE::HARD_DISK :
+ emit sig_ui_hard_disk_close(drive);
+ break;
+ case EMU_MEDIA_TYPE::LASER_DISC :
+ emit sig_ui_laser_disc_eject(drive);
+ break;
+ case EMU_MEDIA_TYPE::QUICK_DISK :
+ emit sig_ui_quick_disk_close(drive);
+ break;
+ case EMU_MEDIA_TYPE::TAPE :
+ // ToDo: close by rec/play.
+ emit sig_ui_tape_eject(drive);
+ break;
+ default:
+ break;
+ }
+}
+
+void OSD_BASE::osdcall_misc(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, QString message_str, int64_t data)
+{
+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
+ uint64_t _slot = media_type & 255;
+
+ switch(_type) {
+ case EMU_MEDIA_TYPE::BINARY :
+ // ToDO : write protect.
+ break;
+ case EMU_MEDIA_TYPE::BUBBLE_CASETTE :
+ emit sig_ui_bubble_write_protect(drive,
+ (quint64)(message_type & EMU_MESSAGE_TYPE::WRITE_PROTECT));
+ break;
+ case EMU_MEDIA_TYPE::CARTRIDGE :
+ // ToDo
+ break;
+ case EMU_MEDIA_TYPE::COMPACT_DISC :
+ // ToDo
+ break;
+ case EMU_MEDIA_TYPE::FLOPPY_DISK :
+ // ToDo
+ emit sig_ui_floppy_write_protect(drive,
+ (quint64)(message_type & EMU_MESSAGE_TYPE::WRITE_PROTECT));
+ break;
+ case EMU_MEDIA_TYPE::HARD_DISK :
+ // ToDo
+ break;
+ case EMU_MEDIA_TYPE::LASER_DISC :
+ // ToDo
+ break;
+ case EMU_MEDIA_TYPE::QUICK_DISK :
+ // ToDo: Write protect and bank
+ break;
+ case EMU_MEDIA_TYPE::TAPE :
+ {
+
+ bool is_pause_unpause = ((message_type & EMU_MESSAGE_TYPE::TOGGLE_PAUSE) != 0) ? true : false;
+
+ if(!(is_pause_unpause)) {
+ switch(message_type & EMU_MESSAGE_TYPE::MEDIA_FFREW_MASK) {
+ case EMU_MESSAGE_TYPE::TAPE_FF:
+ emit sig_ui_tape_push_fast_forward(drive);
+ break;
+ case EMU_MESSAGE_TYPE::TAPE_REW:
+ emit sig_ui_tape_push_fast_rewind(drive);
+ break;
+ case EMU_MESSAGE_TYPE::TAPE_APSS_FF:
+ emit sig_ui_tape_push_apss_forward(drive);
+ break;
+ case EMU_MESSAGE_TYPE::TAPE_APSS_REW:
+ emit sig_ui_tape_push_apss_rewind(drive);
+ break;
+ default:
+ // ToDo: write protect
+ break;
+ }
+ }
+ }
+ break;
+ }
+}
+
void OSD_BASE::string_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, _TCHAR* message)
{
// switch(media_type) {
// case EMU_MEDIA_TYPE::BINARY:
// }
QString tmps;
- uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
- uint64_t _slot = media_type & 255;
- bool is_ui_message = ((media_type & EMU_MEDIA_TYPE::UI_MESSAGE_MASK) != 0) ? true : false;
- if(is_ui_message) {
- // Below are update message to UI.
- return; // ToDo: Implement
- }
-
+ tmps.clear();
// Below are update status to UI.
if(message != nullptr) {
tmps = QString::fromLocal8Bit(message);
}
- switch(_type) {
- case EMU_MEDIA_TYPE::FLOPPY_DISK :
- switch(message_type) {
- // From EMU::open_floppy_disk
- case EMU_MESSAGE_TYPE::MEDIA_MOUNTED :
- emit sig_ui_floppy_insert_history(drive, tmps, _slot);
- break;
- }
+ EMU_MESSAGE_TYPE::type_t message_mode
+ = message_type & EMU_MESSAGE_TYPE::MEDIA_MODE_MASK;
+ switch(message_type & (EMU_MESSAGE_TYPE::TYPE_MASK))
+ {
+ case EMU_MESSAGE_TYPE::TYPE_MESSAGE:
+ osdcall_message_str(media_type, drive, message_type, tmps);
+ break;
+ case EMU_MESSAGE_TYPE::TYPE_MEDIA:
+ switch(message_mode) {
+ case EMU_MESSAGE_TYPE::MEDIA_MOUNTED :
+ osdcall_mount(media_type, drive, message_type, tmps);
break;
- case EMU_MEDIA_TYPE::TAPE :
- switch(message_type) {
- case EMU_MESSAGE_TYPE::MEDIA_MOUNTED :
- emit sig_ui_tape_play_insert_history(drive, tmps);
- break;
- }
+ case EMU_MESSAGE_TYPE::MEDIA_REMOVED :
+ osdcall_unmount(media_type, drive, message_type);
+ break;
+ case EMU_MESSAGE_TYPE::MEDIA_OTHERS :
+ osdcall_misc(media_type, drive, message_type, tmps, INT64_MIN);
break;
+ default:
+ break;
+ }
+ default:
+ break;
}
}
+
void OSD_BASE::int_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, int64_t data)
{
- uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
- uint64_t _slot = media_type & 255;
- bool is_ui_message = ((media_type & EMU_MEDIA_TYPE::UI_MESSAGE_MASK) != 0) ? true : false;
- if(is_ui_message) {
- // Below are update message to UI.
- return; // ToDo: Implement
- }
- switch(_type) {
- case EMU_MEDIA_TYPE::FLOPPY_DISK :
- switch(message_type) {
- // From EMU::close_floppy_disk
- case EMU_MESSAGE_TYPE::MEDIA_REMOVED :
- emit sig_ui_floppy_close(drive);
- break;
- case EMU_MESSAGE_TYPE::MEDIA_WRITE_PROTECT :
- emit sig_ui_floppy_write_protect(drive, data);
- break;
- }
+ EMU_MESSAGE_TYPE::type_t message_mode
+ = message_type & EMU_MESSAGE_TYPE::MEDIA_MODE_MASK;
+ switch(message_type & (EMU_MESSAGE_TYPE::TYPE_MASK))
+ {
+ case EMU_MESSAGE_TYPE::TYPE_MESSAGE:
+ osdcall_message_int(media_type, drive, message_type, data);
+ break;
+ case EMU_MESSAGE_TYPE::TYPE_MEDIA:
+ switch(message_mode) {
+ case EMU_MESSAGE_TYPE::MEDIA_MOUNTED :
+ // ToDo.
break;
+ case EMU_MESSAGE_TYPE::MEDIA_REMOVED :
+ osdcall_unmount(media_type, drive, message_type);
+ break;
+ case EMU_MESSAGE_TYPE::MEDIA_OTHERS :
+ osdcall_misc(media_type, drive, message_type, QString::fromUtf8(""), data);
+ break;
+ default:
+ break;
+ }
+ break;
}
}
virtual int get_vm_buttons_code(int num);
virtual void update_input_mouse();
+ // Messaging.
+ virtual void __FASTCALL osdcall_message_str(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, QString message);
+ virtual void __FASTCALL osdcall_message_int(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, int64_t data);
+ virtual void __FASTCALL osdcall_mount(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, QString path);
+ virtual void __FASTCALL osdcall_unmount(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type);
+ virtual void __FASTCALL osdcall_misc(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, QString message_str, int64_t data);
+
public:
OSD_BASE(std::shared_ptr<USING_FLAGS> p, std::shared_ptr<CSP_Logger> logger);
~OSD_BASE();
OSDN Git Service
