From: K.Ohta <whatisthis.sowhat@gmail.com>
Date: Thu, 23 Feb 2023 18:09:25 +0000 (+0900)
Subject: [UI][Qt] Fix command line interface.Make processing correct.
X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=22d030dcaf8e87a40af3941decb6ed22a8ff2877;p=csp-qt%2Fcommon_source_project-fm7.git

[UI][Qt] Fix command line interface.Make processing correct.

- This still be unstable around loading and closing Laser Disc.
  Sometime clashs.
---

diff --git a/source/src/qt/CMakeLists.txt b/source/src/qt/CMakeLists.txt
index 61c577b34..f1c16d5a9 100644
--- a/source/src/qt/CMakeLists.txt
+++ b/source/src/qt/CMakeLists.txt
@@ -1,5 +1,5 @@
 message("* qt/osd")
-SET(THIS_LIB_VERSION 9.3.0)
+SET(THIS_LIB_VERSION 9.4.0)
 
 set(s_qt_osd_headers
 	osd_base.h
diff --git a/source/src/qt/avio/CMakeLists.txt b/source/src/qt/avio/CMakeLists.txt
index 947857d7c..2c8c633f7 100644
--- a/source/src/qt/avio/CMakeLists.txt
+++ b/source/src/qt/avio/CMakeLists.txt
@@ -1,6 +1,6 @@
 message("* qt/avio")
 
-SET(THIS_LIB_VERSION 7.6.0)
+SET(THIS_LIB_VERSION 7.6.1)
 set(s_qt_avio_headers
 	csp_avio_basic.h
 	movie_saver.h
diff --git a/source/src/qt/common/emu_thread.cpp b/source/src/qt/common/emu_thread.cpp
index 37fb1532c..408ca0b04 100644
--- a/source/src/qt/common/emu_thread.cpp
+++ b/source/src/qt/common/emu_thread.cpp
@@ -47,7 +47,6 @@ EmuThreadClass::EmuThreadClass(Ui_MainWindowBase *rootWindow, std::shared_ptr<US
 //	connect(this, SIGNAL(sig_open_bubble(int, QString)), MainWindow, SLOT(_open_bubble(int, QString)));
 //	connect(this, SIGNAL(sig_open_b77_bubble(int, QString, int)), this, SLOT(do_open_bubble_casette(int, QString, int)));
 
-
 	p_osd->setParent(this);
 	//p_osd->moveToThread(this);
 	connect(p_osd, SIGNAL(sig_notify_power_off()), this, SLOT(do_notify_power_off()));
@@ -70,7 +69,6 @@ int EmuThreadClass::get_interval(void)
 #include <QStringList>
 #include <QFileInfo>
 
-extern QStringList virtualMediaList; // {TYPE, POSITION}
 
 void EmuThreadClass::resetEmu()
 {
@@ -200,9 +198,9 @@ void EmuThreadClass::doWork(const QString &params)
 		for(int i = 0; i < u_p->get_max_bubble(); i++) bubble_text[i].clear();
 	}
 
-	_queue_begin = parse_command_queue(virtualMediaList, 0);
+//	_queue_begin = parse_command_queue(virtualMediaList);
+//	virtualMediaList.clear();
 	//SDL_SetHint(SDL_HINT_TIMER_RESOLUTION, "2");
-
 	do {
 		//p_emu->SetHostCpus(this->idealThreadCount());
 		// Chack whether using_flags exists.
@@ -244,6 +242,10 @@ void EmuThreadClass::doWork(const QString &params)
 		sleep_period = 0;
 		if(p_emu) {
 			// drive machine
+			if(!(half_count)) { // OK?
+				_queue_begin = parse_command_queue(virtualMediaList);
+				virtualMediaList.clear();
+			}
 			if(bLoadStateReq != false) {
 				loadState();
 				bLoadStateReq = false;
@@ -266,7 +268,6 @@ void EmuThreadClass::doWork(const QString &params)
 				saveState();
 				bSaveStateReq = false;
 			}
-
 			if(!(is_up_null)) {
 			if(u_p->is_use_minimum_rendering()) {
 				if((vert_line_bak != config.opengl_scanline_vert) ||
@@ -306,24 +307,6 @@ void EmuThreadClass::doWork(const QString &params)
 					prevRecordReq = false;
 				}
 			}
-#if defined(USE_LASER_DISC) || defined(USE_MOVIE_PLAYER)
-			if(turn_count < 128) {
-				turn_count++;
-			} else {
-				if(vMovieQueue.size() >= 2) {
-					for(int ii = 0; ii < vMovieQueue.size(); ii += 2) {
-						QString _dom = vMovieQueue.at(ii);
-						QString _path = vMovieQueue.at(ii + 1);
-						bool _num_ok;
-						int _dom_num = _dom.right(1).toInt(&_num_ok);
-						if(!_num_ok) _dom_num = 0;
-						emit sig_open_laser_disc(_dom_num, _path);
-					}
-					vMovieQueue.clear();
-					//turn_count = 0;
-				}
-			}
-#endif
 #if defined(USE_SOUND_VOLUME)
 			for(int ii = 0; ii < USE_SOUND_VOLUME; ii++) {
 				if(bUpdateVolumeReq[ii]) {
@@ -525,6 +508,10 @@ void EmuThreadClass::doWork(const QString &params)
 		}
 //		printf("HALF=%s %dmsec\n", (half_count) ? "YES" : "NO ", tick_timer.elapsed());
 		half_count = !(half_count);
+//		if(!(half_count)) { // OK?
+//			_queue_begin = parse_command_queue(virtualMediaList);
+//			virtualMediaList.clear();
+//		}
 		//SDL_Delay(sleep_period);
 	} while(1);
 _exit:
diff --git a/source/src/qt/common/emu_thread_slots.cpp b/source/src/qt/common/emu_thread_slots.cpp
index 9d1d221b5..1294767c4 100644
--- a/source/src/qt/common/emu_thread_slots.cpp
+++ b/source/src/qt/common/emu_thread_slots.cpp
@@ -204,6 +204,12 @@ void EmuThreadClassBase::do_rec_tape(int drv, QString name)
 		emit sig_change_virtual_media(CSP_DockDisks_Domain_CMT, drv, name);
 	}
 }
+
+void EmuThreadClassBase::do_close_tape_ui(int drv)
+{
+	sub_close_tape_internal(drv);
+}
+
 void EmuThreadClassBase::sub_close_tape_internal(int drv)
 {
 	if(drv < 0) return;
@@ -477,6 +483,10 @@ void EmuThreadClassBase::do_eject_compact_disc()
 	sub_close_compact_disc_internal(drv);
 }
 
+void EmuThreadClassBase::do_close_hard_disk_ui(int drv)
+{
+	sub_close_hard_disk_internal(drv);
+}
 
 void EmuThreadClassBase::sub_close_hard_disk_internal(int drv)
 {
diff --git a/source/src/qt/common/qt_utils.cpp b/source/src/qt/common/qt_utils.cpp
index a54037606..88ebfe32a 100644
--- a/source/src/qt/common/qt_utils.cpp
+++ b/source/src/qt/common/qt_utils.cpp
@@ -19,6 +19,7 @@
 #include <QImageReader>
 #include <QDateTime>
 #include <QDir>
+#include <QMap>
 #include <QTranslator>
 #include <QProcessEnvironment>
 #include <QCommandLineParser>
@@ -781,386 +782,231 @@ static void setup_logs(void)
 #endif
 }
 
-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;
-extern bool _b_dump_envver;
+extern QProcessEnvironment _envvars;
+extern bool _b_dump_envvar;
 extern 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
-}
+extern DLL_PREFIX QList<QCommandLineOption> SetOptions_Sub(QCommandLineParser *parser);
 
-void SetBinaryOptions(QCommandLineParser *cmdparser)
+QCommandLineOption SetOptionsList(unsigned int drive, QStringList src, const QString desc, const QString name, const QString defaultValue)
 {
-#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();
+	QStringList new_s;
+
+	QString _apd = QString::number(drive);
+	for(auto _n = src.begin(); _n != src.end(); ++_n) {
+		new_s.append((*_n) + _apd);
 	}
-#endif
+	QCommandLineOption dst(new_s, desc, name, defaultValue);
+	return dst;
 }
 
-void SetCartOptions(QCommandLineParser *cmdparser)
+QList<QCommandLineOption> SetOptions(QCommandLineParser *cmdparser, QStringList& aliases)
 {
-#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();
+	QString emudesc = QString::fromUtf8("Emulator for ");
+	emudesc = emudesc + QString::fromUtf8(DEVICE_NAME);
+    cmdparser->setApplicationDescription(emudesc);
+    cmdparser->addHelpOption();
+    //cmdparser->addVersionOption();
+
+
+	QList<QCommandLineOption> _ret;
+	QStringList _cl;
+	SetOptions_Sub(cmdparser);
+
+	//
+	const QString _alias_bin     = (const QString)(QString::fromUtf8("vBinary"));
+	const QString _alias_sbin    = (const QString)(QString::fromUtf8("vSaveBinary"));
+	const QString _alias_bubble  = (const QString)(QString::fromUtf8("vBubble"));
+	const QString _alias_cd      = (const QString)(QString::fromUtf8("vCompactDisc"));
+	const QString _alias_cart    = (const QString)(QString::fromUtf8("vCart"));
+	const QString _alias_fdd     = (const QString)(QString::fromUtf8("vFloppy"));
+	const QString _alias_hdd     = (const QString)(QString::fromUtf8("vHardDisk"));
+	const QString _alias_ld      = (const QString)(QString::fromUtf8("vLaserDisc"));
+	const QString _alias_qd      = (const QString)(QString::fromUtf8("vQuickDisk"));
+	const QString _alias_tape    = (const QString)(QString::fromUtf8("vTape"));
+	const QString _alias_stape   = (const QString)(QString::fromUtf8("vSaveCMT"));
+
+	const QStringList _bin_list = {"bin", "vBinary", "vBIN"};
+	const QStringList _save_bin_list = {"sbin", "vSaveBinary", "vSBIN"};
+	const QStringList _bubble_list = {"bub", "vBubble", "vBUB"};
+	const QStringList _cart_list = {"cart", "vCartridge", "vCart", "vCART"};
+	const QStringList _cd_list = {"cd", "vCompactDisc", "vCd", "vCD"};
+	const QStringList _fdd_list = {"fd", "vFd", "vFloppy", "vFloppyDisk", "vFloppyDrive", "vFD", "vFDD"};
+	const QStringList _hdd_list       = {"hd", "vHardDisk", "vHardDrive", "vHD", "vHDD"};
+	const QStringList _ld_list        = {"ld", "vLaserDisc", "vLd", "vLD"};
+	const QStringList _qd_list        = {"qd", "vQuickDisk", "vQd", "vQD"};
+	const QStringList _tape_list      = {"tape", "vTape", "vCasette", "vCMT"};
+	const QStringList _save_tape_list = {"scmt", "vSaveTape", "vSaveCMT", "vSCMT"};
+
+#if defined(USE_BINARY_FILE)
+	for(unsigned int i = 0; i < USE_BINARY_FILE; i++) {
+		QString _alias = _alias_bin;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
+
+		QCommandLineOption _l =
+			SetOptionsList(i, _bin_list,
+						   QCoreApplication::translate("main", "Set virtual BINARY file for LOADING slot %1.").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
+	}
+
+	for(unsigned int i = 0; i < USE_BINARY_FILE; i++) {
+		QString _alias_s = _alias_sbin;
+		_alias_s.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias_s);
+	#if 0
+		QCommandLineOption _ls =
+			SetOptionsList(i, _sbin_list,
+						   QCoreApplication::translate("main", "Set virtual BINARY file for SAVING slot %1.").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_ls);
+	#endif
 	}
 #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]);
+	for(unsigned int i = 0; i < USE_BUBBLE; i++) {
+		QString _alias = _alias_bubble;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
+
+		QCommandLineOption _l =
+			SetOptionsList(i, _bubble_list,
+						   QCoreApplication::translate("main", "Set virtual BUBBLE CASETTE %1.").arg(i),
+						   QCoreApplication::translate("main", "[W@|WP@][SLOT@]PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
 #endif
-}
+#if defined(USE_CART)
+	for(unsigned int i = 0; i < USE_CART; i++) {
+		QString _alias = _alias_cart;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-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();
+		QCommandLineOption _l =
+			SetOptionsList(i, _cart_list,
+						   QCoreApplication::translate("main", "Set virtual ROM CARTRIDGE %1.").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
 #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
-}
+	for(unsigned int i = 0; i < USE_COMPACT_DISC; i++) {
+		QString _alias = _alias_cd;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-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();
+		QCommandLineOption _l =
+			SetOptionsList(i, _cd_list,
+						   QCoreApplication::translate("main", "Set virtual COMPACT DISC %1 to FILE.").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
 #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);
+#if defined(USE_FLOPPY_DISK)
+	for(unsigned int i = 0; i < USE_FLOPPY_DISK; i++) {
+		QString _alias = _alias_fdd;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-		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();
+		QCommandLineOption _l =
+			SetOptionsList(i, _fdd_list,
+						   QCoreApplication::translate("main", "Set virtual FLOPPY DISK %1.").arg(i),
+						   QCoreApplication::translate("main", "[W@|WP@][SLOT@]PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
 #endif
-}
-
+#if defined(USE_HARD_DISK)
+	for(unsigned int i = 0; i < USE_HARD_DISK; i++) {
+		QString _alias = _alias_hdd;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-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);
-			}
-		}
+		QCommandLineOption _l =
+			SetOptionsList(i, _hdd_list,
+						   QCoreApplication::translate("main", "Set virtual HARD DISK DRIVE %1 .").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
 #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);
-			}
-		}
+#if defined(USE_LASER_DISC)
+	// ToDo: Fix working around LASER DISC correctly. 20230224 K.O.
+	for(unsigned int i = 0; i < USE_LASER_DISC; i++) {
+		QString _alias = _alias_ld;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
+
+		QCommandLineOption _l =
+			SetOptionsList(i, _ld_list,
+						   QCoreApplication::translate("main", "Set virtual LASER DISC %1.").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
 #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
-}
+	for(unsigned int i = 0; i < USE_QUICK_DISK; i++) {
+		QString _alias = _alias_qd;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-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
-}
+		QCommandLineOption _l =
+			SetOptionsList(i, _qd_list,
+						   QCoreApplication::translate("main", "Set virtual QUICK DISK %1"),
+						   QCoreApplication::translate("main", "[W@|WP@][SLOT@]PATH"), QString::fromUtf8(""));
 
-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);
-			}
-		}
+		_ret.append(_l);
 	}
 #endif
-}
+#if defined(USE_TAPE)
+	for(unsigned int i = 0; i < USE_TAPE; i++) {
+		QString _alias = _alias_tape;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-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);
-			}
-		}
+		QCommandLineOption _l =
+			SetOptionsList(i, _tape_list,
+						   QCoreApplication::translate("main", "Set virtual CASETTE TAPE %1 for loading.").arg(i),
+						   QCoreApplication::translate("main", "PATH"), QString::fromUtf8(""));
+		_ret.append(_l);
 	}
-#endif
-}
+	for(unsigned int i = 0; i < USE_TAPE; i++) {
+		QString _alias = _alias_stape;
+		_alias.append(QString::fromUtf8("%1").arg(i));
+		aliases.append(_alias);
 
-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
-}
+		QCommandLineOption _l =
+			SetOptionsList(i, _save_tape_list,
+						   QCoreApplication::translate("main", "Set virtual CASETTE TAPE %1 for SAVING.").arg(i),
+						   QCoreApplication::translate("main", "[W@|WP@][SLOT@]PATH"), QString::fromUtf8(""));
 
-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);
-			}
-		}
+		_ret.append(_l);
 	}
 #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);
-			}
-		}
+	if(cmdparser != nullptr) {
+		cmdparser->addOptions(_ret);
 	}
-#endif
+	return _ret;
 }
 
-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);
+extern void ProcessCmdLine_Sub(QCommandLineParser *cmdparser);
 
-void ProcessCmdLine(QCommandLineParser *cmdparser, QStringList *_l)
+void ProcessCmdLine(QCommandLineParser *cmdparser, const QStringList vmedialist, QMap<QString, QString>& dstlist)
 {
-	char homedir[PATH_MAX];
+	char homedir[_MAX_PATH] = {0};
 	std::string delim;
 #if defined(Q_OS_WIN)
 	delim = "\\";
 #else
 	delim = "/";
 #endif
-	ProcessCmdLine_Sub(cmdparser, _l);
+	ProcessCmdLine_Sub(cmdparser);
 	{
-		char tmps[128];
+		char tmps[128] = {0};
 		std::string localstr;
-		memset(tmps, 0x00, 128);
-		if(cmdparser->isSet(*_opt_cfgfile)) {
-			strncpy(tmps, cmdparser->value(*_opt_cfgfile).toLocal8Bit().constData(), 127);
+		if(cmdparser->isSet("cfgfile")) {
+			strncpy(tmps, cmdparser->value("cfgfile").toLocal8Bit().constData(), 127);
 		}
 		if(strlen(tmps) <= 0){
 			my_stprintf_s(tmps, sizeof(tmps) - 1, _T("%s.ini"), _T(CONFIG_NAME));
@@ -1170,51 +1016,63 @@ void ProcessCmdLine(QCommandLineParser *cmdparser, QStringList *_l)
 		load_config(localstr.c_str());
 		config_fullpath = localstr;
 	}
-	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;
-			} 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;
-			} else if((render == QString::fromUtf8("GLES2")) ||
-					  (render == QString::fromUtf8("GLESV2")) ||
-					  (render == QString::fromUtf8("ESV2")) ||
-					  (render == QString::fromUtf8("ES2")) ||
-					  (render == QString::fromUtf8("ES")) ||
-					  (render == QString::fromUtf8("GLES"))) {
-				config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_ES;
-				config.render_major_version = 2;
-				config.render_minor_version = 1;
-			} else if((render == QString::fromUtf8("GLES3")) ||
-					  (render == QString::fromUtf8("GLESV3")) ||
-					  (render == QString::fromUtf8("ESV3")) ||
-					  (render == QString::fromUtf8("ES3"))) {
-				config.render_platform = CONFIG_RENDER_PLATFORM_OPENGL_ES;
-				config.render_major_version = 3;
-				config.render_minor_version = 1;
-			} 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;
-			}
+	QString rendervalue = QString::fromUtf8("");
+	const QStringList fixedGLList = {"gl2", "gl3", "gl4", "gl43", "gl46", "gles2", "gles3" };
+	for(auto _gl = fixedGLList.begin(); _gl != fixedGLList.end(); ++_gl) {
+		if(cmdparser->isSet((*_gl))) {
+			rendervalue = (*_gl);
+			break;
+		}
+	}
+	const QStringList fixedGLList_v2  = { "gl2", "glv2", "v2", "2", "openglv2" };
+	const QStringList fixedGLList_v3  = { "gl3", "glv3", "v3", "3", "openglv3", "opengl", "gl" };
+	const QStringList fixedGLList_v4  = { "gl4", "glv4", "4", "openglv4"};
+	const QStringList fixedGLList_v43 = { "gl43", "glv43", "openglv43" "gl4_3", "4.3", "4_3"};
+	const QStringList fixedGLList_v46 = { "gl46", "glv46", "openglv46" "gl4_6", "4.6", "4_6"};
+	const QStringList fixedGLList_es2 = { "gles2", "glesv2", "gles", "es2", "esv2", "es" };
+	const QStringList fixedGLList_es3 = { "gles3", "glesv3", "esv3", "es3" };
+	if(rendervalue.isEmpty()) {
+		QString tmps = cmdparser->value("render");
+		if(fixedGLList_v2.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gl2");
+		} else if(fixedGLList_v3.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gl3");
+		} else if(fixedGLList_v4.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gl4");
+		} else if(fixedGLList_v43.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gl43");
+		} else if(fixedGLList_v46.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gl46");
+		} else if(fixedGLList_es2.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gles2");
+		} else if(fixedGLList_es3.contains(tmps, Qt::CaseInsensitive)) {
+			rendervalue = QString::fromUtf8("gles3");
+		} else {
+			rendervalue = tmps.toLower();
 		}
 	}
+	typedef struct x_s {
+		int type;
+		int major;
+		int minor;
+	} x_t;
+	QMap <QString, x_t> _glmap;
+	_glmap.insert(QString::fromUtf8("gl2"),  {CONFIG_RENDER_PLATFORM_OPENGL_MAIN, 2, 0});
+	_glmap.insert(QString::fromUtf8("gl3"),  {CONFIG_RENDER_PLATFORM_OPENGL_MAIN, 3, 0});
+	_glmap.insert(QString::fromUtf8("gl4"),  {CONFIG_RENDER_PLATFORM_OPENGL_CORE, 4, 3});
+	_glmap.insert(QString::fromUtf8("gl43"), {CONFIG_RENDER_PLATFORM_OPENGL_CORE, 4, 3});
+	_glmap.insert(QString::fromUtf8("gl46"), {CONFIG_RENDER_PLATFORM_OPENGL_CORE, 4, 6});
+	_glmap.insert(QString::fromUtf8("gles2"), {CONFIG_RENDER_PLATFORM_OPENGL_ES, 2, 1});
+	_glmap.insert(QString::fromUtf8("gles3"), {CONFIG_RENDER_PLATFORM_OPENGL_ES, 3, 0});
+
+	x_t _t = {CONFIG_RENDER_PLATFORM_OPENGL_ES, 2, 1};
+	if(_glmap.contains(rendervalue)) {
+		_t = _glmap.value(rendervalue);
+	}
+	config.render_platform = _t.type;
+	config.render_major_version = _t.major;
+	config.render_minor_version = _t.minor;
+
 	switch(config.render_platform) {
 	case CONFIG_RENDER_PLATFORM_OPENGL_MAIN:
 	case CONFIG_RENDER_PLATFORM_OPENGL_CORE:
@@ -1236,20 +1094,11 @@ void ProcessCmdLine(QCommandLineParser *cmdparser, QStringList *_l)
 		break;
 	}
 
-	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);
 
 	uint32_t dipsw_onbits = 0x0000000;
 	uint32_t dipsw_offmask = 0xffffffff;
-	if(cmdparser->isSet(*_opt_dipsw_off)) {
-		QStringList bitList = cmdparser->values(*_opt_dipsw_off);
+	if(cmdparser->isSet("offbit")) {
+		QStringList bitList = cmdparser->values("offbit");
 		QString tv;
 		bool num_ok;
 		for(int i = 0; i < bitList.size(); i++) {
@@ -1262,8 +1111,8 @@ void ProcessCmdLine(QCommandLineParser *cmdparser, QStringList *_l)
 			}
 		}
 	}
-	if(cmdparser->isSet(*_opt_dipsw_on)) {
-		QStringList bitList = cmdparser->values(*_opt_dipsw_on);
+	if(cmdparser->isSet("onbit")) {
+		QStringList bitList = cmdparser->values("onbit");
 		QString tv;
 		bool num_ok;
 		for(int i = 0; i < bitList.size(); i++) {
@@ -1278,9 +1127,19 @@ void ProcessCmdLine(QCommandLineParser *cmdparser, QStringList *_l)
 	}
 	config.dipswitch &= dipsw_offmask;
 	config.dipswitch |= dipsw_onbits;
+
+	// Virtual Medias
+	for(auto __l = vmedialist.begin(); __l != vmedialist.end(); ++__l) {
+		if(cmdparser->isSet(*__l)) {
+			QString tmps = *__l;
+			if(!(tmps.isEmpty())) {
+				dstlist.insert(tmps, cmdparser->value(tmps));
+			}
+		}
+	}
 }
 
-void OpeningMessage(std::shared_ptr<CSP_Logger>p_logger, std::string archstr)
+void OpeningMessage(std::shared_ptr<CSP_Logger>p_logger, std::string archstr, const QMap<QString, QString> virtualMediaList)
 {
 	p_logger->set_emu_vm_name(DEVICE_NAME); // Write to syslog, console
 	p_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Start Common Source Project '%s'", my_procname.c_str());
@@ -1298,19 +1157,18 @@ void OpeningMessage(std::shared_ptr<CSP_Logger>p_logger, std::string archstr)
 						  config_fullpath.c_str()); // Debug
 
 	p_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) {
-			p_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());
-		}
+	QList<QString> __keys = virtualMediaList.keys();
+	for(auto __s = __keys.begin(); __s != __keys.end(); ++__s) {
+		QString __val = virtualMediaList.value(*__s);
+		p_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Virtual media :%s, name %s",
+							(*__s).toLocal8Bit().constData(),
+							__val.toLocal8Bit().constData());
 	}
 }
 
 void SetupSDL(std::shared_ptr<CSP_Logger>p_logger)
 {
-	QStringList _el = _envvers.toStringList();
+	QStringList _el = _envvars.toStringList();
 
 	if(_el.size() > 0) {
 		for(int i = 0; i < _el.size(); i++) {
@@ -1386,9 +1244,10 @@ int MainLoop(int argc, char *argv[])
 	GuiMain = new QApplication(argc, argv);
 	GuiMain->setObjectName(QString::fromUtf8("Gui_Main"));
     QCommandLineParser cmdparser;
+	QStringList vmedia_aliases;
 
-	virtualMediaList.clear();
-	SetOptions(&cmdparser);
+	vmedia_aliases.clear();
+	SetOptions(&cmdparser, vmedia_aliases);
 
 	QStringList arglist;
 	if(argv != NULL) {
@@ -1408,17 +1267,20 @@ int MainLoop(int argc, char *argv[])
 	emustr = emustr + cfgstr;
 	std::shared_ptr<USING_FLAGS> using_flags = std::shared_ptr<USING_FLAGS>(new USING_FLAGS_EXT(&config));
 	cmdparser.process(arglist);
-	ProcessCmdLine(&cmdparser, &virtualMediaList);
 
-	_envvers = QProcessEnvironment::systemEnvironment();
+	QMap<QString, QString> virtualMediaList;
+	virtualMediaList.clear();
+
+	ProcessCmdLine(&cmdparser, (const QStringList)vmedia_aliases, virtualMediaList);
+
+	_envvars = QProcessEnvironment::systemEnvironment();
 
 	std::shared_ptr<CSP_Logger>p_logger = std::shared_ptr<CSP_Logger>(new CSP_Logger(GuiMain, config.log_to_syslog, config.log_to_console, emustr.c_str()));
 	set_debug_logger(p_logger);
 	SetupLogger(p_logger, GuiMain, emustr, CSP_LOG_TYPE_VM_DEVICE_END - CSP_LOG_TYPE_VM_DEVICE_0 + 1);
-	OpeningMessage(p_logger, archstr);
+	OpeningMessage(p_logger, archstr, (const QMap<QString, QString>)virtualMediaList);
 	SetupSDL(p_logger);
 
-
 	/*
 	 * Into Qt's Loop.
 	 */
@@ -1443,11 +1305,11 @@ int MainLoop(int argc, char *argv[])
 	if(debugger_translator.load(s_locale, "debugger", ".", ":/", ".qm")) {
 		GuiMain->installTranslator(&debugger_translator);
 	}
-	//QProcessEnvironment::systemEnvironment() = _envvers;
-	if(_b_dump_envver) {
+	//QProcessEnvironment::systemEnvironment() = _envvars;
+	if(_b_dump_envvar) {
 		//QProcessEnvironment ev = QProcessEnvironment::systemEnvironment();
-		QProcessEnvironment ev = _envvers;
-		QStringList el = _envvers.toStringList();
+		QProcessEnvironment ev = _envvars;
+		QStringList el = _envvars.toStringList();
 		if(el.size() > 0) {
 			p_logger->debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_GENERAL, "Environment Variables:");
 			for(int i = 0; i < el.size(); i++) {
@@ -1465,6 +1327,8 @@ int MainLoop(int argc, char *argv[])
 	rMainWindow->retranselateUi_Depended_OSD();
 //	QMetaObject::connectSlotsByName(rMainWindow);
    	EmuThreadClass *hRunEmu_Real = new EmuThreadClass(rMainWindow, using_flags);
+	hRunEmu_Real->setVirtualMediaList((const QMap<QString, QString>)virtualMediaList);
+
 	OSD_BASE* p_osd = hRunEmu_Real->get_emu()->get_osd();
 
 	QObject::connect((OSD*)p_osd, SIGNAL(sig_update_device_node_name(int, const _TCHAR *)),
diff --git a/source/src/qt/emuutils/CMakeLists.txt b/source/src/qt/emuutils/CMakeLists.txt
index eb54e1773..477c56b57 100644
--- a/source/src/qt/emuutils/CMakeLists.txt
+++ b/source/src/qt/emuutils/CMakeLists.txt
@@ -1,6 +1,6 @@
 message("* qt/emuutils")
 
-SET(THIS_LIB_VERSION 7.11.1)
+SET(THIS_LIB_VERSION 7.12.0)
 
 set(s_qt_emuutils_headers
 	../gui/csp_logger.h
diff --git a/source/src/qt/gui/CMakeLists.txt b/source/src/qt/gui/CMakeLists.txt
index ab41f2f3c..4c3e92921 100644
--- a/source/src/qt/gui/CMakeLists.txt
+++ b/source/src/qt/gui/CMakeLists.txt
@@ -1,6 +1,6 @@
 message("* qt/gui")
 
-set(THIS_LIB_VERSION 8.7.0)
+set(THIS_LIB_VERSION 8.8.0)
 
 set(s_qt_gui_headers
 	  qt_dialogs.h
diff --git a/source/src/qt/gui/emu_thread_tmpl.cpp b/source/src/qt/gui/emu_thread_tmpl.cpp
index da85bc485..7c6b6c140 100644
--- a/source/src/qt/gui/emu_thread_tmpl.cpp
+++ b/source/src/qt/gui/emu_thread_tmpl.cpp
@@ -23,6 +23,7 @@
 #include "qt_gldraw.h"
 #include "common.h"
 #include "dock_disks.h"
+#include "../../osdcall_types.h"
 
 #include "./virtualfileslist.h"
 #include "menu_metaclass.h"
@@ -67,7 +68,6 @@ EmuThreadClassBase::EmuThreadClassBase(Ui_MainWindowBase *rootWindow, std::share
 	skip_frames = 0;
 	calc_message = true;
 	mouse_flag = false;
-	vMovieQueue.clear();
 
 	drawCond = new QWaitCondition();
 //	keyMutex = new QMutex(QMutex::Recursive);
@@ -94,6 +94,7 @@ EmuThreadClassBase::EmuThreadClassBase(Ui_MainWindowBase *rootWindow, std::share
 	}
 	connect(this, SIGNAL(sig_draw_finished()), rootWindow->getGraphicsView(), SLOT(releaseKeyCode(void)));
 	connect(this, SIGNAL(sig_emu_finished()), rootWindow->getGraphicsView(), SLOT(deleteLater()));
+	virtualMediaList.clear();
 
 	QMutexLocker _n(&keyMutex);
 
@@ -372,88 +373,166 @@ void EmuThreadClassBase::do_update_volume_balance(int num, int level)
 		}
 	}
 }
+int EmuThreadClassBase::parse_drive(QString key)
+{
+	int index = 0;
+	for(int i = (key.size() - 1); i != 0; --i) {
+		if((key.at(i) < '0') || (key.at(i) > '9')) break;
+		index++;
+	}
+	if(index <= 0) return 0;
+	if(index > 2) index = 2;
+	QString s = key.right(index);
+	return s.toInt();
+}
 
-int EmuThreadClassBase::parse_command_queue(QStringList _l, int _begin)
-{
-	int _ret = _l.size() / 2;
-	for(int i = _begin * 2; i < _l.size(); i+= 2) {
-		QString _dom = _l.at(i);
-		QString _file = _l.at(i + 1);
-		QString _dom_type = _dom.left(_dom.size() - 1);
-		int _dom_num;
-		bool _num_ok;
-		_dom_num = _dom.right(1).toInt(&_num_ok);
-		if(_num_ok) {
-			if((_dom_type == QString::fromUtf8("vFloppyDisk")) ||
-			   (_dom_type == QString::fromUtf8("vBubble"))) {
-				int _n = _file.indexOf(QString::fromUtf8("@"));
-				int _slot = 0;
-				QFileInfo fileInfo;
-				if((_n > 0) && (_n < 4)) {
-					_slot = _file.left(_n).toInt(&_num_ok);
-					if(_num_ok) {
-						fileInfo = QFileInfo(_file.right(_file.size() - (_n + 1)));
-					} else {
-						fileInfo = QFileInfo(_file);
-						_slot = 0;
-					}
+void EmuThreadClassBase::parse_file(QString val, QString& filename)
+{
+	ssize_t check_at = val.lastIndexOf(QString::fromUtf8("@"));
+	if((check_at < 0) || (check_at >= (val.size() - 1))) { // Not Found
+		filename = val;
+	} else {
+		QString tmps = val.right(check_at + 1);
+		filename = tmps;
+	}
+}
+
+void EmuThreadClassBase::parse_file_slot(QString val, QString& filename, bool& protect_changed, bool& is_protected, int& slot )
+{
+	ssize_t check_at = val.lastIndexOf(QString::fromUtf8("@"));
+	protect_changed = false;
+	if((check_at < 0) || (check_at >= (val.size() - 1))) { // Not Found
+		filename = val;
+	} else {
+		QString tmps = val.right(check_at + 1);
+		filename = tmps;
+		ssize_t _at2 = val.indexOf(QString::fromUtf8("@"));
+		while((_at2 < val.size()) && (_at2 >= 0))  {
+			ssize_t _at3 = val.indexOf(QString::fromUtf8("@"), _at2 + 1);
+			if(_at3 <= (_at2 + 1)) {
+				break;
+			}
+			QString tmps2 = val.mid(_at2 + 1, _at3 - _at2);
+			if(!(tmps2.isEmpty())) {
+				if(tmps2.toLower() == QString::fromUtf8("wp")) {
+					is_protected = true;
+					protect_changed = true;
+				} else if(tmps2.toLower() == QString::fromUtf8("w")) {
+					is_protected = false;
+					protect_changed = true;
 				} else {
-					fileInfo = QFileInfo(_file);
-					_slot = 0;
-				}
-				if(fileInfo.isFile()) {
-					const _TCHAR *path_shadow = (const _TCHAR *)(fileInfo.absoluteFilePath().toLocal8Bit().constData());
-					if(_dom_type == QString::fromUtf8("vFloppyDisk")) {
-						if(check_file_extension(path_shadow, ".d88") || check_file_extension(path_shadow, ".d77")) {
-
-							emit sig_change_virtual_media(CSP_DockDisks_Domain_FD, _dom_num, fileInfo.absoluteFilePath());;
-						} else {
-							emit sig_open_fd(_dom_num, fileInfo.absoluteFilePath());
-							emit sig_change_virtual_media(CSP_DockDisks_Domain_FD, _dom_num, fileInfo.absoluteFilePath());;
-						}
-					} else 	if(_dom_type == QString::fromUtf8("vHardDisk")) {
-						emit sig_open_hdd(_dom_num, fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_HD, _dom_num, fileInfo.absoluteFilePath());;
-					} else if(_dom_type == QString::fromUtf8("vBubble")) {
-						if(check_file_extension(path_shadow, ".b77")) {
-							emit sig_open_b77_bubble(_dom_num, fileInfo.absoluteFilePath(), _slot);
-							emit sig_change_virtual_media(CSP_DockDisks_Domain_Bubble, _dom_num, fileInfo.absoluteFilePath());;
-						} else {
-							emit sig_open_bubble(_dom_num, fileInfo.absoluteFilePath());
-							emit sig_change_virtual_media(CSP_DockDisks_Domain_Bubble, _dom_num, fileInfo.absoluteFilePath());;
-						}
+					bool _ok;
+					int _t = tmps.toInt(&_ok);
+					if(_ok) {
+						slot = _t & EMU_MEDIA_TYPE::EMU_SLOT_MASK;
 					}
 				}
-			} else {
-				QFileInfo fileInfo = QFileInfo(_file);
-				if(fileInfo.isFile()) {
-					if(_dom_type == QString::fromUtf8("vQuickDisk")) {
-						emit sig_open_quick_disk(_dom_num, fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_QD, _dom_num, fileInfo.absoluteFilePath());;
-				} else if(_dom_type == QString::fromUtf8("vCmt")) {
-						emit sig_open_cmt_load(_dom_num, fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_CMT, _dom_num, fileInfo.absoluteFilePath());;
-					} else if(_dom_type == QString::fromUtf8("vBinary")) {
-						emit sig_open_binary_load(_dom_num, fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_Binary, _dom_num, fileInfo.absoluteFilePath());;
-					} else if(_dom_type == QString::fromUtf8("vCart")) {
-						emit sig_open_cart(_dom_num, fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_Cart, _dom_num, fileInfo.absoluteFilePath());;
-					} else if(_dom_type == QString::fromUtf8("vLD")) {
-						vMovieQueue.append(_dom);
-						vMovieQueue.append(fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_LD, _dom_num, fileInfo.absoluteFilePath());;
-						//emit sig_open_laser_disc(_dom_num, fileInfo.absoluteFilePath());
-					} else if(_dom_type == QString::fromUtf8("vCD")) {
-						emit sig_open_cdrom(_dom_num, fileInfo.absoluteFilePath());
-						emit sig_change_virtual_media(CSP_DockDisks_Domain_CD, _dom_num, fileInfo.absoluteFilePath());;
-					}
+			}
+			_at2 = _at3;
+		}
+	}
+}
+
+int EmuThreadClassBase::parse_command_queue(QMap<QString, QString> __list)
+{
+	int _ret = 0;
+	for(auto _s = __list.constBegin(); _s != __list.constEnd(); ++_s) {
+		QString _key = _s.key();
+		QString _val = _s.value();
+		printf("%s %s\n", _key.toLocal8Bit().constData(), _val.toLocal8Bit().constData());
+		int slot = 0;
+		QString _file = QString::fromUtf8("");
+		bool is_protected = false;
+		bool protect_changed = false;
+		if(!(_key.isEmpty())) {
+			int drv = parse_drive(_key);
+			if(_key.contains("vBinary", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_load_binary(drv, _file);
+				_ret++;
+			} else if(_key.contains("vSaveBinary", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_save_binary(drv, _file);
+				_ret++;
+			} else if(_key.contains("vBubble", Qt::CaseInsensitive)) {
+				parse_file_slot(_val, _file, protect_changed, is_protected, slot);
+				do_open_bubble_casette(drv, _file, slot);
+				if(protect_changed) {
+					do_write_protect_bubble_casette(drv, is_protected);
+				}
+				_ret++;
+			} else if(_key.contains("vCart", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_open_cartridge(drv, _file);
+				_ret++;
+			} else if(_key.contains("vCompactDisc", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_open_compact_disc(drv, _file);
+				_ret++;
+			} else if(_key.contains("vFloppy", Qt::CaseInsensitive)) {
+				parse_file_slot(_val, _file, protect_changed, is_protected, slot);
+				do_open_floppy_disk(drv, _file, slot);
+				if(protect_changed) {
+					do_write_protect_floppy_disk(drv, is_protected);
+				}
+				_ret++;
+			} else if(_key.contains("vHardDisk", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_open_hard_disk(drv, _file);
+				_ret++;
+			} else if(_key.contains("vLaserDisc", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_open_laser_disc(drv, _file);
+				_ret++;
+			} else if(_key.contains("vQuickDisk", Qt::CaseInsensitive)) {
+				parse_file_slot(_val, _file, protect_changed, is_protected, slot);
+				do_open_quick_disk(drv, _file);
+				if(protect_changed) {
+					do_write_protect_quick_disk(drv, is_protected);
+				}
+				_ret++;
+			} else if(_key.contains("vTape", Qt::CaseInsensitive)) {
+				parse_file(_val, _file);
+				do_play_tape(drv, _file);
+				_ret++;
+			} else if(_key.contains("vSaveCMT", Qt::CaseInsensitive)) {
+				parse_file_slot(_val, _file, protect_changed, is_protected, slot);
+				if(!(is_protected) && (protect_changed)) {
+					do_rec_tape(drv, _file);
 				}
+				_ret++;
+			} else if(_key.contains("vCloseBubble", Qt::CaseInsensitive)) {
+				do_close_bubble_casette_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseCart", Qt::CaseInsensitive)) {
+				do_close_cartridge_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseCompactDisc", Qt::CaseInsensitive)) {
+				do_eject_compact_disc_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseFloppy", Qt::CaseInsensitive)) {
+				do_close_floppy_disk_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseHardDisk", Qt::CaseInsensitive)) {
+				do_close_hard_disk_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseLaserDisc", Qt::CaseInsensitive)) {
+				do_close_laser_disc_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseQuickDisk", Qt::CaseInsensitive)) {
+				do_close_quick_disk_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseTape", Qt::CaseInsensitive)) {
+				do_close_tape_ui(drv);
+				_ret++;
+			} else if(_key.contains("vCloseSaveCMT", Qt::CaseInsensitive)) {
+				do_close_tape_ui(drv);
+				_ret++;
 			}
+			// ToDo: Write Protect
+			// ToDo: Choose SLOT
 		}
 	}
-	_ret = _ret - _begin;
-	if(_ret < 0) _ret = 0;
 	return _ret;
 }
 
diff --git a/source/src/qt/gui/emu_thread_tmpl.h b/source/src/qt/gui/emu_thread_tmpl.h
index 896e8f2d5..780533ba8 100644
--- a/source/src/qt/gui/emu_thread_tmpl.h
+++ b/source/src/qt/gui/emu_thread_tmpl.h
@@ -15,6 +15,8 @@
 #include <QString>
 #include <QStringList>
 #include <QElapsedTimer>
+#include <QMap>
+
 #if QT_VERSION >= 0x051400
 	#include <QRecursiveMutex>
 #else
@@ -75,6 +77,8 @@ protected:
 	EMU_TEMPLATE *p_emu;
 	OSD_BASE *p_osd;
 
+	QMap<QString, QString> virtualMediaList;
+
 	bool poweroff_notified;
 
 	bool now_skip;
@@ -154,12 +158,11 @@ protected:
 	QString bubble_text[16];
 
 	QString clipBoardText;
-	QStringList vMovieQueue;
 
 	// Standard 8 files.
 	void calc_volume_from_balance(int num, int balance);
 	void calc_volume_from_level(int num, int level);
-	int parse_command_queue(QStringList _l, int _begin);
+	int parse_command_queue(QMap<QString, QString> __list);
 
 	void button_pressed_mouse_sub(Qt::MouseButton button);
 	void button_released_mouse_sub(Qt::MouseButton button);
@@ -239,6 +242,11 @@ protected:
 	void sub_close_laser_disc_internal(int drv);
 	void sub_close_quick_disk_internal(int drv);
 	void sub_close_tape_internal(int drv);
+
+	int parse_drive(QString key);
+	void parse_file(QString val, QString& filename);
+	void parse_file_slot(QString val, QString& filename, bool& protect_changed, bool& is_protected, int& slot );
+
 public:
 	EmuThreadClassBase(Ui_MainWindowBase *rootWindow, std::shared_ptr<USING_FLAGS> p, QObject *parent = 0);
 	~EmuThreadClassBase();
@@ -249,7 +257,18 @@ public:
 	bool now_debugging();
 
 	EMU_TEMPLATE *get_emu() { return p_emu; }
-
+	void addVirtualMediaList(const QString key, const QString value)
+	{
+		virtualMediaList.insert(key, value);
+	}
+	ssize_t setVirtualMediaList(const QMap<QString, QString>value)
+	{
+		virtualMediaList.clear();
+		for(auto _i = value.constBegin(); _i != value.constEnd(); ++_i) {
+			virtualMediaList.insert(_i.key(), _i.value());
+		}
+		return virtualMediaList.count();
+	}
 	int get_d88_file_cur_bank(int drive);
 	int get_d88_file_bank_num(int drive);
 	QString get_d88_file_disk_name(int drive, int banknum);
@@ -300,11 +319,13 @@ public slots:
 	void do_close_floppy_disk_ui(int drive);
 
 	void do_close_hard_disk();
-	void do_open_hard_disk(int, QString);
+	void do_close_hard_disk_ui(int drv);
+	void do_open_hard_disk(int drv, QString fname);
 
 	void do_play_tape(int drv, QString name);
 	void do_rec_tape(int drv, QString name);
 	void do_close_tape();
+	void do_close_tape_ui(int drv);
 
 	void do_cmt_push_play();
 	void do_cmt_push_stop();
@@ -320,7 +341,6 @@ public slots:
 	void do_close_quick_disk_ui(int drv);
 	void do_open_quick_disk(int drv, QString path);
 
-
 	void do_open_cartridge(int drv, QString path);
 	void do_close_cartridge();
 	void do_close_cartridge_ui(int drv);
diff --git a/source/src/qt/gui/qt_main.cpp b/source/src/qt/gui/qt_main.cpp
index b5be60b25..a7b544382 100644
--- a/source/src/qt/gui/qt_main.cpp
+++ b/source/src/qt/gui/qt_main.cpp
@@ -56,84 +56,102 @@ void get_short_filename(_TCHAR *dst, _TCHAR *file, int maxlen)
 	return;
 }
 
-QCommandLineOption *_opt_homedir;
-QCommandLineOption *_opt_cfgfile;
-QCommandLineOption *_opt_cfgdir;
-QCommandLineOption *_opt_resdir;
-QCommandLineOption *_opt_opengl;
-QCommandLineOption *_opt_envver;
-QCommandLineOption *_opt_dump_envver;
-QCommandLineOption *_opt_dipsw_on;
-QCommandLineOption *_opt_dipsw_off;
-QProcessEnvironment _envvers;
-
-bool _b_dump_envver;
+QProcessEnvironment _envvars;
+
+bool _b_dump_envvar;
 std::string config_fullpath;
 
-DLL_PREFIX void SetOptions_Sub(QCommandLineParser *cmdparser)
+DLL_PREFIX QList<QCommandLineOption> SetOptions_Sub(QCommandLineParser *parser)
 {
+	QList<QCommandLineOption> _ret;
 	QStringList _cl;
     _cl.append("d");
     _cl.append("homedir");
-    _opt_homedir = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Custom home directory."), "homedir");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Custom home directory."), QCoreApplication::translate("main", "DIRECTORY PATH")));
     _cl.clear();
-   
+
     _cl.append("c");
     _cl.append("cfgfile");
-    _opt_cfgfile = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Custom config file (without path)."), "cfgfile");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Custom config file (without path)."), QCoreApplication::translate("main", "PATH")));
     _cl.clear();
-   
-    _opt_cfgdir = new QCommandLineOption("cfgdir", QCoreApplication::translate("main", "Custom config directory."), "cfgdir");
+
 
     _cl.append("r");
     _cl.append("res");
-    _opt_resdir = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Custom resource directory (ROMs, WAVs, etc)."), "resdir");
+    _cl.append("resdir");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Custom resource directory (ROMs, WAVs, etc)."), QCoreApplication::translate("main", "DIRECTORY PATH")));
     _cl.clear();
 
     _cl.append("on");
     _cl.append("dipsw-on");
-    _opt_dipsw_on = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Turn on <onbit> of dip switch."), "onbit");
+    _cl.append("onbit");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Turn on <onbit> of dip switch."), QCoreApplication::translate("main", "Bit to SET")));
     _cl.clear();
-   
+
     _cl.append("off");
     _cl.append("dipsw-off");
-    _opt_dipsw_off = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Turn off <offbit> of dip switch."), "offbit");
+    _cl.append("offbit");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Turn off <offbit> of dip switch."), QCoreApplication::translate("main", "Bit to RESET")));
     _cl.clear();
-	
+
     _cl.append("g");
     _cl.append("gl");
     _cl.append("opengl");
     _cl.append("render");
-    _opt_opengl = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type."), "{  GL2 | GL | GL3 | GL4 | GL4_CORE | GLES | ES2 | ES3}");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type."), "render", QCoreApplication::translate("main", "Renderer TYPE")));
     _cl.clear();
-	
+
+    _ret.append(QCommandLineOption("gl2", QCoreApplication::translate("main", "Force set using renderer type to OpenGL v2.")));
+    _ret.append(QCommandLineOption("gl3", QCoreApplication::translate("main", "Force set using renderer type to OpenGL v3(main profile).")));
+
+    _cl.append("gl4");
+    _cl.append("gl4core");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type to OpenGL v4(core profile).")));
+	_cl.clear();
+
+    _cl.append("gl43");
+    _cl.append("gl4_3");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type to OpenGL v4.3(core profile).")));
+	_cl.clear();
+    _cl.append("gl46");
+    _cl.append("gl4_6");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type to OpenGL v4.6(core profile).")));
+	_cl.clear();
+
+    _cl.append("gles");
+    _cl.append("gles2");
+    _cl.append("es2");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type to OpenGL ESv2.")));
+	_cl.clear();
+
+    _cl.append("gles3");
+    _cl.append("es3");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Force set using renderer type to OpenGL ESv3.")));
+	_cl.clear();
+
     _cl.append("v");
     _cl.append("env");
-    _cl.append("envver");
-    _opt_envver = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Set / Delete environment variable."), "{NAME[=VAL] | -NAME}");
+    _cl.append("envvar");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Set / Delete environment variable."), QCoreApplication::translate("main", "NAME=VALUE")));
     _cl.clear();
 
     _cl.append("dump-env");
-    _cl.append("dump-envver");
-    _opt_dump_envver = new QCommandLineOption(_cl, QCoreApplication::translate("main", "Dump environment variables."), "");
+    _cl.append("dump-envvar");
+    _ret.append(QCommandLineOption(_cl, QCoreApplication::translate("main", "Dump environment variables.")));
     _cl.clear();
 
-    cmdparser->addOption(*_opt_opengl);
-    cmdparser->addOption(*_opt_homedir);
-    cmdparser->addOption(*_opt_cfgfile);
-    cmdparser->addOption(*_opt_cfgdir);
-    cmdparser->addOption(*_opt_resdir);
-    cmdparser->addOption(*_opt_dipsw_on);
-    cmdparser->addOption(*_opt_dipsw_off);
+	if(parser != nullptr) {
+		parser->addOptions(_ret);
+	}
+	return _ret;
 }
 
-DLL_PREFIX void ProcessCmdLine_Sub(QCommandLineParser *cmdparser, QStringList *_l)
+DLL_PREFIX void ProcessCmdLine_Sub(QCommandLineParser *cmdparser)
 {
-	char homedir[PATH_MAX];
+	char homedir[_MAX_PATH] = {0};
 	std::string delim;
-	memset(homedir, 0x00, PATH_MAX);
-	if(cmdparser->isSet(*_opt_homedir)) {
-		strncpy(homedir, cmdparser->value(*_opt_homedir).toLocal8Bit().constData(), PATH_MAX - 1);
+	if(cmdparser->isSet("homedir")) {
+		strncpy(homedir, cmdparser->value("homedir").toLocal8Bit().constData(), _MAX_PATH - 1);
 		cpp_homedir = homedir;
 		size_t _len = cpp_homedir.length() - 1;
 		size_t _pos = cpp_homedir.rfind(delim);
@@ -142,14 +160,13 @@ DLL_PREFIX void ProcessCmdLine_Sub(QCommandLineParser *cmdparser, QStringList *_
 			cpp_homedir.append(delim);
 		}
 	} else {
-		cpp_homedir.copy(homedir, PATH_MAX - 1, 0);
+		cpp_homedir.copy(homedir, _MAX_PATH - 1, 0);
 	}
 
-	if(cmdparser->isSet(*_opt_cfgdir)) {
-		char tmps[PATH_MAX];
+	if(cmdparser->isSet("cfgfile")) {
+		char tmps[_MAX_PATH] = {0};
 		std::string tmpstr;
-		memset(tmps, 0x00, PATH_MAX);
-		strncpy(tmps, cmdparser->value(*_opt_cfgdir).toLocal8Bit().constData(), PATH_MAX - 1);
+		strncpy(tmps, cmdparser->value("cfgfile").toLocal8Bit().constData(), _MAX_PATH - 1);
 		cpp_confdir = tmps;
 		size_t _len = cpp_confdir.length() - 1;
 		size_t _pos = cpp_confdir.rfind(delim);
@@ -158,11 +175,10 @@ DLL_PREFIX void ProcessCmdLine_Sub(QCommandLineParser *cmdparser, QStringList *_
 			cpp_confdir.append(delim);
 		}
 	}
-	if(cmdparser->isSet(*_opt_resdir)) {
-		char tmps[PATH_MAX];
+	if(cmdparser->isSet("resdir")) {
+		char tmps[_MAX_PATH] = {0};
 		std::string tmpstr;
-		memset(tmps, 0x00, PATH_MAX);
-		strncpy(tmps, cmdparser->value(*_opt_resdir).toLocal8Bit().constData(), PATH_MAX - 1);
+		strncpy(tmps, cmdparser->value("resdir").toLocal8Bit().constData(), _MAX_PATH - 1);
 		sRssDir = tmps;
 		size_t _len = sRssDir.length() - 1;
 		size_t _pos = sRssDir.rfind(delim);
@@ -171,12 +187,12 @@ DLL_PREFIX void ProcessCmdLine_Sub(QCommandLineParser *cmdparser, QStringList *_
 			sRssDir.append(delim);
 		}
 	}
-	
-	if(cmdparser->isSet(*_opt_envver)) {
-		QStringList nList = cmdparser->values(*_opt_envver);
+
+	if(cmdparser->isSet("envvar")) {
+		QStringList nList = cmdparser->values("envvar");
 		QString tv;
 		//QProcessEnvironment ev = QProcessEnvironment::systemEnvironment();
-		QProcessEnvironment ev = _envvers;
+		QProcessEnvironment ev = _envvars;
 		if(nList.size() > 0) {
 			for(int i = 0; i < nList.size(); i++) {
 				tv = nList.at(i);
@@ -208,11 +224,11 @@ DLL_PREFIX void ProcessCmdLine_Sub(QCommandLineParser *cmdparser, QStringList *_
 					if(tv.length() > 0) ev.insert(tv, QString::fromUtf8(""));
 				}
 			}
-			_envvers.swap(ev);
+			_envvars.swap(ev);
 		}
 	}
-	_b_dump_envver = false;
-	if(cmdparser->isSet(*_opt_dump_envver)) {
-		_b_dump_envver = true;
+	_b_dump_envvar = false;
+	if(cmdparser->isSet("dump-envvar")) {
+		_b_dump_envvar = true;
 	}
 }
diff --git a/source/src/vm/common_vm/CMakeLists.txt b/source/src/vm/common_vm/CMakeLists.txt
index 5c8b459f4..2a85940db 100644
--- a/source/src/vm/common_vm/CMakeLists.txt
+++ b/source/src/vm/common_vm/CMakeLists.txt
@@ -1,6 +1,6 @@
 message("* vm/common_vm")
 
-SET(THIS_LIB_VERSION 7.6.5)
+SET(THIS_LIB_VERSION 7.6.6)
 
 #include(cotire)
 set(s_vm_common_vm_srcs
diff --git a/source/src/vm/fmgen/CMakeLists.txt b/source/src/vm/fmgen/CMakeLists.txt
index d53eb8baf..0933d237e 100644
--- a/source/src/vm/fmgen/CMakeLists.txt
+++ b/source/src/vm/fmgen/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required (VERSION 3.0)
 
 message("* vm/fmgen")
-SET(THIS_LIB_VERSION 5.5.5)
+SET(THIS_LIB_VERSION 5.5.6)
 add_definitions(-D__LIBFMGEN_VERSION=\"libCSPfmgen.${THIS_LIB_VERSION}\")
 
 SET(s_vm_fmgen_srcs