#include <stdio.h>
#include <string>
#include <vector>
+#include <QApplication>
#include <QString>
#include <QTextCodec>
#include <QImage>
#include <QImageReader>
#include <QDateTime>
#include <QDir>
+#include <QTranslator>
+#include <QProcessEnvironment>
+#include <QCommandLineParser>
#include "common.h"
#include "fileio.h"
+#include "config.h"
#include "emu.h"
#include "menuclasses.h"
#include "mainwidget.h"
#include "draw_thread.h"
#include "qt_gldraw.h"
-#include "qt_glutil_gl2_0.h"
+#include "../gui/gl2/qt_glutil_gl2_0.h"
#include "csp_logger.h"
#include "dock_disks.h"
#include "menu_disk.h"
#include "dialog_movie.h"
#include "../avio/movie_saver.h"
// emulation core
+#include "../../vm/fmgen/fmgen.h"
EMU* emu;
QApplication *GuiMain = NULL;
+extern config_t config;
+#if defined(CSP_OS_WINDOWS)
+CSP_Logger DLL_PREFIX_I *csp_logger;
+#else
+extern CSP_Logger *csp_logger;
+#endif
// Start to define MainWindow.
class META_MainWindow *rMainWindow;
#endif
// menu
-extern std::string cpp_homedir;
+extern DLL_PREFIX_I std::string cpp_homedir;
extern DLL_PREFIX_I std::string cpp_confdir;
-extern std::string my_procname;
-std::string sRssDir;
+extern DLL_PREFIX_I std::string my_procname;
+extern DLL_PREFIX_I std::string sRssDir;
bool now_menuloop = false;
static int close_notified = 0;
// timing control
connect(actionSave_State[i], SIGNAL(sig_save_state(QString)), hRunEmu, SLOT(do_save_state(QString))); // OK?
}
}
-#if defined(USE_FD1) || defined(USE_FD2) || defined(USE_FD3) || defined(USE_FD4) || \
- defined(USE_FD5) || defined(USE_FD6) || defined(USE_FD7) || defined(USE_FD8)
+#if defined(USE_FLOPPY_DISK)
connect(this, SIGNAL(sig_write_protect_disk(int, bool)), hRunEmu, SLOT(do_write_protect_disk(int, bool)));
connect(this, SIGNAL(sig_open_disk(int, QString, int)), hRunEmu, SLOT(do_open_disk(int, QString, int)));
connect(this, SIGNAL(sig_close_disk(int)), hRunEmu, SLOT(do_close_disk(int)));
connect(hRunEmu, SIGNAL(sig_update_recent_disk(int)), this, SLOT(do_update_recent_disk(int)));
//connect(hRunEmu, SIGNAL(sig_change_osd_fd(int, QString)), this, SLOT(do_change_osd_fd(int, QString)));
- drvs = 0;
-# if defined(USE_FD1)
- drvs = 1;
-# endif
-# if defined(USE_FD2)
- drvs = 2;
-# endif
-# if defined(USE_FD3)
- drvs = 3;
-# endif
-# if defined(USE_FD4)
- drvs = 4;
-# endif
-# if defined(USE_FD5)
- drvs = 5;
-# endif
-# if defined(USE_FD6)
- drvs = 6;
-# endif
-# if defined(USE_FD7)
- drvs = 7;
-# endif
-# if defined(USE_FD8)
- drvs = 8;
-# endif
+ drvs = USE_FLOPPY_DISK;
for(int ii = 0; ii < drvs; ii++) {
menu_fds[ii]->setEmu(emu);
connect(menu_fds[ii], SIGNAL(sig_update_inner_fd(int ,QStringList , class Action_Control **, QStringList , int, bool)),
this, SLOT(do_update_inner_fd(int ,QStringList , class Action_Control **, QStringList , int, bool)));
}
#endif
-#if defined(USE_TAPE1)
+#if defined(USE_HARD_DISK)
+ connect(this, SIGNAL(sig_open_hard_disk(int, QString)), hRunEmu, SLOT(do_open_hard_disk(int, QString)));
+ connect(this, SIGNAL(sig_close_hard_disk(int)), hRunEmu, SLOT(do_close_hard_disk(int)));
+ connect(hRunEmu, SIGNAL(sig_update_recent_hard_disk(int)), this, SLOT(do_update_recent_hard_disk(int)));
+ //connect(hRunEmu, SIGNAL(sig_change_osd_fd(int, QString)), this, SLOT(do_change_osd_fd(int, QString)));
+#endif
+#if defined(USE_TAPE)
connect(this, SIGNAL(sig_play_tape(int, QString)), hRunEmu, SLOT(do_play_tape(int, QString)));
connect(this, SIGNAL(sig_rec_tape(int, QString)), hRunEmu, SLOT(do_rec_tape(int, QString)));
connect(this, SIGNAL(sig_close_tape(int)), hRunEmu, SLOT(do_close_tape(int)));
connect(this, SIGNAL(sig_cmt_push_apss_rewind(int)), hRunEmu, SLOT(do_cmt_push_apss_rewind(int)));
# endif
#endif
-#if defined(USE_QD1)
+#if defined(USE_QUICK_DISK)
connect(this, SIGNAL(sig_write_protect_quickdisk(int, bool)), hRunEmu, SLOT(do_write_protect_quickdisk(int, bool)));
connect(this, SIGNAL(sig_open_quickdisk(int, QString)), hRunEmu, SLOT(do_open_quickdisk(int, QString)));
connect(this, SIGNAL(sig_close_quickdisk(int)), hRunEmu, SLOT(do_close_quickdisk(int)));
//connect(hRunEmu, SIGNAL(sig_change_osd_qd(int, QString)), this, SLOT(do_change_osd_qd(int, QString)));
#endif
-#if defined(USE_CART1)
+#if defined(USE_CART)
connect(this, SIGNAL(sig_open_cart(int, QString)), hRunEmu, SLOT(do_open_cart(int, QString)));
connect(this, SIGNAL(sig_close_cart(int)), hRunEmu, SLOT(do_close_cart(int)));
#endif
#if defined(USE_COMPACT_DISC)
- connect(this, SIGNAL(sig_open_cdrom(QString)), hRunEmu, SLOT(do_open_cdrom(QString)));
- connect(this, SIGNAL(sig_close_cdrom()), hRunEmu, SLOT(do_eject_cdrom()));
+ connect(this, SIGNAL(sig_open_cdrom(int, QString)), hRunEmu, SLOT(do_open_cdrom(int, QString)));
+ connect(this, SIGNAL(sig_close_cdrom(int)), hRunEmu, SLOT(do_eject_cdrom(int)));
//connect(hRunEmu, SIGNAL(sig_change_osd_cdrom(QString)), this, SLOT(do_change_osd_cdrom(QString)));
+ // ToDo: multiple CDs
#endif
#if defined(USE_LASER_DISC)
- connect(this, SIGNAL(sig_open_laserdisc(QString)), hRunEmu, SLOT(do_open_laser_disc(QString)));
- connect(this, SIGNAL(sig_close_laserdisc(void)), hRunEmu, SLOT(do_close_laser_disc(void)));
+ connect(this, SIGNAL(sig_open_laserdisc(int, QString)), hRunEmu, SLOT(do_open_laser_disc(int, QString)));
+ connect(this, SIGNAL(sig_close_laserdisc(int)), hRunEmu, SLOT(do_close_laser_disc(int)));
+ // ToDo: multiple LDs
#endif
-#if defined(USE_BINARY_FILE1)
+#if defined(USE_BINARY_FILE)
connect(this, SIGNAL(sig_load_binary(int, QString)), hRunEmu, SLOT(do_load_binary(int, QString)));
connect(this, SIGNAL(sig_save_binary(int, QString)), hRunEmu, SLOT(do_save_binary(int, QString)));
#endif
-#if defined(USE_BUBBLE1)
+#if defined(USE_BUBBLE)
connect(this, SIGNAL(sig_write_protect_bubble(int, bool)), hRunEmu, SLOT(do_write_protect_bubble_casette(int, bool)));
connect(this, SIGNAL(sig_open_bubble(int, QString, int)), hRunEmu, SLOT(do_open_bubble_casette(int, QString, int)));
connect(this, SIGNAL(sig_close_bubble(int)), hRunEmu, SLOT(do_close_bubble_casette(int)));
connect(hRunEmu, SIGNAL(sig_update_recent_bubble(int)), this, SLOT(do_update_recent_bubble(int)));
//connect(hRunEmu, SIGNAL(sig_change_osd_bubble(int, QString)), this, SLOT(do_change_osd_bubble(int, QString)));
- drvs = 0;
-# if defined(USE_BUBBLE1)
- drvs = 1;
-# endif
-# if defined(USE_BUBBLE2)
- drvs = 2;
-# endif
+ drvs = USE_BUBBLE;
for(int ii = 0; ii < drvs; ii++) {
menu_bubbles[ii]->setEmu(emu);
connect(menu_bubbles[ii],
#ifdef USE_TAPE_BUTTON
hRunEmu->set_tape_play(false);
#endif
-#if defined(USE_KEY_LOCKED) || defined(USE_EXTRA_LEDS)
+#if defined(USE_KEY_LOCKED) || defined(USE_LED_DEVICE)
connect(hRunEmu, SIGNAL(sig_send_data_led(quint32)), this, SLOT(do_recv_data_led(quint32)));
#endif
#ifdef USE_AUTO_KEY
connect(this, SIGNAL(sig_start_auto_key(QString)), hRunEmu, SLOT(do_start_auto_key(QString)));
connect(this, SIGNAL(sig_stop_auto_key()), hRunEmu, SLOT(do_stop_auto_key()));
+ connect(this, SIGNAL(sig_set_roma_kana(bool)), hRunEmu, SLOT(set_romakana(bool)));
#endif
//connect(actionExit_Emulator, SIGNAL(triggered()), hRunEmu, SLOT(doExit()));
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "EmuThread : Start.");
connect(hDrawEmu, SIGNAL(message_changed(QString)), this, SLOT(message_status_bar(QString)));
connect(actionCapture_Screen, SIGNAL(triggered()), glv, SLOT(do_save_frame_screen()));
- if(using_flags->get_config_ptr()->use_separate_thread_draw) {
+ /*if(config.use_separate_thread_draw) {
connect(hRunEmu, SIGNAL(sig_draw_thread(bool)), hDrawEmu, SLOT(doDraw(bool)), Qt::QueuedConnection);
connect(hRunEmu, SIGNAL(sig_set_draw_fps(double)), hDrawEmu, SLOT(do_set_frames_per_second(double)), Qt::QueuedConnection);
connect(hRunEmu, SIGNAL(sig_draw_one_turn(bool)), hDrawEmu, SLOT(do_draw_one_turn(bool)), Qt::QueuedConnection);
- } else {
+ } else*/ {
connect(hRunEmu, SIGNAL(sig_draw_thread(bool)), hDrawEmu, SLOT(doDraw(bool)));
connect(hRunEmu, SIGNAL(sig_set_draw_fps(double)), hDrawEmu, SLOT(do_set_frames_per_second(double)));
connect(hRunEmu, SIGNAL(sig_draw_one_turn(bool)), hDrawEmu, SLOT(do_draw_one_turn(bool)));
objNameStr = QString("EmuDrawThread");
hDrawEmu->setObjectName(objNameStr);
- if(using_flags->get_config_ptr()->use_separate_thread_draw) hDrawEmu->start();
+ if(config.use_separate_thread_draw) hDrawEmu->start();
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "DrawThread : Launch done.");
- hSaveMovieThread = new MOVIE_SAVER(640, 400, 30, emu->get_osd(), using_flags->get_config_ptr());
+ hSaveMovieThread = new MOVIE_SAVER(640, 400, 30, emu->get_osd(), &config);
connect(actionStart_Record_Movie->binds, SIGNAL(sig_start_record_movie(int)), hRunEmu, SLOT(do_start_record_video(int)));
connect(this, SIGNAL(sig_start_saving_movie()),
hRunEmu->start();
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "EmuThread : Launch done.");
- this->set_screen_aspect(using_flags->get_config_ptr()->window_stretch_type);
+ this->set_screen_aspect(config.window_stretch_type);
emit sig_movie_set_width(SCREEN_WIDTH);
emit sig_movie_set_height(SCREEN_HEIGHT);
}
void Ui_MainWindow::LaunchJoyThread(void)
{
#if defined(USE_JOYSTICK)
- hRunJoy = new JoyThreadClass(emu, emu->get_osd(), using_flags, using_flags->get_config_ptr(), csp_logger);
+ hRunJoy = new JoyThreadClass(emu, emu->get_osd(), using_flags, &config, csp_logger);
connect(this, SIGNAL(quit_joy_thread()), hRunJoy, SLOT(doExit()));
hRunJoy->setObjectName("JoyThread");
hRunJoy->start();
}
#endif
if(statusUpdateTimer != NULL) statusUpdateTimer->stop();
-#if defined(USE_KEY_LOCKED) || defined(USE_EXTRA_LEDS)
+#if defined(USE_KEY_LOCKED) || defined(USE_LED_DEVICE)
if(ledUpdateTimer != NULL) ledUpdateTimer->stop();
#endif
emit quit_draw_thread();
hDrawEmu = NULL;
}
if(hRunEmu != NULL) {
+ OnCloseDebugger();
hRunEmu->quit();
hRunEmu->wait();
delete hRunEmu;
#endif
}
-CSP_Logger *csp_logger;
+QStringList virtualMediaList; // {TYPE, POSITION}
+QCommandLineOption *_opt_fds[8];
+QCommandLineOption *_opt_hdds[8];
+QCommandLineOption *_opt_cmts[2];
+QCommandLineOption *_opt_lds[2];
+QCommandLineOption *_opt_cds[2];
+QCommandLineOption *_opt_binaries[8];
+QCommandLineOption *_opt_bubbles[8];
+QCommandLineOption *_opt_qds[8];
+QCommandLineOption *_opt_carts[8];
+extern QCommandLineOption *_opt_homedir;
+extern QCommandLineOption *_opt_cfgfile;
+extern QCommandLineOption *_opt_cfgdir;
+extern QCommandLineOption *_opt_resdir;
+extern QCommandLineOption *_opt_opengl;
+extern QCommandLineOption *_opt_envver;
+extern QCommandLineOption *_opt_dump_envver;
+extern QCommandLineOption *_opt_dipsw_on;
+extern QCommandLineOption *_opt_dipsw_off;
+extern QProcessEnvironment _envvers;
+bool _b_dump_envver;
+std::string config_fullpath;
+
+void SetFDOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_FLOPPY_DISK)
+ for(int i = 0; i < USE_FLOPPY_DISK; i++) {
+ QString sfdType1 = QString::fromUtf8("fd%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vFd%1").arg(i);
+ QString sfdType3 = QString::fromUtf8("vFloppyDisk%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _cl.append(sfdType3);
+ _opt_fds[i] = new QCommandLineOption(_cl,QCoreApplication::translate("main", "Set virtual floppy disk %1.").arg(i) , "[D88_SLOT@]fullpath");
+ cmdparser->addOption(*_opt_fds[i]);
+ _cl.clear();
+ }
+#endif
+}
+
+void SetHDDOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_HARD_DISK)
+ for(int i = 0; i < USE_HARD_DISK; i++) {
+ QString sfdType1 = QString::fromUtf8("hd%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vHd%1").arg(i);
+ QString sfdType3 = QString::fromUtf8("vHardDisk%1").arg(i);
+ QString sfdType4 = QString::fromUtf8("vHardDrive%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _cl.append(sfdType3);
+ _cl.append(sfdType4);
+ _opt_hdds[i] = new QCommandLineOption(_cl,QCoreApplication::translate("main", "Set virtual hard drive %1.").arg(i) , "[D88_SLOT@]fullpath");
+ cmdparser->addOption(*_opt_hdds[i]);
+ _cl.clear();
+ }
+#endif
+}
-int MainLoop(int argc, char *argv[])
+void SetBinaryOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_BINARY_FILE)
+ for(int i = 0; i < USE_BINARY_FILE; i++) {
+ QString sfdType1 = QString::fromUtf8("bin%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vBinary%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _opt_binaries[i] = new QCommandLineOption(_cl,QCoreApplication::translate("main", "Set virtual binary image %1.").arg(i) , "fullpath");
+ cmdparser->addOption(*_opt_binaries[i]);
+ _cl.clear();
+ }
+#endif
+}
+
+void SetCartOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_CART)
+ for(int i = 0; i < USE_CART; i++) {
+ QString sfdType1 = QString::fromUtf8("cart%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vCart%1").arg(i);
+ QString sfdType3 = QString::fromUtf8("vCartridge%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _cl.append(sfdType3);
+ _opt_carts[i] = new QCommandLineOption(_cl,QCoreApplication::translate("main", "Set virtual cartridge %1 (mostly ROM).").arg(i) , "fullpath");
+ cmdparser->addOption(*_opt_carts[i]);
+ _cl.clear();
+ }
+#endif
+}
+void SetBubbleOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_BUBBLE)
+ for(int i = 0; i < USE_BUBBLE; i++) {
+ QString sfdType1 = QString::fromUtf8("bub%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vBubble%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _opt_bubbles[i] = new QCommandLineOption(_cl,QCoreApplication::translate("main", "Set virtual bubble cartridge %1.").arg(i) , "[B88_SLOT@]fullpath");
+ cmdparser->addOption(*_opt_bubbles[i]);
+ }
+#endif
+}
+
+void SetLDOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_LASER_DISC)
+ for(int i = 0; i < USE_LASER_DISC; i++) {
+ QString sfdType1 = QString::fromUtf8("ld%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vLaserDisc%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _opt_lds[i] = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Set virtual laser disc %1 (mostly movie file).").arg(i) , "fullpath");
+ cmdparser->addOption(*_opt_lds[i]);
+ _cl.clear();
+ }
+#endif
+}
+void SetCDOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_COMPACT_DISC)
+ for(int i = 0; i < USE_COMPACT_DISC; i++) {
+ QString sfdType1 = QString::fromUtf8("cd%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vCompactDisc%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _opt_cds[i] = new QCommandLineOption(_cl,QCoreApplication::translate("main", "Set virtual compact disc %1.").arg(i) , "fullpath");
+ cmdparser->addOption(*_opt_cds[i]);
+ _cl.clear();
+ }
+#endif
+}
+
+void SetCmtOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_TAPE)
+ for(int i = 0; i < USE_TAPE; i++) {
+ QString sfdType1 = QString::fromUtf8("cmt%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("tape%1").arg(i);
+ QString sfdType3 = QString::fromUtf8("vCmt%1").arg(i);
+ QString sfdType4 = QString::fromUtf8("vTape%1").arg(i);
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _cl.append(sfdType3);
+ _cl.append(sfdType4);
+ _opt_cmts[i] = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Set virtual casette tape %1.").arg(i) , "fullpath");
+ cmdparser->addOption(*_opt_cmts[i]);
+ _cl.clear();
+ }
+#endif
+}
+
+void SetQuickDiskOptions(QCommandLineParser *cmdparser)
+{
+#if defined(USE_QUICK_DISK)
+ for(int i = 0; i < USE_QUICK_DISK; i++) {
+ QString sfdType1 = QString::fromUtf8("qd%1").arg(i);
+ QString sfdType2 = QString::fromUtf8("vQuickDisk%1").arg(i);
+
+ QStringList _cl;
+ _cl.append(sfdType1);
+ _cl.append(sfdType2);
+ _opt_qds[i] = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Set virtual quick disk %1.").arg(i) , "fullpath");
+ cmdparser->addOption(*_opt_qds[i]);
+ _cl.clear();
+ }
+#endif
+}
+
+
+void SetProcCmdFD(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_FLOPPY_DISK)
+ for(int i = 0; i < USE_FLOPPY_DISK; i++) {
+ if(_opt_fds[i] != NULL) {
+ if(cmdparser->isSet(*_opt_fds[i])) {
+ QString sfdType = QString::fromUtf8("vFloppyDisk%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_fds[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdHDD(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_HARD_DISK)
+ for(int i = 0; i < USE_HARD_DISK; i++) {
+ if(_opt_hdds[i] != NULL) {
+ if(cmdparser->isSet(*_opt_hdds[i])) {
+ QString sfdType = QString::fromUtf8("vHardDisk%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_hdds[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdQuickDisk(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_QUICK_DISK)
+ for(int i = 0; i < USE_QUICK_DISK; i++) {
+ if(_opt_qds[i] != NULL) {
+ if(cmdparser->isSet(*_opt_qds[i])) {
+ QString sfdType = QString::fromUtf8("vQuickDisk%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_qds[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdCmt(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_TAPE)
+ for(int i = 0; i < USE_TAPE; i++) {
+ if(_opt_cmts[i] != NULL) {
+ if(cmdparser->isSet(*_opt_cmts[i])) {
+ QString sfdType = QString::fromUtf8("vCmt%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_cmts[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdBinary(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_BINARY_FILE)
+ for(int i = 0; i < USE_BINARY_FILE; i++) {
+ if(_opt_binaries[i] != NULL) {
+ if(cmdparser->isSet(*_opt_binaries[i])) {
+ QString sfdType = QString::fromUtf8("vBinary%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_binaries[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdBubble(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_BUBBLE)
+ for(int i = 0; i < USE_BUBBLE; i++) {
+ if(_opt_bubbles[i] != NULL) {
+ if(cmdparser->isSet(*_opt_bubbles[i])) {
+ QString sfdType = QString::fromUtf8("vBubble%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_bubbles[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdCart(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_CART)
+ for(int i = 0; i < USE_CART; i++) {
+ if(_opt_carts[i] != NULL) {
+ if(cmdparser->isSet(*_opt_carts[i])) {
+ QString sfdType = QString::fromUtf8("vCart%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_carts[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdLD(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_LASER_DISC)
+ for(int i = 0; i < USE_LASER_DISC; i++) {
+ if(_opt_lds[i] != NULL) {
+ if(cmdparser->isSet(*_opt_lds[i])) {
+ QString sfdType = QString::fromUtf8("vLD%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_lds[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+void SetProcCmdCD(QCommandLineParser *cmdparser, QStringList *_l)
+{
+#if defined(USE_COMPACT_DISC)
+ for(int i = 0; i < USE_COMPACT_DISC; i++) {
+ if(_opt_cds[i] != NULL) {
+ if(cmdparser->isSet(*_opt_cds[i])) {
+ QString sfdType = QString::fromUtf8("vCD%1").arg(i);
+ QString medianame = cmdparser->value(*_opt_cds[i]);
+ _l->append(sfdType);
+ _l->append(medianame);
+ }
+ }
+ }
+#endif
+}
+
+extern void SetOptions_Sub(QCommandLineParser *cmdparser);
+void SetOptions(QCommandLineParser *cmdparser)
+{
+ QString emudesc = QString::fromUtf8("Emulator for ");
+ emudesc = emudesc + QString::fromUtf8(DEVICE_NAME);
+ cmdparser->setApplicationDescription(emudesc);
+ cmdparser->addHelpOption();
+ //cmdparser->addVersionOption();
+
+ SetOptions_Sub(cmdparser);
+ QStringList _cl;
+
+ for(int i = 0; i < 8; i++) {
+ _opt_fds[i] = NULL;
+ _opt_hdds[i] = NULL;
+ _opt_qds[i] = NULL;
+ _opt_bubbles[i] = NULL;
+ _opt_binaries[i] = NULL;
+ _opt_carts[i] = NULL;
+ }
+ for(int i = 0; i < 2; i++) {
+ _opt_cmts[i] = NULL;
+ _opt_lds[i] = NULL;
+ _opt_cds[i] = NULL;
+ }
+
+ SetFDOptions(cmdparser);
+ SetHDDOptions(cmdparser);
+ //SetBinaryOptions(cmdparser); // Temporally disabled.
+ SetCmtOptions(cmdparser);
+ SetCartOptions(cmdparser);
+ SetBubbleOptions(cmdparser); // Temporally disabled.
+ SetQuickDiskOptions(cmdparser);
+ SetLDOptions(cmdparser); // Temporally disabled.
+ SetCDOptions(cmdparser);
+
+ cmdparser->addOption(*_opt_envver);
+ cmdparser->addOption(*_opt_dump_envver);
+}
+
+extern void ProcessCmdLine_Sub(QCommandLineParser *cmdparser, QStringList *_l);
+
+void ProcessCmdLine(QCommandLineParser *cmdparser, QStringList *_l)
{
char homedir[PATH_MAX];
- std::string archstr;
- std::string emustr("emu");
- std::string cfgstr(CONFIG_NAME);
- setup_logs();
- cpp_homedir.copy(homedir, PATH_MAX - 1, 0);
+ std::string delim;
+#if defined(Q_OS_WIN)
+ delim = "\\";
+#else
+ delim = "/";
+#endif
+ ProcessCmdLine_Sub(cmdparser, _l);
{
char tmps[128];
std::string localstr;
- snprintf(tmps, sizeof(tmps), _T("%s.ini"), _T(CONFIG_NAME));
+ memset(tmps, 0x00, 128);
+ if(cmdparser->isSet(*_opt_cfgfile)) {
+ strncpy(tmps, cmdparser->value(*_opt_cfgfile).toLocal8Bit().constData(), 127);
+ }
+ if(strlen(tmps) <= 0){
+ snprintf(tmps, sizeof(tmps), _T("%s.ini"), _T(CONFIG_NAME));
+ }
localstr = tmps;
localstr = cpp_confdir + localstr;
load_config(localstr.c_str());
+ config_fullpath = localstr;
}
- emustr = emustr + cfgstr;
+ if(cmdparser->isSet(*_opt_opengl)) {
+ char tmps[128] = {0};
+ strncpy(tmps, cmdparser->value(*_opt_opengl).toLocal8Bit().constData(), 128 - 1);
+ if(strlen(tmps) > 0) {
+ QString render = QString::fromLocal8Bit(tmps).toUpper();
+ if((render == QString::fromUtf8("GL2")) ||
+ (render == QString::fromUtf8("GLV2"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_MAIN;
+ config.render_major_version = 2;
+ config.render_minor_version = 0;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, true);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, false);
+ } else if((render == QString::fromUtf8("GL3")) ||
+ (render == QString::fromUtf8("GLV3")) ||
+ (render == QString::fromUtf8("OPENGLV3")) ||
+ (render == QString::fromUtf8("OPENGL")) ||
+ (render == QString::fromUtf8("GL"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_MAIN;
+ config.render_major_version = 3;
+ config.render_minor_version = 0;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, true);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, false);
+ } else if((render == QString::fromUtf8("GLES2")) ||
+ (render == QString::fromUtf8("GLESV2")) ||
+ (render == QString::fromUtf8("GLES3")) ||
+ (render == QString::fromUtf8("GLESV3")) ||
+ (render == QString::fromUtf8("GLES"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_ES;
+ config.render_major_version = 2;
+ config.render_minor_version = 1;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, false);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, true);
+ } else if((render == QString::fromUtf8("GL4")) ||
+ (render == QString::fromUtf8("GL43")) ||
+ (render == QString::fromUtf8("GL4.3")) ||
+ (render == QString::fromUtf8("GL4_3")) ||
+ (render == QString::fromUtf8("GL4_CORE"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_CORE;
+ config.render_major_version = 4;
+ config.render_minor_version = 3;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, true);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, false);
+ }
+ }
+ }
+ SetProcCmdFD(cmdparser, _l);
+ SetProcCmdHDD(cmdparser, _l);
+ SetProcCmdQuickDisk(cmdparser, _l);
+ SetProcCmdCmt(cmdparser, _l);
+ SetProcCmdCart(cmdparser, _l);
+ SetProcCmdBinary(cmdparser, _l);
+ SetProcCmdBubble(cmdparser, _l);
+ SetProcCmdLD(cmdparser, _l);
+ SetProcCmdCD(cmdparser, _l);
- csp_logger = new CSP_Logger(config.log_to_syslog, config.log_to_console, emustr.c_str()); // Write to syslog, console
- csp_logger->set_log_stdout(CSP_LOG_DEBUG, true);
- csp_logger->set_log_stdout(CSP_LOG_INFO, true);
- csp_logger->set_log_stdout(CSP_LOG_WARN, true);
+#if 0
+ memset(homedir, 0x00, PATH_MAX);
+ if(cmdparser->isSet(*_opt_homedir)) {
+ strncpy(homedir, cmdparser->value(*_opt_homedir).toLocal8Bit().constData(), PATH_MAX - 1);
+ cpp_homedir = homedir;
+ size_t _len = cpp_homedir.length() - 1;
+ size_t _pos = cpp_homedir.rfind(delim);
+ if((_pos < _len) ||
+ (_pos == std::string::npos)) {
+ cpp_homedir.append(delim);
+ }
+ } else {
+ cpp_homedir.copy(homedir, PATH_MAX - 1, 0);
+ }
+
+ if(cmdparser->isSet(*_opt_cfgdir)) {
+ char tmps[PATH_MAX];
+ std::string tmpstr;
+ memset(tmps, 0x00, PATH_MAX);
+ strncpy(tmps, cmdparser->value(*_opt_cfgdir).toLocal8Bit().constData(), PATH_MAX - 1);
+ cpp_confdir = tmps;
+ size_t _len = cpp_confdir.length() - 1;
+ size_t _pos = cpp_confdir.rfind(delim);
+ if((_pos < _len) ||
+ (_pos == std::string::npos)) {
+ cpp_confdir.append(delim);
+ }
+ }
- archstr = "Generic";
-#if defined(__x86_64__)
- archstr = "amd64";
-#endif
-#if defined(__i386__)
- archstr = "ia32";
+ {
+ char tmps[128];
+ std::string localstr;
+ memset(tmps, 0x00, 128);
+ if(cmdparser->isSet(*_opt_cfgfile)) {
+ strncpy(tmps, cmdparser->value(*_opt_cfgfile).toLocal8Bit().constData(), 127);
+ }
+ if(strlen(tmps) <= 0){
+ snprintf(tmps, sizeof(tmps), _T("%s.ini"), _T(CONFIG_NAME));
+ }
+ localstr = tmps;
+ localstr = cpp_confdir + localstr;
+ load_config(localstr.c_str());
+ config_fullpath = localstr;
+ }
+ if(cmdparser->isSet(*_opt_resdir)) {
+ char tmps[PATH_MAX];
+ std::string tmpstr;
+ memset(tmps, 0x00, PATH_MAX);
+ strncpy(tmps, cmdparser->value(*_opt_resdir).toLocal8Bit().constData(), PATH_MAX - 1);
+ sRssDir = tmps;
+ size_t _len = sRssDir.length() - 1;
+ size_t _pos = sRssDir.rfind(delim);
+ if((_pos < _len) ||
+ (_pos == std::string::npos)) {
+ sRssDir.append(delim);
+ }
+ }
+ if(cmdparser->isSet(*_opt_opengl)) {
+ char tmps[128] = {0};
+ strncpy(tmps, cmdparser->value(*_opt_opengl).toLocal8Bit().constData(), 128 - 1);
+ if(strlen(tmps) > 0) {
+ QString render = QString::fromLocal8Bit(tmps).toUpper();
+ if((render == QString::fromUtf8("GL2")) ||
+ (render == QString::fromUtf8("GLV2"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_MAIN;
+ config.render_major_version = 2;
+ config.render_minor_version = 0;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, true);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, false);
+ } else if((render == QString::fromUtf8("GL3")) ||
+ (render == QString::fromUtf8("GLV3")) ||
+ (render == QString::fromUtf8("OPENGLV3")) ||
+ (render == QString::fromUtf8("OPENGL")) ||
+ (render == QString::fromUtf8("GL"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_MAIN;
+ config.render_major_version = 3;
+ config.render_minor_version = 0;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, true);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, false);
+ } else if((render == QString::fromUtf8("GLES2")) ||
+ (render == QString::fromUtf8("GLESV2")) ||
+ (render == QString::fromUtf8("GLES3")) ||
+ (render == QString::fromUtf8("GLESV3")) ||
+ (render == QString::fromUtf8("GLES"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_ES;
+ config.render_major_version = 2;
+ config.render_minor_version = 1;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, false);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, true);
+ } else if((render == QString::fromUtf8("GL4")) ||
+ (render == QString::fromUtf8("GL43")) ||
+ (render == QString::fromUtf8("GL4.3")) ||
+ (render == QString::fromUtf8("GL4_3")) ||
+ (render == QString::fromUtf8("GL4_CORE"))) {
+ config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_CORE;
+ config.render_major_version = 4;
+ config.render_minor_version = 3;
+ GuiMain->setAttribute(Qt::AA_UseDesktopOpenGL, true);
+ GuiMain->setAttribute(Qt::AA_UseOpenGLES, false);
+ }
+ }
+ }
+ if(cmdparser->isSet(*_opt_envver)) {
+ QStringList nList = cmdparser->values(*_opt_envver);
+ QString tv;
+ //QProcessEnvironment ev = QProcessEnvironment::systemEnvironment();
+ QProcessEnvironment ev = _envvers;
+ if(nList.size() > 0) {
+ for(int i = 0; i < nList.size(); i++) {
+ tv = nList.at(i);
+ if(tv.indexOf(QString::fromUtf8("-")) == 0) {
+ // Delete var
+ int n1 = tv.indexOf(QString::fromUtf8("="));
+ if(n1 > 0) {
+ tv = tv.left(n1).right(n1 - 1);
+ } else {
+ tv = tv.right(tv.length() - 1);
+ }
+ printf("DEBUG: DEL ENV:%s\n", tv.toLocal8Bit().constData());
+ ev.remove(tv);
+ } else if(tv.indexOf(QString::fromUtf8("=")) > 0) {
+ // Delete var
+ int n1 = tv.indexOf(QString::fromUtf8("="));
+ QString skey;
+ QString sval;
+ skey = tv.left(n1);
+ if((tv.length() - n1) < 1) {
+ sval = QString::fromUtf8("");
+ } else {
+ sval = tv.right(tv.length() - n1 - 1);
+ }
+ printf("DEBUG: SET ENV:%s to %s\n", skey.toLocal8Bit().constData(), sval.toLocal8Bit().constData());
+ if(skey.length() > 0) ev.insert(skey, sval);
+ } else if(tv.indexOf(QString::fromUtf8("=")) < 0) {
+ printf("DEBUG: SET ENV:%s to (NULL)\n", tv.toLocal8Bit().constData());
+ if(tv.length() > 0) ev.insert(tv, QString::fromUtf8(""));
+ }
+ }
+ _envvers.swap(ev);
+ }
+ }
+ _b_dump_envver = false;
+ if(cmdparser->isSet(*_opt_dump_envver)) {
+ _b_dump_envver = true;
+ }
#endif
+ uint32_t dipsw_onbits = 0x0000000;
+ uint32_t dipsw_offmask = 0xffffffff;
+ if(cmdparser->isSet(*_opt_dipsw_off)) {
+ QStringList bitList = cmdparser->values(*_opt_dipsw_off);
+ QString tv;
+ bool num_ok;
+ for(int i = 0; i < bitList.size(); i++) {
+ tv = bitList.at(i);
+ int _bit = tv.toInt(&num_ok);
+ if(num_ok) {
+ if((_bit >= 0) && (_bit < 32)) {
+ dipsw_offmask &= (uint32_t)(~(1 << _bit));
+ }
+ }
+ }
+ }
+ if(cmdparser->isSet(*_opt_dipsw_on)) {
+ QStringList bitList = cmdparser->values(*_opt_dipsw_on);
+ QString tv;
+ bool num_ok;
+ for(int i = 0; i < bitList.size(); i++) {
+ tv = bitList.at(i);
+ int _bit = tv.toInt(&num_ok);
+ if(num_ok) {
+ if((_bit >= 0) && (_bit < 32)) {
+ dipsw_onbits |= (uint32_t)(1 << _bit);
+ }
+ }
+ }
+ }
+ config.dipswitch &= dipsw_offmask;
+ config.dipswitch |= dipsw_onbits;
+}
+
+void OpeningMessage(std::string archstr)
+{
csp_logger->set_emu_vm_name(DEVICE_NAME); // Write to syslog, console
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Start Common Source Project '%s'", my_procname.c_str());
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "(C) Toshiya Takeda / Qt Version K.Ohta");
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Architecture: %s", archstr.c_str());
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Use -h or --help for help.");
//csp_logger->debug_log(AGAR_LOG_INFO, " -? is print help(s).");
- csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Moduledir = %s home = %s", cpp_confdir.c_str(), cpp_homedir.c_str()); // Debug
- /*
- * Into Qt's Loop.
- */
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Home = %s, Resource directory = %s",
+ cpp_homedir.c_str(),
+ sRssDir.c_str()); // Debug
+
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Config dir = %s, config_file = %s",
+ cpp_confdir.c_str(),
+ config_fullpath.c_str()); // Debug
+
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "DIPSW VALUE IS 0x%08x", config.dipswitch);
+ if(virtualMediaList.size() >= 2) {
+ for(int i = 0; i < virtualMediaList.size(); i += 2) {
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Virtual media %d, type %s, name %s",
+ i / 2,
+ virtualMediaList.at(i).toLocal8Bit().constData(),
+ virtualMediaList.at(i + 1).toLocal8Bit().constData());
+ }
+ }
+}
+
+void SetupSDL(void)
+{
+ QStringList _el = _envvers.toStringList();
+ if(_el.size() > 0) {
+ for(int i = 0; i < _el.size(); i++) {
+ QString _s = _el.at(i);
+ if(_s.startsWith("SDL_")) {
+ QString skey, svar;
+ int _nl;
+ _nl = _s.indexOf('=');
+ if(_nl >= 0) {
+ skey = _s.left(_nl);
+ svar = _s.right(_s.length() - _nl);
+ } else {
+ skey = _s;
+ svar = QString::fromUtf8("");
+ }
+ SDL_setenv(skey.toLocal8Bit().constData(), svar.toLocal8Bit().constData(), 1);
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Note: SDL ENVIROMENT : %s to %s.",
+ skey.toLocal8Bit().constData(),
+ svar.toLocal8Bit().constData());
+ }
+ }
+ }
#if defined(USE_SDL2)
SDL_Init(SDL_INIT_AUDIO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
#else
SDL_Init(SDL_INIT_AUDIO | SDL_INIT_JOYSTICK | SDL_INIT_VIDEO);
#endif
csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Audio and JOYSTICK subsystem was initialised.");
- GuiMain = new QApplication(argc, argv);
- GuiMain->setObjectName(QString::fromUtf8("Gui_Main"));
- for(int ii = 0; ii < (CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1); ii++) {
+}
+
+
+void SetupLogger(QObject *parent, std::string emustr, int _size)
+{
+
+ csp_logger = new CSP_Logger(parent, config.log_to_syslog, config.log_to_console, emustr.c_str()); // Write to syslog, console
+ csp_logger->set_log_stdout(CSP_LOG_DEBUG, true);
+ csp_logger->set_log_stdout(CSP_LOG_INFO, true);
+ csp_logger->set_log_stdout(CSP_LOG_WARN, true);
+
+ csp_logger->set_state_log(0, config.state_log_to_recording);
+ csp_logger->set_state_log(1, config.state_log_to_syslog);
+ csp_logger->set_state_log(2, config.state_log_to_console);
+
+ for(int ii = 0; ii < _size; ii++) {
for(int jj = 0; jj < 8; jj++) {
csp_logger->set_device_node_log(ii, 1, jj, config.dev_log_to_syslog[ii][jj]);
csp_logger->set_device_node_log(ii, 2, jj, config.dev_log_to_console[ii][jj]);
csp_logger->set_device_node_log(ii, 0, jj, config.dev_log_recording[ii][jj]);
}
}
- USING_FLAGS_EXT *using_flags = new USING_FLAGS_EXT(&config);
- // initialize emulation core
+}
+
+int MainLoop(int argc, char *argv[])
+{
+
+ std::string archstr;
+ std::string emustr("emu");
+ std::string cfgstr(CONFIG_NAME);
+ std::string delim;
+ QString emudesc;
+
+ setup_logs();
+#if defined(Q_OS_WIN)
+ delim = "\\";
+#else
+ delim = "/";
+#endif
+
+ GuiMain = new QApplication(argc, argv);
+ GuiMain->setObjectName(QString::fromUtf8("Gui_Main"));
+ _envvers = QProcessEnvironment::systemEnvironment();
+
+ QCommandLineParser cmdparser;
+
+ virtualMediaList.clear();
+ SetOptions(&cmdparser);
+
+ cmdparser.process(QCoreApplication::arguments());
+
+ ProcessCmdLine(&cmdparser, &virtualMediaList);
+
+ emustr = emustr + cfgstr;
+
+ SetupLogger(GuiMain, emustr, CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1);
+
+
+ archstr = "Generic";
+#if defined(__x86_64__)
+ archstr = "amd64";
+#endif
+#if defined(__i386__)
+ archstr = "ia32";
+#endif
+ OpeningMessage(archstr);
+ SetupSDL();
+ /*
+ * Into Qt's Loop.
+ */
+ //SetupTranslators();
QTranslator local_translator;
QLocale s_locale;
if(local_translator.load(s_locale, QLatin1String("csp_qt_machine"), QLatin1String("_"), QLatin1String(":/"))) {
if(common_translator.load(s_locale, QLatin1String("csp_qt_common"), QLatin1String("_"), QLatin1String(":/"))) {
GuiMain->installTranslator(&common_translator);
}
+ QTranslator debugger_translator;
+ if(debugger_translator.load(s_locale, QLatin1String("csp_qt_debugger"), QLatin1String("_"), QLatin1String(":/"))) {
+ GuiMain->installTranslator(&debugger_translator);
+ }
+ //QProcessEnvironment::systemEnvironment() = _envvers;
+ if(_b_dump_envver) {
+ //QProcessEnvironment ev = QProcessEnvironment::systemEnvironment();
+ QProcessEnvironment ev = _envvers;
+ QStringList el = _envvers.toStringList();
+ if(el.size() > 0) {
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Environment Variables:");
+ for(int i = 0; i < el.size(); i++) {
+ csp_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "#%d : %s", i, el.at(i).toLocal8Bit().constData());
+ }
+ }
+ }
+ USING_FLAGS_EXT *using_flags = new USING_FLAGS_EXT(&config);
+ // initialize emulation core
rMainWindow = new META_MainWindow(using_flags, csp_logger);
rMainWindow->connect(rMainWindow, SIGNAL(sig_quit_all(void)), rMainWindow, SLOT(deleteLater(void)));
rMainWindow->setCoreApplication(GuiMain);
void Ui_MainWindow::do_update_inner_fd(int drv, QStringList base, class Action_Control **action_select_media_list,
QStringList lst, int num, bool use_d88_menus)
{
-#if defined(USE_FD1)
+#if defined(USE_FLOPPY_DISK)
if(use_d88_menus) {
for(int ii = 0; ii < using_flags->get_max_d88_banks(); ii++) {
if(ii < emu->d88_file[drv].bank_num) {
void Ui_MainWindow::do_update_inner_bubble(int drv, QStringList base, class Action_Control **action_select_media_list,
QStringList lst, int num, bool use_d88_menus)
{
-#if defined(USE_BUBBLE1)
+#if defined(USE_BUBBLE)
if(use_d88_menus) {
for(int ii = 0; ii < using_flags->get_max_b77_banks(); ii++) {
if(ii < emu->b77_file[drv].bank_num) {
//emu->open_debugger(no);
VM *vm = emu->get_vm();
- if((emu->now_debugging ) || (emu->hDebugger != NULL)) this->OnCloseDebugger();
+ if((emu->now_debugging ) || (emu->hDebugger != NULL)) /* OnCloseDebugger(); */ return;
+
if(!(emu->now_debugging && emu->debugger_thread_param.cpu_index == no)) {
//emu->close_debugger();
if(vm->get_cpu(no) != NULL && vm->get_cpu(no)->get_debugger() != NULL) {
emit quit_debugger_thread();
//emu->hDebugger->wait();
}
- delete emu->hDebugger;
- emu->hDebugger = NULL;
- emu->now_debugging = false;
}
+ if(emu != NULL) {
+ if(emu->hDebugger != NULL) {
+ delete emu->hDebugger;
+ emu->hDebugger = NULL;
+ }
+ emu->now_debugging = false;
+ }
}
#endif
+QString Ui_MainWindow::get_system_version()
+{
+ QString guiver = get_gui_version();
+ QString aviover;
+ QString vm_gitver;
+ QString common_vmver;
+ QString osdver;
+ QString libcommon_ver;
+ QString libfmgen_ver;
+ QString build_date;
+
+ QString outstr;
+
+ aviover.clear();
+ common_vmver.clear();
+ vm_gitver.clear();
+ osdver.clear();
+ libcommon_ver.clear();
+
+ if(hSaveMovieThread != NULL) {
+ aviover = hSaveMovieThread->get_avio_version();
+ }
+ if(emu != NULL) {
+ if(emu->get_osd() != NULL) {
+ _TCHAR *cvp = emu->get_osd()->get_lib_common_vm_version();
+ _TCHAR *gvp = emu->get_osd()->get_lib_common_vm_git_version();
+ _TCHAR *ovp = emu->get_osd()->get_lib_osd_version();
+ if(cvp != NULL) {
+ common_vmver = QString::fromUtf8(cvp);
+ }
+ if(gvp != NULL) {
+ vm_gitver = QString::fromUtf8(gvp);
+ }
+ if(ovp != NULL) {
+ osdver = QString::fromUtf8(ovp);
+ }
+ }
+ }
+
+ const _TCHAR *pp = get_lib_common_version();
+ if(pp != NULL) {
+ libcommon_ver = QString::fromUtf8(pp);
+ }
+ libfmgen_ver = QString::fromUtf8(FM::get_libfmgen_version());
+
+ outstr.clear();
+ if(!(common_vmver.isEmpty())) {
+ outstr.append(common_vmver);
+ outstr.append("<BR>\n");
+ }
+ if(!(libcommon_ver.isEmpty())) {
+ outstr.append(libcommon_ver);
+ outstr.append("<BR>\n");
+ }
+ if(!(libfmgen_ver.isEmpty())) {
+ outstr.append(libfmgen_ver);
+ outstr.append("<BR>\n");
+ }
+ if(!(guiver.isEmpty())) {
+ outstr.append(guiver);
+ outstr.append("<BR>\n");
+ }
+ if(!(aviover.isEmpty())) {
+ outstr.append(aviover);
+ outstr.append("<BR>\n");
+ }
+ if(!(vm_gitver.isEmpty())) {
+ outstr.append("Build Version: ");
+ outstr.append(vm_gitver);
+ outstr.append("<BR>\n");
+ }
+ return outstr;
+}
+
+QString Ui_MainWindow::get_build_date()
+{
+#if defined(__BUILD_DATE)
+ return QString::fromUtf8(__BUILD_DATE);
+#else
+ return QString::fromUtf8("");
+#endif
+}
OSDN Git Service
